java的多态

1 概念

同一对象拥有多种形态

2 作用

把不同数据类型进行统一

3 特点

父类的引用指向子类对象 （父类 xxx = new 子类() )

上面 xxx 可以调用子类重写父类的非静态方法，可以调用父类所有属性和静态方法，但不能直接调用子类独有方法，必须先强转为子类 ((子类)xxx).子类独有方法(); 才能这样调用到。

↑解释
在进行 父类 xxx = new 子类()时
是低转高（子转父），由于子类已经继承了父类的所有，所以此时子类把自己独有的方法删除后，自然而然就可以转化为父类对象。
而当 xxx调用子类独有的方法时，则需要重新开辟一个只属于子类的空间为((子类)xxx)，所以需要强制转，
此时((子类)xxx)相当于开辟了一个子类对象的空间，用它就能调用子类独有的方法。

因此，父类引用指向子类对象的变量xxx 不能直接调用子类独有方法

4 代码：

父类 Father.java

public class Father {
    public String name = "fathername";
    public static String name2 = "fathername2";
​
    public void  run(){
        System.out.println("f run");
    }
​
    public static void run2(){
        System.out.println("f static run2");
    }
​
    public void fathermethod(){
        System.out.println("f method");
    }
}

子类 Son.java

public class Son extends Father{
   public String name = "sonname";
    public static String name2 = "sonname2";
    
    public void  run(){
        System.out.println("s run");
    }
​
    public static void run2(){
        System.out.println("s static run2");
    }
​
    public void sonmethod(){
        System.out.println("子类独有方法");
    }
}

主程序类 Application.java

public class Application {
    public static void main(String[] args) {
        Father f = new Son();
​
        f.run();                     //调用的是子类重写的run方法(非static方法看右边)
        f.run2();                          //父类的run2（static方法看左边）
        System.out.println(f.name2);       //父类的静态属性name2（属性看左边）
        System.out.println(f.name);        //父类非静态属性name （属性看左边）
​
        ((Son) f).sonmethod();      //调用子类独有的方法(非static方法看右边)
                                    //等价于Son xxx = ((Son)f); xxx.xonmethod();
        f.fathermethod();           //调用子类中继承的，只是没重写，所有结果为f method(非static方法看右边)
        
        System.out.println("------------------------------");
        
        /* 
        Father father = new Father();
            这块注解的代码运行都报错
        ((Son)father).run();
        ((Son)father).fathermethod();
        ((Son)father).sonmethod();
        System.out.println(((Son) father).name);
            所以父类引用指向父类对象的变量强转后也不能调用子类的东西。
         */
        Son s = new Son();
        ((Father)s).run();      //还是子类重写的（非static方法看右边）
        Father b = ((Father) s);
        System.out.println(b.name);  //父类的(属性看左边）
        s.run();                       //非static方法看右边， 右边是new Son 所以打印结果也是Son里重写的
        s.run2();                     //子类的run2（static方法看左边）
        System.out.println(s.name2);//子类的name2（属性看左边）
        System.out.println(s.name);//子类重写的 （属性看左边）
    }
}

5 运行结果

6 总结

父类引用指向子类对象的变量调用 静态方法和所有属性时看左边（父类），只有调用 非静态方法时看右边（某子类）。

所以 “父 xxx = new 子() ”中的xxx，简单说就是一个去掉子类独有方法的子类对象。