Java中的超类和子类

对你来说，这可能很简单，但我不知道区别是什么。我只想知道这两个代码之间的区别。假设我有一些如下所述的代码

第一类是动物，它将是超类

public class Animal {

    private String name;
    private int weight;
    private String sound;

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setWeight(int weight){
        if(weight > 0){
            this.weight = weight;
        } else {
            System.out.println("Weight must be bigger than 0");
        }
    }

    public int getWeight(){
        return weight;
    }

    public void setSound(String sound){
        this.sound = sound;
    }

    public String getSound(){
        return sound;
    }
}

第二类是狗，它扩展了动物类

public class Dog extends Animal {

    public void digHole(){
        System.out.println("Dig a hole");
    }

    public Dog(){
        super();

        setSound("bark");
    }
}

最后一个类是WorkWithAnimals，它将打印输出

public class WorkWithAnimals {

    public static void main(String args[]){

        Dog fido = new Dog();

        fido.setName("Dadu");
        System.out.println(fido.getName());

        fido.digHole();
        fido.setWeight(-1);
    }
}

我的问题是，动物fido=新狗和狗fido=新狗之间有什么区别

既然Dog已经扩展了Animal，为什么我们必须编写类似Animal fido=newdog这样的代码

他们两个打印的结果相同，不是吗

Animal fido = new Dog()

及

都是指同一个物体，狗。OOP允许您创建引用其子类的超类的变量类型。这是抽象的目的。如果你不知道这意味着什么，你应该找一本java的书读一读

及

---

都是指同一个物体，狗。OOP允许您创建引用其子类的超类的变量类型。这是抽象的目的。如果您不知道这意味着什么，您应该找到一本java书籍并阅读它。

如果您这样定义实例fido：

 Animal fido = new Dog()

然后，您可以调用fido上定义的所有方法。但是，如果不进行强制执行，则无法发出这样的呼叫：

fido.digHole(); // this will not compile
((Dog)fido).digHole(); // this will work

---

如果您这样定义实例fido：

 Animal fido = new Dog()

然后，您可以调用fido上定义的所有方法。但是，如果不进行强制执行，则无法发出这样的呼叫：

fido.digHole(); // this will not compile
((Dog)fido).digHole(); // this will work

---

类Animal将不包括digHole，因此您应该得到一个编译时错误；因此：

Animal fido = new Dog();
fido.dighole(); //<--compile time error

---

会很好。

类动物将不包括digHole，因此您应该会得到编译时错误；因此：

Animal fido = new Dog();
fido.dighole(); //<--compile time error

---

不会有问题。

区别在于将来如何使用实例。例如：如果要将元素添加到集合中，很可能会使用泛型来避免类型转换

---

或者对于更复杂的用途，请查找GoF设计模式，特别是策略，以及为什么在本例中使用接口超类可以提高代码设计的可读性和灵活性

差异与将来如何使用实例有关。例如：如果要将元素添加到集合中，很可能会使用泛型来避免类型转换

或者对于更复杂的用途，请查找GoF设计模式，特别是策略，以及为什么在本例中使用接口超类可以提高代码设计的可读性和灵活性

想象一下：

public void sleep(Animal a){
    a.sleep();
}

使用Animal作为参数类型，我可以将其传递给猫、狗或任何扩展Animal的对象

但如果我写了这个：

public void sleep(Dog d){
      d.sleep();
  }

现在我被限制在狗的类型

同样，在第一种情况下，我不必知道动物实施的各种子类是如何睡眠的。

想象一下：

public void sleep(Animal a){
    a.sleep();
}

使用Animal作为参数类型，我可以将其传递给猫、狗或任何扩展Animal的对象

但如果我写了这个：

public void sleep(Dog d){
      d.sleep();
  }

现在我被限制在狗的类型

---

同样，在第一种情况下，我不必知道动物实施睡眠的各种亚类。

这是OOP的基础，可以把这个例子作为现实生活中的一个例子，在现实生活中，我们有动物这个例子代表动物类，我们有一只狗，狗是一种动物，它具有普通动物的所有属性，比如猴子或袋鼠，但这三种动物都有自己的做事方式，就像它们中只有一种做的事情一样多

这是OOP的基础，可以把这个例子作为现实生活中的例子，在现实生活中，我们有一只狗，它是一种动物，具有普通动物的所有属性，如猴子或袋鼠，但这三种动物都有自己的做事方式，就像它们中只有一种做的事情一样多

好答案在这里好答案在这里取决于编译器的严格程度。我的每件事都要严格限制。给他一个更好的解决方案或解释。这取决于你的编译器有多严格。我的每件事都要严格限制。给他一个更好的解决方案或解释。