java基础（六）多态

        本文主要介绍了java基础当中的多态，介绍了其定义，并且通过一道代码练习题详细的讲解了多态的用法。

一、多态

 1、多态是什么？

        （1）多态定义

        多态就是父类的引用（数据类型）指向子类的对象,具体流程如下例1。

        格式： A ad=new B();

        例1：

        代码：

//父类
public class A{
    
}

//子类
public class B extends A{
    
}

//测试类本身无含义
public class Test{
    public static  void main{
            A ad=new B();
    }
}

        （2）通过数据的存储形式了解什么是多态

        通过，修改父类：A类与子类：B类，单独画出两个类的对象的内存结构形式，和子类B进行方法重写后的内存图，对这些内存图进行一个参考画出多态 A ad=new B();的内存图

        ①基本数据类型中int、byte、float的内存存取形式

        ②父类即A类对象的内存结构图

        ③子类即B类对象的内存结构图

        ④子类即B类对象run()方法重写后的内存形式

        ⑤多态 A ad=new B(); ad的内存图

        创建子类对象一定会创建父类对象，所以内存中会出现A和B的对象，但因为数据类型决定数据的存储形式，ab被A类型所锁定（决定），ab受制于数据类型A，所以只能调用A对象的数据。

        如果子类发生过重写（重写的方法覆盖之前的方法），此时该重写的方法是父类与子类共用的，所以也能调用。

2、多态的用法

（1）向上转型

        向上转型，子类的对象可以被父类的类型所接收，即父类的引用指向子类的对象，详细代码请看下图。

练习1：(务必掌握) A类是B类（show（A）方法重写）的父类，B类是C类、D类的父类

        代码：

        A类

public class A {
    public String show(D obj) {
        return ("A and D");
    }
    public String show(A obj) {
        return ("A and A");
    } 
}

        B类

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

        C类

public class C extends B{
}

        D类

public class D extends B{
}

        Test类 //本身无实际含义

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }

        ①system.out.println("1----"+a1.show(b))

        首先注意创建a1对象时会创建一个内存空间（用@1表示），创建b时会先创建A类对象在创建B类对象两者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，而@2中B类的show（A）方法的重写只能影响@2中的a对象，无法影响到@1的a1对象，所以调用A类本身的show（A）方法，输出A and A。

        ②system.out.println("1----"+a1.show(c))

        问题②与问题①类型相同

        首先注意创建a1对象时会创建一个内存空间（用@1表示），创建对象c时会创建A类对象和创建B类对象还有c类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，而@2中B类的show（A）方法的重写只能影响@2中的a对象，无法影响到@1的a1对象，所以调用A类本身的show（A）方法，输出A and A。

        ③system.out.println("1----"+a1.show(d))

        问题③与问题①类型相同。

        首先注意创建a1对象时会创建一个内存空间（用@1表示），创建对象d时会创建A类对象和创建B类对象还有d类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，所以调用A类本身的show（D）方法，输出A and D。

        ④system.out.println("1----"+a2.show(b))

        首先注意创建a2对象时，因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为A a2 =new A（），a2的类型为A，只能访问A类对象的方法。此时两个对象都在一个内存空间（用@1表示），创建对象b时会创建A类对象和创建B类对象两者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，而@2中B类的show（A）方法的重写只能影响@2中的a对象，无法影响到@1的a1对象，所以调用A类本身的show（A）方法（但注意此时A类本身show（A）方法也已经完成重写），输出B and A。

        ⑤system.out.println("1----"+a2.show(c))

        问题⑤与问题④类型相同

        首先注意创建a2对象时，因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为A a2 =new A（），a2的类型为A，只能访问A类对象的方法。此时两个对象都在一个内存空间（用@1表示），创建对象c时会创建A类对象和创建B类对象还有c类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，而@2中B类的show（A）方法的重写只能影响@2中的a对象，无法影响到@1的a1对象，所以调用A类本身的show（A）方法（但注意此时A类本身show（A）方法也已经完成重写），输出B and A。

        ⑥system.out.println("1----"+a2.show(d))

        首先注意创建a2对象时,因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为A a2 =new A（），a2的类型为A，只能访问A类对象的方法。此时两个对象都在一个内存空间（用@1表示），创建对象d时会创建A类对象和创建B类对象还有d类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类中的方法，所以调用A类本身的show（D）方法，输出A and D。

        ⑦system.out.println("1----"+b.show(b))

        首先注意创建b对象时,因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为b是B类对象，且继承了A类对象，所以b可以访问A和B类对象的方法，调用show(A)输出B and A。

        ⑧system.out.println("1----"+b.show(c))

        首先注意创建b对象时,因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为b是B类对象，且继承了A类对象，所以b可以访问A和B类对象的方法，此时两个对象都在一个内存空间（用@1表示），创建对象c时会创建A类对象和创建B类对象还有c类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类和B类中的方法，所以调用重写后的show（A）方法，输出B and A。

        ⑨system.out.println("1----"+b.show(d))

        首先注意创建b对象时,因为是newB()所以会先创建一个A类对象在创建一个B类对象，此时完成了A类对象show（A）的重写，但因为b是B类对象，且继承了A类对象，所以b可以访问A和B类对象的方法，此时两个对象都在一个内存空间（用@1表示），创建对象d时会创建A类对象和创建B类对象还有d类对象三者在同一内存空间（用@2表示）。

        然后注意@1和@2在分别在两个内存空间，所以上述输出只能调用@1 A类和B类中的方法，所以调用重写后的show（D）方法，输出A and D。