Java——多态

一、多态的定义

多态：父类的引用指向子类的对象

如上面的照片，B是子类，A是父类

在Test中父类的引用指向了子类的对象，这个就是多态。

代码： 

class A{
    
}

class B extends A{
    
}
public class Test {
    public static void main(String[] args) {
        A ab = new B();
    }
}

不同的数据类型决定着数据不同的存储形式

为了更好的理解多态，我们可以先复习一下数据类型

从上面的图片中可以了解到：不同的数据类型决定着数据不同的存储形式

 A a = new A();

然后我们继续对A代码进行扩充，并生成新的实例对象a：

class A{

    public String name;
    public int age;

    public void run(){
        System.out.println("A跑得快");
    }
    public void eat(String name){
        System.out.println(name + "吃得多");
    }
}

class B extends A{

}
public class Test {
    public static void main(String[] args) {
        A ab = new B();
        A a = new A();
    }
}

这里我们先画出实例对象a的内存存储形式

 B b = new B();

然后继续对B类进行补充

class A{

    public String name;
    public int age;

    public void run(){
        System.out.println("A跑得快");
    }
    public void eat(String name){
        System.out.println(name + "吃得多");
    }
}

class B extends A{
    public  char sex;
    public int height;
    public void fly(){
        System.out.println("B飞得高");
    }
}
public class Test {
    public static void main(String[] args) {
        A ab = new B();
        A a = new A();
        B b = new B();
    }
}

这里我们需要注意的一个问题是：创建子类实例对象的前提是要创建子类的父类对象 

也就是说在创建B的子类之前，我们首先要将父类A的对象给他创建出来，所以b对象的创建内存图大致是这个样子的：

如果此时在B中也写一个run方法，那么A中的run方法就会被覆盖

  A ab = new B();

最后我们去分析ab对象产生时的内存图。

  A ab = new B();

在new B的时候，堆中的A、B都要出现，理由和上一个时相同的：创建子类对象一定会创建父类对象。

那么不同点究竟是什么呢？

这里就需要提到我们前面曾提到过的数据类型了

因为不同的数据类型决定着数据不同的存储形式，而在  A ab = new B();这一行代码中，A就相当于数据类型，所以ab所能操作的只能使用A那部分的内存，不过如果run方法重写了以后，这个重写的run方法相当于由A和B所共享了，所以此时还可以调用run方法。

class A{

    public String name;
    public int age;

    public void run(){
        System.out.println("A跑得快");
    }
    public void eat(String name){
        System.out.println(name + "吃得多");
    }
}

class B extends A{
    public  char sex;
    public int height;
    public void fly(){
        System.out.println("B飞得高");
    }
    public void run(){
        System.out.println("B跑得快");
    }
}
public class Test {
    public static void main(String[] args) {
        A ab = new B();
        ab.run();
        ab.sex;//error
    }
}

二、实现多态的方式

继承：

通过继承父类并在子类中重写父类的方法来实现多态。子类继承父类后，可以对父类的方法进行扩展和修改，以适应不同的需求。

接口实现：

一个类可以实现多个接口，不同的实现类可以对接口中的抽象方法进行不同的实现，从而实现多态。

三、多态的优点

提高代码的可维护性和可扩展性：

当需要增加新的功能或修改现有功能时，只需要在子类中进行修改，而不会影响到父类和其他子类的代码。

增强代码的灵活性和可复用性：

可以使用父类的引用指向不同的子类对象，根据实际情况动态地调用不同子类的方法，提高了代码的灵活性和可复用性。

四、多态的实现机制

向上转型（Upcasting）：

将子类对象赋值给父类引用，这是自动进行的。在向上转型后，通过父类引用只能访问父类中定义的成员变量和方法，不能访问子类特有的成员变量和方法。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();
    }
}

在这个例子中，将Dog对象赋值给Animal类型的引用，这就是向上转型。当调用makeSound方法时，实际执行的是Dog类中的方法，这体现了多态。

方法重写（Override）：子类重写父类的方法，使得在运行时根据对象的实际类型来调用相应的方法。当使用父类引用调用重写的方法时，实际执行的是子类中的方法。在上面的例子中，Dog类重写了Animal类中的makeSound方法

动态绑定（Dynamic Binding）：也称为后期绑定，是在运行时根据对象的实际类型来确定要调用的方法。Java 通过方法表来实现动态绑定，在运行时根据对象的实际类型查找对应的方法表，从而确定要调用的方法。

五、多态的注意事项

不能通过父类引用访问子类特有的成员变量和方法：

向上转型后，父类引用只能访问父类中定义的成员变量和方法。如果需要访问子类特有的成员变量和方法，可以进行向下转型（Downcasting），但需要注意进行类型检查，以避免出现类型转换异常。

class Parent {
    int parentVariable = 10;

    void parentMethod() {
        System.out.println("This is parent method.");
    }
}

class Child extends Parent {
    int childVariable = 20;

    void childMethod() {
        System.out.println("This is child method.");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        // 可以访问父类的成员变量和方法
        System.out.println(parent.parentVariable);
        parent.parentMethod();

        // 以下代码会报错，不能通过父类引用访问子类特有的成员变量和方法
        // System.out.println(parent.childVariable);
        // parent.childMethod();
    }
}

在这个例子中，创建了一个父类Parent和一个子类Child。通过父类引用指向子类对象后，可以访问父类中定义的成员变量和方法，但不能直接访问子类特有的成员变量和方法。如果尝试访问子类特有的成员变量和方法，会在编译时出现错误。

构造方法不具有多态性：

在创建对象时，构造方法是按照类的继承层次依次调用的，不会发生多态。

class Parent {
    public Parent() {
        System.out.println("Parent constructor called.");
    }
}

class Child extends Parent {
    public Child() {
        System.out.println("Child constructor called.");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        // 输出结果先是“Parent constructor called.”，然后是“Child constructor called.”
        // 可以看到构造方法是按照类的继承层次依次调用的，没有多态性
    }
}

在这个例子中，创建一个Child对象并赋值给Parent类型的引用。在这个过程中，首先调用父类的构造方法，然后调用子类的构造方法。这表明构造方法是按照类的继承层次依次调用的，不具有多态性，即不能根据对象的实际类型动态地选择调用哪个构造方法。

静态方法不具有多态性：

静态方法是与类相关联的，而不是与对象相关联的，因此静态方法不具有多态性。

class Parent {
    public static void staticMethod() {
        System.out.println("Parent static method.");
    }
}

class Child extends Parent {
    public static void staticMethod() {
        System.out.println("Child static method.");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        Parent.staticMethod(); // 输出 "Parent static method."
        Child.staticMethod(); // 输出 "Child static method."
        // 即使通过父类引用指向子类对象，调用静态方法时还是根据引用的类型（这里是 Parent）来决定调用哪个静态方法，而不是根据对象的实际类型。
    }
}

在这个例子中，尽管通过父类引用指向了子类对象，但是在调用静态方法时，仍然是根据引用的类型（而不是对象的实际类型）来决定调用哪个静态方法，这体现了静态方法不具有多态性。