多态——向上转型和向下转型

本次博客带领大家学习多态中的向上转型和向下转型，在多态中是相当重要的。

向上转型

• 多态的前提是：两个对象(类)存在继承关系。

1. 本质：父类的引用指向了子类的对象。
2. 语法：父类类型 引用名 = new 子类类型();
3. 特点：编译类型看左边，运行类型看右边。
   1. 可以调用父类中的所有成员(需遵守访问权限)。
   2. 不能调用子类中特有成员。
   3. 最终运行效果看子类的具体实现！

public class PolyDetail {
    public static void main(String[] args) {
        //向上转型：父类的引用指向了子类的对象。
        //语法：父类类型引用名 = new 子类类型()
        Animal animal = new Cat();
        Object obj = new Cat();//Object  也是 Cat的父类
        System.out.println("ok~~~~");

        //可以调用父类中的所有成员(需遵守访问权限)
        //但是不能调用子类特有的成员
        //因为在编译阶段，能调用哪些成员，是由编译类型决定的
        //最终运行效果看子类的具体实现,即调用方法时，按照从子类开始查找方法，然后调用
        animal.eat();
        animal.run();
        animal.show();
        animal.sleep();

    }
}

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("hello,你好");
    }
}

public class Cat extends Animal{
    public void eat(){ //方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){ //Cat特有的方法
        System.out.println("猫抓老鼠");
    }
}

向下转型

1. 语法：子类类型 引用名 = (子类类型) 父类引用;
2. 只能强转父类的引用，不能强转父类的对象。
3. 要求父类的引用必须指向的是当前目标类型的对象。
4. 可以调用子类类型中所有的成员。

public class PolyDetail {
    public static void main(String[] args) {
        //向上转型：父类的引用指向了子类的对象。
        //语法：父类类型引用名 = new 子类类型()
        Animal animal = new Cat();
        Object obj = new Cat();//Object  也是 Cat的父类
        System.out.println("ok~~~~");

        //可以调用父类中的所有成员(需遵守访问权限)
        //但是不能调用子类特有的成员
        //因为在编译阶段，能调用哪些成员，是由编译类型决定的
        //最终运行效果看子类的具体实现,即调用方法时，按照从子类开始查找方法，然后调用
        animal.eat();
        animal.run();
        animal.show();
        animal.sleep();

        //多态的向下转型
        //语法：子类类型 引用名 = (子类类型) 父类引用；
        Cat cat = (Cat) animal;
        cat.catchMouse();
    }
}

属性和instanceof

• 属性没有重写之说！属性的值看编译类型。
• 属性看编译类型，方法看运行类型。
• instanceof 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型。

public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();
        System.out.println(base.count);
        Sub sub = new Sub();
        System.out.println(sub.count);
    }
}

class Base{ //父类
    int count = 10;//属性
}

class Sub extends Base{
    int count = 20;
}

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);
        System.out.println(bb instanceof AA);

        //aa 的编译类型是AA,运行类型是BB
        AA aa = new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);

        Object obj = new Object();
        System.out.println(obj instanceof AA);
    }

}
class AA{} //父类
class BB extends AA{} //子类

动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。
2. 当调用对象属性是，没有动态绑定机制，哪里声明，哪里使用。

public class DynamicBinding {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());
        System.out.println(a.sum1());
    }
}

class A{
    public int i = 0;
    public int sum(){
        return getI()+10;
    }

    public int sum1(){
        return i+10;
    }

    public int getI(){
        return i;
    }
}

class B extends A{
    public int i = 20;
//    public int sum(){
//        return i+20;
//    }
    public int getI(){
        return i;
    }
    public int sum1(){
        return i+10;
    }
}