Chp10-多态

目录

概念

语法

使用

引用类型间的类型强转

多态的使用场景

instanceof关键字

语法

使用

多态的好处

---

声明类型的多种赋值形态

多态会发生在所有大类型与小类型之间，不止是父子类

多态中所有的知识点都可以换算到所有引用类型的多态上

概念

父类引用指向子类对象

大类型引用指向小类型对象

语法

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

父类引用=子类对象;
大类型引用=小类型对象;

使用

1. 实际创建的是子类对象

2. 优先执行子类内容

3. 父类引用无法访问子类独有内容

   • 编译器关注的是引用类型，解释器关注的是实际对象类型

   • 语法结构中，等号左边决定了能做什么，等号右边决定了是什么

引用类型间的类型强转

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

• 只能转向原本指向的子类类型

  • 编译成功，运行报错

• 子类之间不可强转

  • 编译报错

//利用多态创建Dog对象
        Animal a = new Dog();
        a.eat();//狗吃大骨头
        a.sleep();//睡觉
        //a.lookDoor();
        //将Animal类型的引用强转为Dog类型
        Dog dog = (Dog) a;
        dog.lookDoor();
​
       // Cat cat = (Cat) a; 运行报错
​
        Dog d = new Dog();
        //Cat c = (Cat) d; 编译报错

多态的使用场景

1. 用于容器(变量|对象|数组|集合): 将容器类型声明为大类型,则容器内部可以存放不同的小类型对象

           //创建数组,存储若干个Dog和Cat对象
           Animal[] as = {new Dog(), new Cat()};
           //遍历调用动物们的吃饭方法
           for (int i = 0; i < as.length; i++) {
               /*Animal as[0]=new Dog()
               Animal as[1]=new Cat()
               * */
               as[i].eat();
           }

2. 用于参数: 将方法形参声明为大类型,则实参可以传入不同的小类型对象

   public static void main(String[] args) {
           method(new Dog());
           method(new Cat());
          // method(new tuzi());
       }
       //定义一个函数,传入参数,要求调用吃饭方法,可以执行出"狗吃大骨头"|"猫吃小鱼干" | "兔子吃萝卜"
      public static void method(Animal a){//Animal a=new Cat()
           a.eat();
      }

3. 用于返回值: 将方法返回值值声明为大类型, 则可以实际return不同的小类型对象

   • 接收返回值时,仍需使用大类型接收

   public static void main(String[] args) {
           Animal a=method(10);//Animal a=new Dog();
           //接收返回值并进行类型强转
           Dog dog = (Dog) method(10);
       }
       //定义一个函数,传入整型参数n,判断n的奇偶性,偶数返回Dog对象,否则返回Cat对象
       public static Animal method(int n){
           if (n % 2 == 0) {
               return new Dog();
           }
           return new Cat();
       }

instanceof关键字

作用为判断当前对象与指定类型是否兼容, 返回值为布尔类型

语法

引用名 instanceof 类名

//定义一个Animal类型的数组,存入若干个Dog和Cat对象,
        // 要求为Dog对象执行看门方法,否则执行吃饭方法
        Animal[] as = {new Dog(), new Dog(), new Cat()};
        for (int i = 0; i < as.length; i++) {
            //判断当前对象是否与Dog兼容
            if (as[i] instanceof Dog) {
                //调用看门方法
                //( (Dog)as[i]).lookDoor();
                //将当前对象的引用强转为Dog
                Dog dog = (Dog) as[i];
                dog.lookDoor();
            } else {
                as[i].eat();
            }
​
        }

使用

大类型可以兼容小类型对象

        Dog a = new Dog();
        System.out.println(a instanceof Dog);//t
        System.out.println(a instanceof Animal);//t
​
        Dog d = new Keji();
        System.out.println(d instanceof Keji);//t
        System.out.println(d instanceof Dog);//t
        System.out.println(d instanceof Animal);//t

多态的好处

1. 提高代码扩展性

2. 更贴合现实逻辑