从Java中的抽象类强制实例变量实现

Question

I am trying to design an abstract class which will enforce implementation of an instance variable even though the type if this instance variable is unknown at the abstract level. For example:

public abstract class AbstractDiet{
    abstract void computeMeat()
    abstract void computeVeggies()
    …
}

public abstract class AbstractAnimal{
    protected AbstractDiet diet;
    …   
}

Then I'd like users to implement something like:

public class Cat extends AbstractAnimal{
    protected CatFoodDiet diet;   // CatFoodDiet extends AbstractDiet
    …
}

Is this the best way to implement the diet variable? I want to ENFORCE that a subclass of AbstractDiet is always implemented in a subclass of AbstractAnimal.

Answer 1

You can't (and shouldn't) approach the design like that. Using abstract classes, try something like this:

public abstract class AbstractDiet {
    abstract void compute();
}
public abstract class AbstractAnimal<T extends AbstractDiet> { 
    protected T diet;
}
public class CatFoodDiet extends AbstractDiet {
    compute() {
        //
    }
}
public class Cat extends AbstractAnimal<CatFoodDiet> {
    // use field in super which is type CatFoodDiet
}

But typically you would use interfaces instead of abstract classes for the abstract types.

Answer 2

First of all: Keep your instance variables private, and provide accessor methods.

Second of all: It sounds like you are trying to define an interface. Use an interface any time you want to say something like, "every animal has a diet."

interface Animal {
    Diet getDiet();
    ...
 }

If you like, you can also incorporate Bohemian's idea, and make it generic.

interface Animal<D extends Diet> {
    D getDiet();
    ...
}

That way, you will have maximum freedom when it comes time to define different kinds of animal

class Cat implements Animal<CatDiet> {
    CatDiet getDiet() { return...; }
}

Answer 3

The most flexible way is to just require the subclass to provide the information:

public abstract class AbstractAnimal {
    // Subclasses must provide a function that returns the diet
    public abstract AbstractDiet getDiet();
}

public class PetRock extends AbstractAnimal {
    @Override
    public AbstractDiet getDiet() {
        return new SunlightDiet();
    }
}

If you want to force a particular implementation, this is a common way:

public abstract class AbstractAnimal {
    private AbstractDiet diet;

    // Provide a constructor that sets a diet
    protected AbstractAnimal(AbstractDiet aDiet) {
        if (null == aDiet)
            throw new NullPointerException("Diet must be specified");
        diet = aDiet;
}

public class PetRock extends AbstractAnimal {
    public PetRock() {
        // Subclasses have to provide a diet to the superclass
        super(new SunlightDiet());
    }
}