【Java】多态

是小辰

已于 2023-09-23 18:05:20 修改

阅读量4.5k

点赞数 35

分类专栏： JavaSE 文章标签： servlet java 开发语言

于 2023-04-02 13:11:25 首次发布

本文链接：https://blog.csdn.net/weixin_73392477/article/details/129824411

版权

JavaSE 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

面向对象程序三大特性：封装、继承、多态。

1.多态是什么？

概念：

简单的说就是一个对象有多种形态，具体点说多态就是父类中的属性和方法被子类继承后，可以具有不同的数据类型或不同的行为，使父类中的同一个属性和方法在父类与各个子类具有不同的含义。

举例：

如下图：子类都继承了父类，但同一个eat方法在不同父类子类中表现不同行为就是多态。

2.多态的条件

三大条件：

继承：必须存在继承；
重写：子类必须对父类中的方法进行重写；
向上转型：通过父类的引用调用子类的重写的方法；

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(this.name + "吃饭");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Dog extends Animal{ //继承
@Override   //重写               
    public void eat() { //向上转型
        System.out.println(this.name + "吃狗粮");
    }
    public void sleep(){
        System.out.println(this.name + "在睡觉");
    }

    public Dog(String name, int age) {
        super(name, age);
    }
}
class Cat extends Animal{ //继承
    @Override   //重写 
    public void eat() { //向上转型
        System.out.println(this.name + "吃猫粮");
    }
    public void sleep(){
        System.out.println(this.name + "在睡觉");
    }

    public Cat(String name, int age) {
        super(name, age);
    }
}
public class Test1 {
    public static void eat(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Cat cat = new Cat("花花",1);
        Dog dog = new Dog("多多",2);
        eat(cat);
        eat(dog);
    }
}

上述代码满足了多态的三个条件，并实现了多态。

3.重写

3.1重写的概念

重写（override）：又称覆盖，在子类中创建一个与父类具有相同的返回值类型、方法名、参数列表的方法，以实现与父类不同的行为。

3.2重写的作用

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强，满足子类的需求。

3.3重写的规则

参数列表必须完全与被重写的方法参数列表相同；
返回的类型必须与被重写的方法的返回类型相同；
访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）；
重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常；
不能重写静态、private修饰、final修饰、构造方法等；
父类的成员方法只能被它的子类重写。

2中代码就构成了重写。

注意：

避免在构造方法中调用重写的方法，不然可能会造成一些隐藏的问题。

4.向上转型与向下转型

4.1向上转型

向上转型：实际上就是创建一个子类对象，将其当作父类对象来使用。

格式：父类类型对象名 = new 子类类型（）；

例如：

Animal cat = new Cat（"多多"，1）；
//向上转型，将Cat类型转换为Animal类型
//小范围向大范围的转换

这段代码就是直接赋值实现向上转型，2中代码就是通过方法传参来实现向上转型，然后也可以通过方法返回来实现向上转型。

优点：让代码实现更灵活简单；

缺点：不能调用子类特有的方法；

4.2向下转型

当子类对象向上转型后，将无法调用子类中的方法，如果我们想调用子类特有的方法，我们就可以使用向下转型，将父类引用还原成子类对象即可。

向下转型有的时候不太安全，例如：一个狗类对象向上转型转换为动物类，在向下转型的时候不一定转换为狗类，可能转换为猫类等，所以当我们向下转型的时候要加上强制转换符。

有的时候也会造成抛出异常，所以Java中引入了instanceof，如果结果为true，则可以安全转换。

public class Test{
  public static void main(String[] args) {
    Cat cat = new Cat("花花",2);
    Dog dog = new Dog("多多", 1);
    // 向上转型
    Animal animal = cat;
    animal.eat();
    animal = dog;
    animal.eat();
    if(animal instanceof Cat){
      cat = (Cat)animal;
      cat.mew();
   }
    if(animal instanceof Dog){
      dog = (Dog)animal;
      dog.bark();
   }
 }
}

5.多态的优缺点

5.1 优点

举例：

//假如打印一个形状
class Shape {
  //属性....
  public void draw() {
    System.out.println("画图形！");
 }
}
class Rect extends Shape{
  @Override
  public void draw() {
    System.out.println("♦");
 }
}
class Cycle extends Shape{
  @Override
  public void draw() {
    System.out.println("●");
 }
}
class Flower extends Shape{
  @Override
  public void draw() {
    System.out.println("❀");
 }
}
//不使用多态
public static void drawShapes() {
  Rect rect = new Rect();
  Cycle cycle = new Cycle();
  Flower flower = new Flower();
  String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
 
  for (String shape : shapes) {
    if (shape.equals("cycle")) {
      cycle.draw();
   } else if (shape.equals("rect")) {
      rect.draw();
   } else if (shape.equals("flower")) {
      flower.draw();
   }
 }
}
//使用多态
public static void drawShapes() {
  // 我们创建了一个 Shape 对象的数组.
  Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
           new Rect(), new Flower()};
  for (Shape shape : shapes) {
    shape.draw();
 }
}
//我们可以明显看出使用多态的好处