如何使用与封装相同的方法实现多个子类？

Question

I want to create a simple game in Java. I'm struggling to understand how to use inheritance to accomplish how to implement subclasses that use encapsulation without needing to write out the same methods in the subclasses.

Ideally I'd like to make one base class "character" with a bunch of methods that use encapsulation, so that I can just declare different values for the private members of the subclasses. So something like,

public class Character {
private int hitPoints;
public int getHitPoints(){return hitPoints;}
}

And then just declare different values for the variables.

public class subCharacter extends Character {
private int hitPoints=100;
//getHitPoints() already inherited and should return 100
}

But to properly get the hit points of the subclass. I have to declare the same method in the subclass to actually get the method to work.

So isn't encapsulation incompatible with inheritance? Is there something basic here I'm misunderstanding or completely overlooking?

Answer 1

You should make the variable hitPoints protected in you Character class, and set it to 100 in the constructor of the subCharacter class. There is no need for the declaration of the getHitPoints method in the subclass. The code would look like this:

public class Character {
    protected int hitPoints;
    public int getHitPoints(){return hitPoints;}

}

public class subCharacter extends Character {
    public subCharacter () {
        hitPoints = 100;
    }
}

Example of a subCharacter object:

subCharacter sub = new subCharacter();
System.out.println(sub.getHitPoints()); // prints 100

Answer 2

The reason this doesn't work like you think it should is because the subclass's hitpoints field is different from the superclass's hitpoints field. So while the superclass method is defined, it's trying to refer to a variable that you never actually initialized because it's not the same variable named hitpoints .

As others have already said, you should use the protected access modifier instead of the private access modifier on fields you want to have inherited to a subclass.

Then again, you probably don't actually need the SubCharacter class to begin with, if this is what you're actually writing for. You just need to have a constructor that takes a variable argument for hitpoints, or any other field in Character that needs to take different values.

//I'm not going to reproduce everything.
Character(int hp, String nm, boolean someBooleanThatIJustMadeUpToGetTheConceptAcross){
    hitpoints = hp;
    name = nm;
    randomBoolean = someBooleanThatIJustMadeUpToGetTheConceptAcross;
}

This is not to say, however, that you don't need a superclass/subclass if, say, you're using this Character class for both enemies and player characters, for instance.

For an example of when you'd use inheritance...

public class Circle{
protected int radius;
Circle(){//It's always a good idea to have default constructors, by the way.
        radius = 1;
    }
Circle(int rad){
        radius = rad;
    }
}

public class Wheel extends Circle{
    protected int numspokes;
    Wheel(){
        super(); //Calls the constructor for Circle, instead of reimplementing the wheel.  badpuns++;.
        numspokes = 0;
    }
    Wheel(int rad, int spokes){
         super(rad); //This passes the radius up to the Circle this Wheel also is, so that any calls to this Wheel AS IF IT WAS a Circle, like an array or ArrayList of Circles, will function, which is the point of inheritance.
         numspokes = spokes;
    }
}