多态产生的条件

 1
　　　// Son2 类

package com.demo13;

public class Son2 extends Father{
    @Override
    public void love() {
        System.out.println("Son2 love");
    
    }
}

 1
　　//Son2 类
 package com.demo13;

public class Son extends Father{
    public void say(){
        System.out.println("Son say...");
    }
    public void love() {
        System.out.println("Son love");
    }
}

//Test 测试类
 package com.demo13;

public class Test {
    public static void main(String[] args) {
        //1- 子类可以自动转换成父类；
        //父类必须在子类转换成父类的基础上，才能转换成父类
        Father f =  new Son();//正确，自动向上转换
        Son s = (Son)f;//正确
        
        /**
         * 以下代码会报ClassCastException（类型转换异常）
         */
        /*Father f1 = new Father();
        Son s1 = (Son)f1; */
        
        //2- 声明什么类型，就只能调用什么类型内的方法 
        Father ff = new Father();//只能调用Father中的方法
        Son ss = new Son(); //只能调用Son中以及继承下来的方法
        Father f3 = new Son();//只能调用father中的方法
        Son s3 = (Son)f3;//只能调用Son中以及继承下来的方法
        
        //3- new的什么类型，就真正运行什么类型的方法。
        ff.love();
        ss.love();
        f3.love();//Son重写后的方法
        s3.love();
        
        /**
         * 总结：多台产生的条件
         *         1- 继承
         *         2- 子类重写父类方法
         *         3- 声明父类，创建子类，并将声明的父类引用子类对象（即父类对象引用子类对象）
         *         4- 父类调用被重写的方法
         */
        //以下实现了多态
        test(new Son()); 
        test(new Son2());
        
    }

    private static void test(Father f) {
        f.love();
        
    }
    
}

 1
　　// Father 类
 package com.demo13;

public class Father {
    public void show() {
        System.out.println("Father show");
        
    }
    public int add(int x,int y){
        return x + y;
    }
    public void love(){
        System.out.println("Father love");
    }
}