多态

概念

父类引用指向子类对象

父类类型的一个变量中存储了一个子类的对象

多态的理解

一个事物是什么取决于你认为它是什么(引用类型)

你认为的 ---> 引用类型
一个事物是什么 ----> 对象

多态的概念

• 属性没有多态(不研究)
• 成员方法具有多态
  -(1)编译时多态————在编译时只能调用引用类型所对应类中声明的方法
  -(2)运行时多态————在多态发生时，运行时调用的是子类重写父类后的方法实现
• 口诀

编译看左边 运行看右边   
	左边   = 右边
举例：
 Animal animal = new Cat();

多态中类型之间的转换

• 对象一旦创建其类型不可以变

• 向上转型

将子类类型的对象引用，赋值给父类类型引用。
    
意义: 可以忽略 子类之间的差异,提升为父类类型进行统一的处理  

• 向下转型

将父类类型的引用 赋值给子类的引用

意义: 恢复类子类原来的特征 通过向下转型 可以调用子类中特有的方法 

类型转换异常

 //Exception in thread "main" java.lang.ClassCastException: Demo1.Cat cannot be cast to Dmeo1.Dog
        //	at Demo1.main(Demo1.java:14)
        
当使用强制的方法进行转换的时候,可能会发生类型转换异常. 

instanceof 语句(实例属于 )

• 语法

  引用名 instanceof 类型

• 作用

  判断一个引用中引用的对象是什么类型的数据

• 案例

package com.ujiuye.day10;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
//        Animal animal = new Cat();
//
//        boolean f = animal instanceof  Dog;// animal 变量中引用的对象的类型是否属于 dog 类型
//        System.out.println(f);

        Animal animal = new Dog();

        if (animal instanceof  Dog){
            //进行向下转型
            Dog dog = (Dog) animal;
            dog.eat();
            dog.sleep();
            dog.shout();
        }else{
            Cat cat = (Cat) animal;
            cat.eat();
            cat.sleep();
            cat.catchMouse();
        }
    }
}

//动物类
class Animal{
    String name;
    int age;

    public void eat(){
        System.out.println("动物吃");
    }

    public void  sleep(){
        System.out.println("动物睡觉");
    }

}
//狗类
class Dog extends Animal{

    //重写 父类中的方法

    @Override
    public void eat() {
        System.out.println("狗汪汪汪的吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗趴着睡觉");
    }

    //特有的方法
    public void shout(){
        System.out.println("狗汪汪汪的叫");
    }
}

class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫喵喵的吃鱼");
    }

    @Override
    public void sleep() {
        System.out.println("猫 呼呼的睡觉");
    }

    //特有的功能
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

多态的应用

• 多态用在数组中

package com.ujiuye.day10;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        //创建一个动物园
        // zoo 里边 的每个元素的引用是什么类型 Animal   但是存放的是 子类对象  父类引用指向子类对象
        Animal[] zoo = {
                new Dog(),
                new Cat(),
                new Cat(),
                new Wolf(),
                new Wolf(),
                new Wolf(),
                new Wolf(),
                new Monkey(),
                new Monkey(),
             
        };
        //假设 现在动物园开饭了
        //通过循环
        for (int i = 0; i < zoo.length; i++) {
            zoo[i].eat();
          
        }
    }
}

//动物类
class Animal{
    public void eat(){
        System.out.println("动物吃");
    }

    public void  sleep(){
        System.out.println("动物睡觉");
    }

}
//狗类
class Dog extends Animal{


    @Override
    public void eat() {
        System.out.println("狗汪汪汪的吃肉");
    }


    //特有的方法
    public void shout(){
        System.out.println("狗汪汪汪的叫");
    }
}

class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫喵喵的吃鱼");
    }


    //特有的功能
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//猴子
class Monkey extends  Animal{
    @Override
    public void eat() {
        System.out.println("猴子吃桃");
    }
}

//狼
class Wolf extends Animal{
    @Override
    public void eat() {
        System.out.println("狼吃羊");
    }
}

• 多态用在方法的参数上

• 多态用在方法的返回值上

举例：
有一个动物园,其中有很多动物, 找出其中所有的狗,进行获取,在主方法中,饲养狗

import java.util.Arrays;
import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Animal[] zoo = {
                new Dog(),
                new Dog(),
                new Cat(),
                new Wolf(),
                new Wolf(),
                new Wolf(),
                new Monkey(),
                new Monkey(),
                new Monkey(),
                new Monkey(),
                new Monkey()
        };

        Dog[] dog = getDog(zoo);

        //饲养所有的狗
        for (int i = 0; i < dog.length; i++) {
            dog[i].eat();
        }
    }
    //方法一
    //  方法名 : getDog  形式参数列表  Animal[] zoo   返回值类型 Dog[]
//    public static  Dog[] getDog(Animal[] zoo){
//        //1 确定 动物园中有几只狗
//        int dogCount = 0;
//        for (int i = 0; i < zoo.length; i++) {
//            //判断每只动物是否是狗
//            if (zoo[i] instanceof Dog){
//                dogCount++;
//            }
//        }
//
//        //2 根据狗的个数确定狗窝的大小
//        Dog[] dogsHouse = new Dog[dogCount];
//
//        //3. 将所有的狗存储到狗窝中
//        int index = 0;
//        for (int i = 0; i < zoo.length; i++) {
//           if (zoo[i] instanceof Dog){
//               //向下转型
//               dogsHouse[index] =(Dog) zoo[i];
//               index++;
//           }
//        }
//
//        //4 将狗窝返回
//        return  dogsHouse;
//
//    }

    //方法二
    public static Dog[] getDog(Animal[] zoo){
        //1 遍历每一个动物 判断是否为狗 是狗就存储到狗窝中
        // 创建一个狗窝 容量为 0
        Dog[] dogHouse = new Dog[0];

        for (int i = 0; i < zoo.length; i++) {
            if (zoo[i] instanceof Dog){
                //存储到狗窝中
                // 扩容
                //dogHouse = dogHouseCopy(dogHouse);
                dogHouse = Arrays.copyOf(dogHouse,dogHouse.length+1);
                dogHouse[dogHouse.length-1] = (Dog) zoo[i];
            }
        }
        return dogHouse;
    }

    //定义一个方法作用 是用于进行狗窝的扩容每次扩容 1
//    public static Dog[] dogHouseCopy(Dog[] dogs){
//        Dog[] newHouse = new Dog[dogs.length+1];
//        //复制原来数组的元素
//        for (int i = 0; i < dogs.length; i++) {
//            newHouse[i] = dogs[i];
//        }
//        return newHouse;
//    }



}

//动物类
class Animal{
    public void eat(){
        System.out.println("动物吃");
    }

    public void  sleep(){
        System.out.println("动物睡觉");
    }

}
//狗类
class Dog extends Animal{


    @Override
    public void eat() {
        System.out.println("狗汪汪汪的吃肉");
    }


    //特有的方法
    public void shout(){
        System.out.println("狗汪汪汪的叫");
    }
}

class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫喵喵的吃鱼");
    }


    //特有的功能
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//猴子
class Monkey extends  Animal{
    @Override
    public void eat() {
        System.out.println("猴子吃桃");
    }
}
//狼
class Wolf extends Animal{
    @Override
    public void eat() {
        System.out.println("狼吃羊");
    }
}

多态的好处

1.屏蔽⼦类之间的差异性
2.增强了⽅法的通⽤性
3.利于程序的扩展