Java 面向对象的特性之一——多态

前言

之前我们讲完了Java面向对象的特性——封装和继承 接下来我们继续来讲多态的相关知识。

一、多态的概念

在Java中，多态是一种思想 就是简单来说 一个父类实现一种方法 他的子类就可以对该方法进行重写 ，实现不同对象对同一方法进行不同的实现

二、多态实现的条件

在Java中要实现多态 ，必须满足下面这三个条件，缺一不可。
1.必须在继承的体系下
2.子类必须要对父类中方法进行重写
3.通过父类的引用调用重写的方法
多态的实现：在代码运行时 ，调用不同类对象时，会调用相对应的方法。

代码实现如下：

class Animal{
    String name;
    int age;

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

    public void eat(){
        System.out.println(this.name+"正在吃！");
    }
}

class Cat extends Animal{

    public Cat(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(this.name+"正在吃鱼！");
    }

}

class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

    public void est(){
        System.out.println(this.name+"正在吃骨头！");
    }
}




public class Text {
    public static void eat(Animal animal){
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("旺财",2);
        Cat cat = new Cat("布偶",2);
        eat(cat);
        eat(dog);
    }
}

运行结果：

三、重写

1.什么是重写

重写（override）：也称为覆盖 重写是子类对父类非静态、不是被private修饰、非final修饰和非构造方法等的实现过程进行重新编写 ，返回值和形参都不能改变，里面实现内容改变。

【方法重写的规则】
1、子类在重写父类的方法时，一般必须与父类的原型相同：返回类型 、方法名和参数要完全一致。
2、被重写的方法返回值类型可以不同，但必须是具有父子关系的
3、访问权限不能让父类中被重写的方法的访问权限更低
4、父类被static、private修饰的方法、构造方法不能被重写。
5、重写的方法可以用**@Override**注释 这个注释可以帮我们进行合法检验

说到重写 你们一定想到了重载 那重载和重写有什么区别呢 ？一张图让你们了解

【重写和重载的区别】

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

静态绑定：也称为前期绑定，即在编译时，根据用户所传递实参类型就确定了具体调用哪个方法。函数重载

动态绑定：也称为后期绑定，即在编译时，还不能确定方法的行为，需要等到程序运行时，才能确定具体调用哪个类的方法。

四、向上转型和向下转型

1.向上转型

定义：就是创建一个子类对象，讲其当成父类对象来使用
语法格式：父类类型 对象名 = new 子类类型（）

Animal animal = new Cat("小咪",1);

animal是父类类型，但可以引用一个子类对象，这就是向上转型
可以应用到直接赋值，方法传参，方法返回

方法返回

 public static Animal buyAnimal(String var){
        if ("狗".equals(var)){
            return new Dog("狗狗",1);
        }else if ("猫".equals(var)){
            return new Cat("猫猫",1);
        }else {
            return null;
        }
    }

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

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

多态的优点：
可以避免写很多的if-else语句 ，代码可读性更高
可拓展能力更强

多态的具体实现：

class Shape{
    public void draw(){
        System.out.println("画图形！");
    }
}
class Cycle extends Shape{
    public void draw(){
        System.out.println("○");
    }
}
class Rect extends Shape{
    public void draw(){
        System.out.println("矩形");

    }

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

class Flower extends Shape{
    public void draw(){
        System.out.println("❀");
    }
}



public class Text1 {
    public static void main(String[] args) {
        Shape rect = new Rect();
        Shape flower = new Flower();
        Shape cycle = new Cycle();
        Shape triangle = new Triangle();

        Shape[] shapes = {cycle,rect,flower,triangle,flower,cycle,rect};
        for (Shape shape:shapes) {
            shape.draw();
        }
    }
}

运行结果为：

到这里多态就结束了 多态是一种很好的思想 可以通过重写父类的方法让子类对父类的方法有了不同的行为 增加了代码的灵活性 和可拓展性。