JAVA 多态

1、多态：父类型的引用可以指向子类型的对象。

2、Parent p=new Child();当使用多态方式调用方式时，首先检查父类中是否有sing()方法，如果没有则编译错误；如果有，再去调用子类的sing()方法。

public class PolyTest {
    public static void main(String[] args) {
        Parent parent=new Child();
        //指向谁调用谁的方法，当把子类的方法注释掉的时候会调用父类的方法。当使用多态方式调用方式时，首先检查父类中是否有sing()方法，如果没有则编译错误。
        parent.sing();
    }
}
class Parent{
    public void  sing(){
        System.out.println("parent is singing");
    }
}
class Child extends Parent{
    //子类进行了重写
    public void  sing(){
        System.out.println("child is singing");
    }
}

3、一共有两种类型的强制类型转换：

       a)向上类型转换(upcast)：比如说将Cat类型转换成Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显示指定。

       b)向下类型转换(downcast)：比如将Animal类型转换为Cat类型。即将父类型转换为子类型。对于向下类型转换，必须要显示指定(必须要使用强制类型转换)。

public class PolyTest2 {
    public static void main(String[] args) {
        Animal a=new Dog();
        Dog dog=(Dog) a;//把a强制转换成Dog类型，简单的说a指向谁就能转换成什么样类型的引用，也叫向下类型转换
        dog.sing();
        Cat cat=new Cat();
        Animal animal=cat;//向上类型转换
        animal.sing();
        Dog d=(Dog)animal;//这样写是错误的，虽然编译的不报错，但是运行的时候会报错误,因为多态分编译期多态和运行期多态
        d.sing();
    }
}
class  Animal{
    public  void  sing(){
        System.out.println("animal is singing");
    }
}
class Dog extends Animal{
    public  void sing(){
        System.out.println("dog is sinsing");
    }
}
class Cat extends Animal{
    public void sing(){
        System.out.println("cat is singing");
    }
}

        问题:什么时候使用向下类型转换呢？

public class PolyTest3 {
    public static void main(String[] args) {
        //当子类有特有的方法，父类不存在这个特有的方法的时候，必须用强制类型转换(向下类型转换)
        Fruit fruit=new Pear();
        Pear p=(Pear)fruit;
        p.grow();
    }
}
class Fruit{
    public  void  run(){
        System.out.println("fruit is running");
    }
}
class Pear extends  Fruit{
    public void  run(){
        System.out.println("pear is running");
    }
    public void grow(){
        System.out.println("grow is running");
    }
}

        结果：grow is running

        多态在实际开发中有什么用？

                以下面这个程序为例：

public class PolyTest4 {
    public void run(BMW bmw){
        bmw.run();
    }
    public void run(QQ qq){
        qq.run();
    }

    public static void main(String[] args) {
        PolyTest4 test4=new PolyTest4();
        BMW bmw=new BMW();
        test4.run(bmw);
        QQ qq=new QQ();
        test4.run(qq);
    }
}

class Car {
    public void run() {
        System.out.println("car is running");
    }
}

class BMW extends Car{
    public void run(){
        System.out.println("BMW is running");
    }
}
class  QQ extends Car{
    public void run(){
        System.out.println("QQ is running");
    }
}

        运行结果：

                BMW is running

                QQ is running

    假如有上百辆车呢？

public class PolyTest4 {
    public void run(Car car){
        car.run();
    }
    public static void main(String[] args) {
        PolyTest4 test4=new PolyTest4();
        Car car=new BMW();
        test4.run(car);
        QQ qq=new QQ();
        test4.run(qq);
        //以此类推一百辆车也可以这样写
    }
}

class Car {
    public void run() {
        System.out.println("car is running");
    }
}

class BMW extends Car{
    public void run(){
        System.out.println("BMW is running");
    }
}
class  QQ extends Car{
    public void run(){
        System.out.println("QQ is running");
    }
}