Let's say I have an abstract class Character that have fields health and maxHealth. maxHealth differs between subclasses. However, the first way I implemented it the health is always initialized as equals to maxHealth.

public abstract class Character 
 protected Vector position;
 protected int health;
 protected int maxHealth;

 public Character(float xLocation, float yLocation)
 Vector position = new Vector(xLocation, yLocation);
 health = maxHealth;
 


public class Grunt extends Character 
 public Grunt(float xLocation, float yLocation)
 super(xLocation, yLocation);
 maxHealth = 200; 
 

But this didn't work correctly because health is assigned to maxHealth before maxHealth was initialized as 200.

I tried to change constructor parameters as follows and it works but I'm not sure that if this is a good practice. What do you think?

public abstract class Character 
 protected Vector position;
 protected int health;
 protected int maxHealth;

 public Character(float xLocation, float yLocation, int maxHealth)
 Vector position = new Vector(xLocation, yLocation);
 this.maxHealth = maxHealth;
 health = maxHealth;
 


public class Grunt extends Character 
 public Grunt(float xLocation, float yLocation)
 super(xLocation, yLocation, 200);
 

Another way, to be able to change the value later is to use a setter. MaxHealth could change in case of any bonus you might implements.

public void setMaxHealt(int maxHealth)
 this.maxHealth = maxHealth;
 this.health = maxHealth;

And in the constructor, simply use the setter.

public Grunt(float xLocation, float yLocation)
 super(xLocation, yLocation);
 setMaxHealth(200);

Using the constructor is fine, and is a good solution to be honest but when you will find constructor with 20 parameters... you will need other solution.

Note :

Since I said this could be nice to add this setter for a bonus, if you don't want to "heal" your character if is health wasn't full, you can simply check before change the value if this.health == this.maxHealth and set the value based on that.

Instead of questioning whether it is a good practice, it would be more helpful to be aware of what your first code actually does. JLS §15.9.4 has this to say about the creation of an object:

The new object contains new instances of all the fields declared in the specified class type and all its superclasses. As each new field instance is created, it is initialized to its default value (§4.12.5).

This means that health and maxHealth are initialized to 0 even before the constructor is executed. So your statement health = maxHealth; is completely pointless, because health is only assigned the default value which is already assigned to it.

I see no problem with your second version (apart from the usage of a non-existent Vector constructor, which I already hinted at in a comment). Every field is initialized in the constructor of the class in which it is declared, which, although not strictly necessary for non-final fields, still makes the code easier to read because you don't have to jump around classes to understand the fields' initializations.

Also, the class Vector is antiquated. If you don't need synchronization, you'd be better off with an ArrayList (and if you do, there are still better solutions as explained in the link). Besides, you are using a raw type, thereby denying the additional type-safety provided by generics.

Edit

Actually, there is a problem in both of your versions that I hadn't spotted earlier: Your constructors never assign a value to the instance variable position. Instead, they declare a local variable with the name position that hides the instance variable. To rectify this, you need to remove the type declaration Vector from the assignment, so that this:

Vector position = new Vector(xLocation, yLocation); //declares a local variable unrelated to `Character.position`

Becomes this:

position = new Vector(xLocation, yLocation); //refers to Character.position