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

我正在尝试设计一个抽象类，它将强制实现一个实例变量，即使该实例变量的类型在抽象级别未知。例如：

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

public abstract class AbstractAnimal{
    protected AbstractDiet diet;
    …   
}

然后，我希望用户实现如下功能：

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

这是实现

diet

变量的最佳方法吗？我想强调AbstractDiet的子类总是在AbstractAnimal的子类中实现的

你不能（也不应该）这样对待设计。使用抽象类，尝试以下操作：

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
}

公共抽象类AbstractDiet{
抽象void compute（）；
}
公共抽象类AbstractAnimal{
保护性T型饮食；
}
公共类CatFoodDiet扩展了抽象饮食{
计算（）{
//
}
}
公营猫科动物{
//super中的use字段类型为CatFoodDiet
}

但是，对于抽象类型，您通常会使用接口而不是抽象类。

您不能（也不应该）这样处理设计。使用抽象类，尝试以下操作：

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
}

公共抽象类AbstractDiet{
抽象void compute（）；
}
公共抽象类AbstractAnimal{
保护性T型饮食；
}
公共类CatFoodDiet扩展了抽象饮食{
计算（）{
//
}
}
公营猫科动物{
//super中的use字段类型为CatFoodDiet
}

但是，对于抽象类型，您通常会使用接口而不是抽象类。

您不能（也不应该）这样处理设计。使用抽象类，尝试以下操作：

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
}

公共抽象类AbstractDiet{
抽象void compute（）；
}
公共抽象类AbstractAnimal{
保护性T型饮食；
}
公共类CatFoodDiet扩展了抽象饮食{
计算（）{
//
}
}
公营猫科动物{
//super中的use字段类型为CatFoodDiet
}

但是，对于抽象类型，您通常会使用接口而不是抽象类。

您不能（也不应该）这样处理设计。使用抽象类，尝试以下操作：

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
}

公共抽象类AbstractDiet{
抽象void compute（）；
}
公共抽象类AbstractAnimal{
保护性T型饮食；
}
公共类CatFoodDiet扩展了抽象饮食{
计算（）{
//
}
}
公营猫科动物{
//super中的use字段类型为CatFoodDiet
}

---

但是对于抽象类型，通常使用接口而不是抽象类。

首先：保持实例变量私有，并提供访问器方法

第二：听起来你好像在试图定义一个接口。当你想说“每种动物都有自己的饮食”时，可以随时使用界面

如果你愿意，你也可以把波希米亚的想法结合起来，使之通用化

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

界面动物{ D getDiet（）； ... } 这样，当需要定义不同种类的动物时，你将有最大的自由

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

类Cat实现动物{
CatDiet getDiet（）{return…；}
}

首先：保持实例变量私有，并提供访问器方法

第二：听起来你好像在试图定义一个接口。当你想说“每种动物都有自己的饮食”时，可以随时使用界面

如果你愿意，你也可以把波希米亚的想法结合起来，使之通用化

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

界面动物{ D getDiet（）； ... } 这样，当需要定义不同种类的动物时，你将有最大的自由

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

类Cat实现动物{
CatDiet getDiet（）{return…；}
}

首先：保持实例变量私有，并提供访问器方法

第二：听起来你好像在试图定义一个接口。当你想说“每种动物都有自己的饮食”时，可以随时使用界面

如果你愿意，你也可以把波希米亚的想法结合起来，使之通用化

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

界面动物{ D getDiet（）； ... } 这样，当需要定义不同种类的动物时，你将有最大的自由

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

类Cat实现动物{
CatDiet getDiet（）{return…；}
}

首先：保持实例变量私有，并提供访问器方法

第二：听起来你好像在试图定义一个接口。当你想说“每种动物都有自己的饮食”时，可以随时使用界面

如果你愿意，你也可以把波希米亚的想法结合起来，使之通用化

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

界面动物{ D getDiet（）； ... } 这样，当需要定义不同种类的动物时，你将有最大的自由

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

类Cat实现动物{
CatDiet getDiet（）{return…；}
}

最灵活的方法是只要求子类提供信息：

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();
    }
}

如果要强制执行特定的实现，这是一种常见的方法：

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());
    }
}

---

最灵活的方法是只要求子类提供信息：

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();
    }
}

如果要强制执行特定的实现，这是一种常见的方法：

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());
    }
}

---

最灵活的方法是只要求子类提供信息：

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();
    }
}

如果要强制执行特定的实现，这是一种常见的方法：

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());
    }
}

---

最灵活的方法是只要求子类提供信息：

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();
    }
}

如果要强制执行特定的实现，这是一种常见的方法：

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());
    }
}

---

我想强制要求AbstractDiet的子类总是在AbstractAnimal的子类中实现。

这句话没有意义。您没有实现变量或字段。你可以初始化它。你到底在问什么？我想确保AbstractDiet的一个子类存在于AbstractAnimal的任何子类中。既然节食就是它