Java中的多态

一 多态的概念

多态：就是一个事物的多种形态，这是建立在继承之下才有的概念，在Java中就是调用对象，不同的对象有不同的表示形态

多态的实现条件
1.在继承关系之下
2.子类重写父类中的方法
3.通过父类来调用被重写的方法

例如狗和猫都是动物，但是狗吃的是骨头 ，而猫吃的是小鱼干

class Animal {
    //父类
        public String name;
        int age;
        //父类构造方法
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void eat(){
            System.out.println(name+"吃饭");
        }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);//先要访问父类的构造方法
    }
    //重写父类的eat方法
    @Override
    public void eat() {
        System.out.println(name+"吃小鱼干");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    //重写父类的eat方法
    @Override//注解
    public void eat(){
        System.out.println(name+"吃骨头");
    }
}
public class Test {
    public static void func(Animal animal){
        animal.eat();
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Dog("旺财",1);
        Animal animal1 = new Cat("sansan",2);

        func(animal);
        func(animal1);
    }
}

运行结果如下

这里有父类Animal和子类Cat和Dog,这里通过父类创建对象，通过父类访问eat方法，但是访问的并不是父类中的方法，而是对应子类的方法，这就是多态

多态是在重写、向下转型和向上转型之下完成

二 重写

重写的概念

重写：简单来说就是子类对父类的方法进行重写，这里的重写参数列表相同，返回值可以相同和不同，不相同的话要有父子关系，和父类中被重写的方法的框架不变，里面的内容改变

重写规则
1.二者之间有继承关系，⼦类在重写⽗类的⽅法时，子类中方法返回值、参数列表、方法名称一样，返回类型⼀般必须与⽗类⽅法原型⼀致，返回类型可以不同，如果不同，返回值要有构造父子关系
2.子类中方法的访问权限高于或等于父类
访问权限：private < 默认 < protected < public
3.⽗类被static、private修饰的⽅法、构造⽅法都不能被重写
4.在重写的时候通常加上@Override注解不仅表示这里是重写，而且写了这个编译器会帮我们检验是否有重写语法错误，提高代码的语法准确性

class Animal {
    //父类
        public String name;
        int age;
        //父类构造方法
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void eat(){
            System.out.println(name+"吃饭");
        }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);//先要访问父类的构造方法
    }
    //重写父类的eat方法
    @Override
    public void eat() {
        System.out.println(name+"吃小鱼干");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    //重写父类的eat方法
    @Override//注解
    public void eat(){
        System.out.println(name+"吃骨头");
    }
}

这里的Cat和Dog子类继承父类Animal，并且这里和父类都有一个eat成员方法，子类和父类的成员方法名称一样，参数列表也相同，返回类型也相同

重写与重构的区别

重构的话只是对参数列表要求不同，其他无太大要求，而重写的话，除了参数列表要求相同，其他也有要求
重构是类的多态的表现，而重写是父类和子类之间类多态的表现

运行时区别：
动态绑定(早绑定)：就是在编译时候，就根据用户传参确定调用具体的那个方法，这里的重构就是动态绑定
静态绑定(晚绑定)：就是在编译时候无法确定调用那个方法，运行的时候才知道调用那个方法,这里的重写就是静态绑定

三 向下转型和向上转型

向上转型

向上转型：就是实例化一个子类对象用父类来接收
可以运用到直接赋值、方法传参、返回类型

⽗类类型 对象名 = new ⼦类类型();

以上面的例子举例

//向上转型
        Animal animal = new Dog("旺财",1);
        Animal animal1 = new Cat("sansan",2);

这里就相当于使用小类型Dog和Cat子类的赋值给一个大类型Animal父类

那如何使用呢

class Animal {
    //父类
        public String name;
        int age;
        //父类构造方法
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void eat(){
            System.out.println(name+"吃饭");
        }
}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name, age);//先要访问父类的构造方法
    }
    //重写父类的eat方法
    @Override
    public void eat() {
        System.out.println(name+"吃小鱼干");
    }

    public void mew(){
        System.out.println("喵喵叫");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    //重写父类的eat方法
    @Override//注解
    public void eat(){
        System.out.println(name+"吃骨头");
    }

    public void bark(){
        System.out.println("汪汪叫");
    }
}
public class Test {
//传参时候向上转型
    public static void func(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        //直接赋值向上转型
        Animal animal = new Dog("旺财",1);
        Animal animal1 = new Cat("sansan",2);
       func(animal);//调用子类Dog的方法
       func(animal1);//调用子类Cat的方法
     }
}

运行结果如下

我们这里实例化的是子类对象，使用父类来接收的，并且在传参的时候形参也是用父类Animal来接收实参，那为什么这里是调用子类的方法，而不是父类的呢
是因为这里的重写是运行时绑定，这是的eat方法被重写了，所以调用子类的，如果子类没有重写就调用父类的方法，这样就可以只用一个方法可以调用子类重写父类的方法

那我们可以调用子类中特有的方法吗(调用父类中没有的方法）

从这里发现，这并不能找到子类中特有的方法，因为这里的类型时父类，向上转型的子类中不可以找子类中特有的方法
向上转型的缺点：不可以访问子类特有的方法

那如何解决这个缺陷呢，这时候就需要使用向下转型

向下转型

向下转型：由于上面的向上转型导致子类中的特有方法不可以被访问，这时候需要将父类引用还原成子类类型，这就是向下访问

我们结合上面的Animal Cat和Dog类

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Dog("旺财",1);
        Animal animal1 = new Cat("sansan",2);
        //向下转型
        animal = (Dog)animal;
        animal1 = (Cat)animal1;
       //这里向下
        ((Dog) animal).bark();
        ((Cat) animal1).mew();
        
    }
}

运行结果如下

这样我们就可以访问子类中特有的方法了，这里要注意的是原本是Dog子类就返回Dog类型，不可以返回成Cat类，这肯定是不行的，可以发现这里的向下转型是有点不安全的，这就要引出instanceof 这个Java提供的关键字，如果需要向下转型使用这个
还是以上面的Animal、Cat、Dog类举例

public class Test {

    public static void func(Animal animal) {
        animal.eat();
        //animal.bark;//这是错误的
        //可以通过向下转型访问子类特有方法
        //如果为真进入向下转型访问
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.bark();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.mew();
        }
    }
    public static void main(String[] args) {
        //向上转型
        Animal animal = new Dog("旺财",1);
        Animal animal1 = new Cat("sansan",2);
        func(animal);
        func(animal1);

    }
}

四 多态的优缺点

优点

能够降低代码的"圈复杂度",避免使⽤⼤量的循环的语句
圈复杂度就是一段代码本身上并不难，但是这里如果里面有很多的分支和循环，这就让人感觉比较复杂
如果一段代码仅仅简单粗暴的使用条件语句和循环语句的话，这就导致圈复杂度就会太高，这时候就要想到重构

例如：

class Shape {
    public void draw(){
        System.out.println("画图形");
    }
}
class Tra extends Shape{
    @Override
    public void draw(){
        System.out.println("画一个三角形");
    }
}
class Flower extends Shape{
    @Override
    public void draw(){
        System.out.println("画一朵花");
    }
}
class Cycle extends Shape{
    @Override
    public void draw(){
        System.out.println("画一个圆");
    }
}
public class Test {
    public static void main(String[] args) {
        Flower flower = new Flower();
        Tra tra = new Tra();
        Cycle cycle = new Cycle();
        //创建一个String类型数组，来进行存放打印
        String[] shapes = {"flower","tra","flower","tra","cycle"};
         //for_each进行这里的String数组的元素进行访问
        for (String shape :shapes) {
            if(shape.equals("flower")){
                flower.draw();
            }else if(shape.equals("cycle")){
                cycle.draw();
            }else if(shape.equals("tra")){
                tra.draw();
            }
        }
    }
}

这里我们呢是创建一个String数组，如果打印什么就进入那个对象的打印，使用equals来判断两个字符串是否相同

运行结果如下

可以看出上面的打印图案的代码有if-else语句好多，如果打印更多图形就还会有更多
这时候就要想到多态的思想

public class Test {
    public static void main(String[] args) {
        Tra tra = new Tra();
        Flower flower = new Flower();
        Cycle cycle = new Cycle();
        //向上转型
        Shape[] shapes = {flower,tra,flower,tra,cycle};
        for (Shape shape:shapes) {
            shape.draw();
        }
    }
}

这里是创建一个父类类型的数组，来存放子类对象，这里存在向上转型，这样使用for - each循环来便利整个数组，来进行进入对应子类方法

运行结果如下

使用多态可扩展展性也比较强，如果这里想打印一个新的图形，只需要继承Shape父类，在对其方法重写，在main方法中父类类型数组加上就行，这很简单，但是如果还是使用if - else语句，就变得复杂了

缺点

主要缺点就是在构造方法中访问 被重写的方法

class A{
    //父类的构造方法
    public A(){
        //触发动态绑定
        //访问的是子类的func方法
        func();
    }
    public void func(){
        System.out.println("A的func方法");
    }
}

class B extends A{
    public int a = 10;
    //重写父类的方法
    @Override
    public void func() {

        System.out.println("B的func方法 "+ a);
    }
}
public class Test {
    public static void main(String[] args) {
        B b = new B();
    }
}

运行结果如下

可以看出这里进入的是子类的func方法，但是这里的a为什么还是默认初始化呢，这就出现了顺序问题
1.这里实例化了一个子类对象B，父类有默认参数的构造方法，子类也会默认生成一个不带参数的构造方法
2.这里我们实例化后，就会先访问父类的构造方法
3.父类A的构造方法又访问这里被重写的func方法，所以访问的是子类B中func方法，但是之前这里并没有经历初始化a,直接经过父类进入方法，所以这里的a为0

使用时要注意：

要保证每个对象都可以简单的构造成功，因此尽量不要在构造方法中调用其他方法，尤其是被重写的方法，因为构造方法优先执行，构造方法访问一个方法，如果这个方法被重写了，发生动态绑定访问子类的方法，但此时的子类重写方法并没有构造完成就被使用了

到这里就结束了，希望对大家有所帮助，预知后事如何，请听下回分解