Java之多态

一、多态前言

1.为什么要使用多态

Java中使用多态的主要目的是提高代码的可重用性和扩展性，使得代码更加灵活和易于维护。通过多态，我们可以将不同的对象看做是同一种类型，从而使得我们可以使用同一种接口来操作这些对象，而不必关心具体的实现细节。

2.多态概念

当父类的引用所指向的子类对象引用指向的对象不一样时。调用重写的方法，所表现出来的行为是不一样的，我们把这种思想叫做多态。上面所说的可能大家会觉得有点抽象，看到后面就懂了。
多态的基础是动态绑定，所以要了解多态前提我们还要了解动态绑定。
要想实现动态绑定，需要满足以上几个条件：
1.要发生向上转型
2.要发生重写
3.使用父类对象的引用去调用重写方法
完成了这三部分，就会发生动态绑定，而在这里，出现了重写以及向上转型这些概念。所以我们得先了解它们才能去了解动态绑定。进而了解多态。

二、重写

1.重写的概念

方法重写的规则：
1.子类在重写父类的方法时，必须与父类方法原型一致：即返回值、方法名、参数列表要完全一致
2.被重写的方法的访问修饰限定符在子类中要大于等于父类的。
3.父类中被static或private或final修饰的方法以及构造方法都不能被重写。 
4.在子类中重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验。

2.重写的作用

三、向上转型

四、多态的实现

多态具体点就是去完成某个行为时，当不同的对象去完成同一件事时（调用eat方法）会产生出不同的状态。代码如下：

class Animal {

    public void eat(){

        System.out.println( "吃饭");

    }

}

 class Cat extends Animal{

    @Override //注解

    public void eat(){

        System.out.println("吃鱼~~~");

    }

}

 class Dog extends Animal {

    @Override

    public void eat(){

        System.out.println("吃骨头~~~");

    }

}

public class TestAnimal {

    public static void eat(Animal a){

        a.eat(); //两次调用该方法，但是结果却不一样

    }

    public static void main(String[] args) {

        Cat cat = new Cat();

        Dog dog = new Dog();

        eat(cat);

        eat(dog);

    }

}

//输出结果

吃鱼~~~
吃骨头~~~

此时在上述代码中当父类的引用所指向的子类对象引用指向的对象不一样时。调用重写的方法（eat），所表现出来的行为是不一样的(输出结果不一样),我们把它叫做多态。

五、向下转型

六、多态的优缺点

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 class Mainn {

    public static void main(String[] args) {

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

            }

        }

    }

}

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 class Mainn {

    public static void main(String[] args) {

            Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),

                    new Rect(), new Flower()};

            for (Shape shape : shapes) {

                shape.draw();

            }

        }

            }

七、避免在构造方法中调用重写的方法

class B {

public B () {

// do nothing

func ();

}

public void func () {

System . out . println ( "B.func()" );

}

}

class D extends B {

private int num = 1 ;

@Override

public void func () {

System . out . println ( "D.func() " + num );

}

}

public class Test {

public static void main ( String [] args ) {

D d = new D ();

}

}

// 执行结果

D . func () 0 // 此时子类对象还没构造完成，故num的值为0