27.0/多态/对象向上转型/向下转型/抽象类/抽象方法。

目录

27.1为什么使用多态?

 27.1.2什么是多态

 27.1.3对象多态

 27.1.4多态的使用前提

27.2 向上转型

27.3向下转型

 (面试题)

 27.4抽象类和抽象方法

特点(面试题):

---

27.1为什么使用多态?

需求1：动物园让我们实现一个功能： 创建一个狗类 ，狗有eat()方法，再创建一个饲养员类，饲养

员有一个feed()方法，让饲养员喂养狗。

 

Dog:
public class Dog {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println(name+"狗吃奥里给");
    }
}

 

Feeder
public class Test01 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("Jerry");

        Feeder f=new Feeder();
        f.feed(dog);
    }
}

 

需求2：此时动物园引进新品种 猫，此时需要创建一个猫类。并添加eat方法，让人类也能喂养猫。

需求3：此时动物园又引进了一种新动物，叫做pig猪 此时pig也有eat 并且 人类也需要喂养pig，请完成功能。

每次动物园引进新产品，都需要在饲养员类中增加一个方法，如果动物园有10000个动物，那么饲养员类中需要增加10000喂养的方法。

使用多态来解决上面代码耦合性。

 27.1.2什么是多态

多态:在继承实现情况下的一种现象，

表现为：对象多态、行为多态

 

 27.1.3对象多态

多态性:

允许你将父对象设置成为一个或更多的他的子对象相等的技术，

赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作.

简单一句话：允许将子类类型赋值给父类类型

多态：

父类对象表现多种子类的形态的能⼒的特征，

⼀句话多态就是⽗类引用子类对象。

向同⼀个⽗类的不同⼦类发送同⼀条消息，⾏为不同。

 27.1.4多态的使用前提

必须有继承|实现关系。

 Animal

package demo02;

/**
 * @program: day1106
 * @description:
 * @author: 闫克起2
 * @create: 2023-11-06 15:34
 **/
public class Animal {
    private String name;

    public void eat(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 Dog

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println(getName()+"吃奥里给");
    }
}

Cat  

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println(getName()+"吃鱼");
    }
}

 Feeder

public class Feeder {

    //
    public void feed(Animal animal){//Animal animal=new Dog();
        animal.eat();
    }


}

 Test

package demo02;

/**
 * @program: day1106
 * @description:
 * @author: 闫克起2
 * @create: 2023-11-06 15:14
 **/
public class Test01 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("Jerry");

        Cat c=new Cat();
        c.setName("Tom");

        Feeder f=new Feeder();
        f.feed(dog);
        f.feed(c);
      
    }
}

如果在增加新的品种动物，无需修改Feeder饲养员类中的代码了。 解决耦合性。

 

1. 包含小狗 小猫 小猪 有一个共同的方法会摆造型

打印机 能够打印动物的造型

良好的可扩展性和可维护性

27.2 向上转型

向上转型：⽗类引⽤⼦类对象（⾃动成⽴，缺点是失去调⽤⼦类独有⽅法的能⼒）

父类 对象名=new 子类();

 Dog中的代码：

package com.ykq.duotai;
public class Dog extends Animal {
    // eat
    @Override
    public void eat(){
        System.out.println("我是一只狗，我喜欢吃奥里给！！！");
    }
    // 看家 watchDoor()
    public  void watchDoor(){
        System.out.println("狗会看门！！！");
    }
}

 test类：

Animal animal = new Dog();// 向上转型
 // dog 赋值给Animal
animal.eat();
animal.watchDoor(); // 报错

 

向上转型后该对象只能当成父类对象来用，

原来子类中定义的属性和方法就被屏蔽掉不能被调用了。

比如

狗里有一个【看门】的方法，

如果向上转型后作为【动物】类就不能调用dog类独有的【看门】的方法。

 总结: 向上转型 从小的转向大的 缺点：不能调用子类里面的特有的方法 .

1. 能调用哪些方法看等号的左边。

2. 执行哪个方法看等号的右边。

27.3向下转型

向下转型：⼦类引⽤⽗类对象（强制转换，慎重）

public static void main(String[] args) {
    // Dog
    Animal dog = new Dog();
    // ⼦类引⽤⽗类对象
    Dog dog1 = (Dog) dog;
    // 向下转型 可以调用子类里面方法   属性
    dog1.watchDoor();
    Cat cat = (Cat) dog;

}
 

 

此时可以调用子类对象中的方法和属性。

注意事项：ClassCastException

 

 (面试题)

 

以上为继承多态 占据5% 继承多态。

继承多态，接口多态95%。

向下转型: 大的转化为小的

缺点:强制类型转换 ClassCastException类型转换异常

优点: 调用子类里面的独有的方法

 27.4抽象类和抽象方法

 抽象类表示现实中并不存在该类，只是为了代码的可用性而抽取的一个父类。

 

 

使用abstract修饰类和方法。

语法:

public abstract class 类名{

​      public abstract 返回类型 方法名(参数列表);

}

抽象类

/**
    1.抽象类使用abstract修饰. 该类中可以有抽象方法和普通方法.
    2.抽象类不能实例化对象.
    3.子类继承了抽象类,那么该子类需要重写抽象类中的所有抽象方法.
 **/
public abstract class Shape {

    //求面积
    public  void area(){};

    //求周长
    public abstract void perimeter();

    public void show(){
        System.out.println("普通方法");
    }
}

长方形子类

public class Rect extends Shape {
    @Override
    public void area() {
        System.out.println("长乘宽");
    }

    @Override
    public void perimeter() {
        System.out.println("长加宽乘2");
    }
}

 测试类:

public class Test {
    public static void main(String[] args) {
        Shape s=new Circle();//向上转型
        s.area();
        s.perimeter();
        s.show();
    }
}

特点(面试题):

1)抽象类不能new对象

   2)抽象类可以有构造方法，专门让子类调用的。（super(color, name)）。

   3)抽象类中可以含有抽象方法，也可以没有抽象方法。

   4)抽象类中可以含有普通实例方法。  sleep()

   5)抽象方法必须使用abstract修饰，并且不能有方法体（不能有{}）。

   6)子类继承抽象类时必须重写所有的抽象方法（参考demo2中的Cat），如果不重写自己必须是抽象类（参考demo2中的Dog）。

   7)含有抽象方法的类一定是抽象类。（把抽象类上的abstract去掉，看是否报错）

 

1. 多态: 一个类对象具有多种形态。

2. 对象的多态: 父类 对象名=new 子类对象(); 向上转型