多态性

多态分类:
　　普通类多态 (静态方法没有多态性 ，成员变量没有多态性)

      

package review07;
/*
 *     多态的分类：
 *         普通类多态(静态方法没有多态性 ，成员变量没有多态性)
 *         抽象类多态（抽象父类的变量不能调用子类中特有的方法）
 *         接口多态
 * 
 *     多态的前提
 *         继承
 *         方法重写
 *         父类引用指向子类对象
 * 编译时类型：引用数据类型定义时的类型就是编译时类型
 * 运行时类型：程序运行时变量指向的正真对象的类型
 */
//普通类多态
class Father4 {
    int num = 10;
    public void show(){
        System.out.println("Father showw");
    }
    public static void method(){
        System.out.println("Father method");
    }
    
    
}
class Son4 extends Father4{
    int  num =20;
    public void show(){
        System.out.println("Son4 show");
    }
    public void show1(){
        System.out.println("Son4 show");
    }
    
    public static void method(){
        System.out.println("son4  method");
    }
}
public class PolymorphismDemo2 {
    public static void main(String[] args) {
        Father4 f = new Son4();//向上造型  多态
        f.show();//Son4 show
        //f.show1();//父类引用不能调用子类中特有的方法
        f.method();//Father method  静态方法没有多态性
        System.out.println(f.num);//10  成员变量没有多态性
    }
}

　　抽象类多态（抽象父类的变量不能调用子类中特有的方法）

package review07;
/*
 * 抽象类多态
 */
abstract class  Animal4{
    public abstract void show();
}
class Dog4 extends Animal4{
    public void show() {
        System.out.println("Dog  show");
    }
}
class Cat4 extends Animal4{
    public void show(){
        System.out.println("cat show()");
    }
    public void test(){
        
    }
}
//
public class PolymorphismDemo3 {
    public static void main(String[] args) {
        Animal4 an = new Dog4();
        an.show();
        
         Animal4  a = new Cat4();
         a.show();
         //a.test();//抽象父类的变量不能调用子类特有的方法
    }
}

　　接口多态     //接口不能调用子类特有的方法

package review07;
/*
 * 接口多态
 */
interface Interf{
    public abstract void method();
}
class InterImple implements Interf{
    public void method(){
        System.out.println("子类实现接口，重写method方法");
    }
    public void test(){
        System.out.println("子类的test方法");
    }
}
public class PolymorphismDemo4 {
    public static void main(String[] args) {
        Interf in = new InterImple();
        in.method();
        //in.test();//接口不能调用子类特有的方法
    }
}

多态前提:
　　继承:
　　方法重写
　　父类引用指向子类对象

编译时类型:引用数据类型定义时的类型就是编译类型
运行时类型:程序运行时变量指向的真正对象的类型