Easy way to force an extending class to set multiple values

Question

Example, let's say from a game:

public class Enemy {
    protected int x, y;
    protected int width, height;
    protected int hitpoints;
    protected int speed;
}

I want to have multiple classes extending this one (one for every enemy type) but I need to make sure (preferably force this) somehow that the extending class assigns values to all of these variables.

I don't want to pass them through a constructor call or set them in it - so currently I'm forced to do this by simply copying the entire decelerations into every class and assigning them values in the same line.

Is there perhaps a more efficient way to do this? (Sorry if the question is somewhat vague..)

Thanks in advance.

Edit - This is how I would create an extending class:

public class Skeleton extends Enemy {
    protected int x, y;
    protected int width, height;
    protected int hitpoints;
    protected int speed;
}

Answer 1

One alternative to Jordão's answer would be to use the builder pattern:

public class SkeletonBuilder
{
    private int x, y, width, height...;        
    public SkeletonBuilder withCoords(int x, int y) { this.x = x; this.y = y; }
    public SkeletonBuilder withSize(int width, int height) { this.width = width; this.height = height; }
    ...

    public Skeleton build() { return new Skeleton(x, y, width, height); }
}

public class Skeleton
{
    /* package */ Skeleton(int x, int y, int width, int height, ...)
}

// game code

Skeleton skeleton = new SkeletonBuilder().withCoords(1, 4).withSize(2, 30).build();

If some of the params could be defaulted then set them up in the SkeletonBuilder constructor. If the other params are required, then you could either set a boolean flag in the builder, or use boxed objects, and fail in the build() method if they're not set.

Answer 2

To both force the subclasses to set the values in the constructor and to make the constructor call readable, you're going to have to write a lot more code in the superclass. This is one way I could think about it (just showing x and y):

abstract class Enemy {
  protected int x, y;

  protected Enemy(X x, Y y) {
    this.x = x.value;
    this.y = y.value;
  }

  protected static class X {
    private final int value;
    private X(int value) { this.value = value; }
  }
  protected static class Y {
    private final int value;
    private Y(int value) { this.value = value; }
  }
  protected static X x(int value) { return new X(value); }
  protected static Y y(int value) { return new Y(value); }
}

class Skeleton extends Enemy {
  public Skeleton() {
    super(x(12), y(13));
  }
}

UPDATE: if it makes sense to have composite types that encapsulate related values, they can make the code better:

class Skeleton extends Enemy {
  public Skeleton() {
    super(position(12, 13), size(300, 300), ...);
  }
}

Answer 3

Your class Skeleton should not declare the same variables as set in Enemy.

As to your question, the simplest option is to make the variables final, and then set them in a constructor. The compiler will enforce that they are all set.

Answer 4

I think you should create a Type interface

interface Type
{
    int getX();
    int getY();
    int getWidth() ;
    int getHeight();
    int getHitpoints();
    int getSpeed();
}

Then the compiler will do the enforcement work.

Answer 5

Based on the comments (and although I would go with a constructor on the superclass) one way to go at it would be to declare the Enemy class as abstract (which probably should be if you just want to define common behaviour there) and initialize the variables as calls to abstract methods. This way the extending classes would be forced to implement those methods and in essence initialize the variables.

Here's a simplified example:

public abstract class Enemy {
    protected int x = getX();
    protected int y = getY();

    protected abstract int getX();
    protected abstract int getY();
}

public class Skeleton extends Enemy {
    @Override
    protected int getX() { return 10; }

    @Override
    protected int getY() { return 10; }
}

Its more verbose, but perhaps it achieves the readability you are looking for.