Java 教程 5：继承和多态

我们可以这样使用它：

WasteDisposalRobot robot = new WasteDisposalRobot();
        
robot.start();
robot.findWaste();
robot.work();
robot.stop();

Robot started.
Finding waste
Robot working.
Robot stopped.

我们在这里看到的是继承在起作用。WasteDisposalRobot是Robot类的subclass 或子类；Robot类是其基类或父类。

WasteDispoalRobot可以做Robot能做的所有事情，我们也可以向它添加新的方法（和数据）。

方法覆盖

如果我们已经创建了某个超类的新子类，但我们不喜欢超类中的一个或多个方法，该怎么办？我们想把它改成别的东西。我们可以简单地通过在子类中再次定义方法来做到这一点。

在下面的代码中，我们重写了Robot父类中的work（）方法，以便它在WasteDisposalRobot子类中执行一些不同的操作。

public class WasteDisposalRobot extends Robot {
    public void findWaste() {
        System.out.println("Finding waste");
    }
    
    @Override
    public void work() {
        System.out.println("Disposing waste!");
    }
}

Robot started.
Finding waste
Disposing waste!
Robot stopped.

请注意位于被覆盖方法之前的@Override指令。这不是强制性的，但您应该始终使用它。它告诉Java编译器您打算覆盖父类中的方法。如果您拼错了方法名称并试图覆盖不存在的方法，编译器将通过抛出错误来警告您。

实例变量继承

您可能会想知道实例变量会发生什么情况。如果Robot超类有一些实例变量，子类是否也可以访问这些变量？这取决于在父类中定义实例变量时是使用public、private或protected访问说明符，还是根本不使用任何说明符。稍后我们将更详细地讨论这一点，但现在我们只说，只要实例变量不是私有的，它们就可以被子类访问。

我们来看一个例子。在这里，我将所有相关代码放在一个文件中，以使其更易于阅读。

class Fruit {
    String name;
    
    Fruit() {
        name = "Fruit";
    }
    
    public String getName() {
        return name;
    }
}

class Banana extends Fruit {
    Banana() {
        name = "Banana";
    }
}



public class Application {


    public static void main(String[] args) {
        Fruit fruit = new Fruit();
        Banana banana = new Banana();
        
        System.out.println(fruit.getName());
        System.out.println(banana.getName());
    }

}

两个类的构造函数都设置name实例变量。Banana类扩展了Fruit类（即继承自它）；它的构造函数还可以访问它设置的name实例变量。然后，当使用getName（）方法从任一个类中检索Name时，将返回并显示相应的名称。

Fruit
Banana

构造函数继承

构造函数像其他方法一样被继承，事实上，当你构造一个子对象时，它的父对象的默认构造函数会首先被自动调用。

class Fruit {
    Fruit() {
        System.out.println("Fruit constructed");
    }

}

class Banana extends Fruit {
    Banana() {
        System.out.println("Banana constructed");
    }
}

public class Application {

    public static void main(String[] args) {
        Banana banana = new Banana();
    }
}

Fruit constructed
Banana constructed

如果父类中没有默认构造函数，则必须在子类中显式定义构造函数。如果需要，可以使用super关键字调用父类中相应的构造函数。

class Fruit {
    Fruit(String name) {
        System.out.println("Fruit constructed with name: " + name);
    }

}

class Banana extends Fruit {
    Banana() {
        super("Banana");
    }
}

public class Application {

    public static void main(String[] args) {
        Banana banana = new Banana();
    }
}

Fruit constructed with name: Banana

Java中的多态性

多态：简单概念。它的字面意思是“许多形状”。但这说明不了什么。多态性意味着，基本上，一旦你有了一个子类，你就可以在使用父类对象的任何地方使用该子类的对象。Java将自动调用正确的方法。

例如，即使我们有一个父类类型的变量，我们也可以将其分配给子类，并且可以使用该变量调用子类中被覆盖的方法。

我们来看一个例子。

class Fruit {
    
    public void show() {
        System.out.println("Fruit");
    }
}

class Banana extends Fruit {
    
    @Override
    public void show() {
        System.out.println("Banana");
    }
    
    public void makeBananaTree() {
        System.out.println("Making a tree");
    }
}

public class Application {

    public static void main(String[] args) {
        Fruit banana = new Banana();
        
        banana.show();
        
        // The following WILL NOT work;
        // Variables of type Fruit know only
        // about Fruit methods.
        // banana.makeBananaTree();
    }
}

Banana

当然，您不能将banana赋给fruit变量，然后使用它来调用只属于banana而不属于fruit的方法。fruit只知道fruit的方法。特定类类型的变量只知道在该特定类及其超类中定义的方法。它不知道子类中定义的方法，即使您可以将子类类型的对象分配给变量（banana对象分配给fruit变量，如本例所示），并且被覆盖的方法将被正确调用。