JavaSE：多态

1. 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。 （同样一件事，我和你去做是两种效果）

 总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

2. 多态实现条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 完成向上转型
2. 完成方法重写
3. 通过父类的引用调用重写的方法

   class Animal{
       private String name;
       private int age;
   
       public Animal(String name, int age) {
           this.name = name;
           this.age = age;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   
       public void eat(){
           System.out.println("正在吃饭(Animal)");
       }
       @Override
       public String toString() {
           return "Animal{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
   }
   class Dog extends Animal{
   
       public Dog(String name, int age) {
           super(name, age);
       }
       public void eark(){
           System.out.println(getName()+"正在汪汪汪");
       }
   
       @Override
       public void eat() {
           System.out.println(getName()+"正在吃狗粮");
       }
   }
   class Bird extends Animal{
       public String wing;
   
       public Bird(String name, int age) {
           super(name, age);
       }
       public void fly(){
           System.out.println(getAge()+"正在飞");
       }
       @Override
       public void eat(){
           System.out.println(getName()+"要吃鸟粮");//动态绑定：重写
       }
   }
   
   public class Test {
       //----------------------类的调用者实现的------------------------//
       private static void func(Animal animal){
           animal.eat();//不论引用的对象
       }
       public static void main(String[] args) {
           //父类引用，引用了子类对象，通过父类的引用，调用这个重写的方法，此时发生了动态绑定！
           //此时 父类引用只有一个，我引用的对象不一样，但是通过调用同一个方法，我们发现此时表现的形式是不一样
           //把这个现象称为:多态
           func(new Bird("小鸟",1));
           func(new Dog("狗子",1));
       }
   }
   
   

    

4. 在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

5. 当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为多态.

3. 重写 

 

重写(override)：也称为覆盖。
重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
 

重写

class Animal{
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println("正在吃饭(Animal)");
    }
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void eark(){
        System.out.println(getName()+"正在汪汪汪");
    }

}
class Bird extends Animal{
    public String wing;

    public Bird(String name, int age) {
        super(name, age);
    }
    public void fly(){
        System.out.println(getAge()+"正在飞");
    }
    public void eat(){
        System.out.println(getName()+"要吃鸟粮");//动态绑定：重写
    }
}

public class Test {
    public static void main(String[] args) {
        Bird bird = new Bird("鹦鹉",2);
        Animal animal=bird;//向上转型，把子类的类给父类
        //animal.fly  error:fly是bird类的，在这里我们是用的animal类
        //animal.wing  error:不可以调用了，此时通过父类引用，只能调用自己特有的方法
        animal.eat();
    }
}

//运行结果:鹦鹉要吃鸟粮

【方法重写的规则】

 
被重写的方法返回值类型可以不同，但是必须是具有父子关系的！！

class a{
    public a eat(){
        return new a();
    }
}
//子类的返回值和父类是父子类关系也可以【协变类型】
class b extends a{
    public b eat(){
        return new b();
    }
}

当我们不想让方法重写时：只需加上final

 

 

【重写和重载的区别】 

区别点	区别点 重载(override)	重写(override
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
访问限定符	可以修改	一定不能做更严格的限制（可以降低限制）

 即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

 

【重写的设计原则】 

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，
并且添加或者改动新的内容。
例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅
可以显示号码，还可以显示头像，地区等。在这个过程当中，我们不应该在原来老的类上进行修改，因为原来的
类，可能还在有用户使用，正确做法是：新建一个新手机的类，对来电显示这个方法重写就好了，这样就达到了我
们当今的需求了。 

 

4. 向上转移和向下转型

4.1 向上转型

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

语法格式：

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

Animal animal = new Cat("喵喵",2);

 animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换

使用场景：

1. 直接赋值
2. 方法传参
3. 方法返回

 

public class TestAnimal {
	// 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
	public static void eatFood(Animal a){
		a.eat();
	}


	// 3. 作返回值：返回任意子类对象
	public static Animal buyAnimal(String var){
		if("狗" == var){
			return new Dog("狗狗",1);
		}else if("猫" == var){
			return new Cat("猫猫", 1);
		}else{
			return null;
		}
}

	public static void main(String[] args) {
		Animal cat = new Cat("喵喵",2); // 1. 直接赋值：子类对象赋值给父类对象
		Dog dog = new Dog("汪汪", 1);
		
		eatFood(cat);
		eatFood(dog);
		
		Animal animal = buyAnimal("狗");
		animal.eat();
		
		animal = buyAnimal("猫");
		animal.eat();
	}
}

向上转型的优点：让代码实现更简单灵活
向上转型的缺陷：不能调用到子类特有的方法

 

 4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的
方法，此时：将父类引用再还原为子类对象即可，即向下转换。 

 

class Animal{
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println("正在吃饭(Animal)");
    }
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void eark(){
        System.out.println(getName()+"正在汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println(getName()+"正在吃狗粮");
    }
}
class Bird extends Animal{
    public String wing;

    public Bird(String name, int age) {
        super(name, age);
    }
    public void fly(){
        System.out.println(getName()+"正在飞");
    }
    @Override
    public void eat(){
        System.out.println(getName()+"要吃鸟粮");//动态绑定：重写
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal= new Bird("鹦鹉",2);
        Bird bird = (Bird)animal; 
        bird.fly();

        /*********************************************************/

        //error：不是所有的动物都是鸟
        /*Animal animal1=new Dog("狗子",1);
        Bird bird = (Bird)animal;
        bird.fly();*///
    }
}

//运行结果:鹦鹉正在飞

向下转型需要向上转型完毕后再去向下转型，向下转型成功后，可以调用子类的对应方法了

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了instanceof ，如果该表达式为true，则可以安全转换。

public class Test {
	public static void main(String[] args) {
		Bird bird = new Bird("鹦鹉",2);
		Dog dog = new Dog("汪汪", 1);


		// 向上转型
		Animal animal = bird;
		animal.eat();
		animal = dog;
		animal.eat();
          //animal 是不是引用了 Bird这个对象 
		if(animal instanceof Bird){
			bird = (Bird)animal;
			bird.new();
		}
          //animal 是不是引用了 Dog这个对象 
		if(animal instanceof Dog){
			dog = (Dog)animal;
			dog.bark();
		}
	}
}

5. 多态的优缺点 

使用多态的好处：
1.避免使用大量的 if - else 

在没有多态的情况下：

 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();
            }
        }
    }

在多态的情况下：如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单

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 Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("▲");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("");
    }
}

public class Test2 {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Triangle triangle =new Triangle();
        Flower flower = new Flower();
        /*drawMap(rect);
        drawMap(cycle);
        drawMap(triangle);
        drawMap(flower);*/
        Shape[] shapes = {rect,cycle,triangle,flower};
        for (Shape shape:shapes){
            //当前shape引用的对象重写draw方法就调用，没有就调用shape自己的
            shape.draw();
        }
    }
}

 

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

class Triangle extends Shape {
	@Override
	public void draw() {
		System.out.println("△");
	}
}