Java多态

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();
 }
}
//我们可以明显看出使用多态的好处

能够降低代码的 "圈复杂度", 避免使用大量的 if - else；

可扩展能力更强，如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低；

5.2 缺点

属性没有多态性，当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性；

构造方法没有多态性；

1.多态是什么？

2.多态的条件