java多态概念

Java多态

1. Java的向上转型
2. Java向下转型
3. 属性的重写问题
4. instanceof操作符的使用

先建一个Animal类，让Cat和Dog类继承Animal类：

public class Animal {
    String name="动物";
    int age;
    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()//特有的方法
    {
        System.out.println("猫抓老鼠");
    }
}

public class Dog extends Animal{
    String name="大黄";
    public void eat()
    {
        System.out.println("小狗汪汪叫。。。");
    }
}

一.iava的向上转型*
语法：
本质：父类的引用指向了子类的对象。
特点：
（1）编译类型看左边，运行类型看右边。
（2）可以调用父类的所有成员（需遵循访问权限)。
（3）不能调用子类中的特有成员(因为在编译阶段，能调用哪些成员是由编译来决定的)。
（4） 最终运行效果看子类的具体表现。

父类类型 引用名=new 子类类型();

public class PolyDetail {
    public static void main(String[] args) {
        //**向上转型：父类的引用指向子类的对象
        Animal animal=new Cat();
        //animal.catchMouse();//是错误的
        animal.eat();
        animal.run();//先在Cat类找，发现没有run方法，则继续去父类查找
        animal.sleep();
        animal.show();
        }}

二.java的向下转型
语法：子类类型 引用名=子类类型 父类引用；
规则：
（1）要求父类的引用必须指向当前目标类型的对象。
（2）只能强制转换父类的引用，不能强制转换父类的对象。
（3）向下转型后能调用子类的所有成员。
例如：

 Cat cat=(Cat) animal;//即把父类的引用强转为子类的引用  此时Cat的编译类型是Cat ,运行类型是Cat(强制转换)
        //Dog dog=(Dog) animal;错误（因为Animal的引用没有指向Dog类的引用）
        Cat c=new Cat();
        cat.catchMouse();

三.属性的重写问题
属性没有重写之说，属性的值看编译类型。

Animal animal1=new Dog();
        System.out.println(animal1.name);//输出的结果是”动物“,因为此时的编译类型是Animal,所以调用的是Animal类中的name;
        Dog dog=new Dog();
        System.out.println(dog.name);//输出结果是”大黄“，此时的编译类型是Dog,所以调用的是Dog类中的name

四.instanceof操作符的使用
用于判断对象的类型是否为xx类型或xx类型的子类。
注意：是判断对象的运行类型。

 public static void main(String[] args) {
  BB bb = new BB();
        System.out.println(bb instanceof BB);//true bb的类型是BB
        System.out.println(bb instanceof AA);//bb类型是AA类型的子类型
        //aa的编译类型是AA，运行类型是BB
        AA aa=new BB();
        System.out.println(aa instanceof AA);//aa的运行类型是AA的子类型
        System.out.println(aa instanceof BB);//aa的运行类型是BB类型的

        Object obj=new Object();
        System.out.println(obj instanceof AA);//false，obj运行类型不是AA，也不是AA的子类型

        String str="hello";
        System.out.println(str instanceof Object);//true
}
}
class AA{}
class BB extends AA{}