java第十课——多态

目录

一：多态概念

二：向上转型

1.直接赋值

2.方法传参

3. 方法返回

 三：向下转型

四：重写

五：多态

---

一：多态概念

        通俗来说，就是多种形态，具体点就是在完成某个行为时，不同的对象去完成，会产生不同的效果。

例如，同样都是动物类，同样是吃这个行为，🐱和🐕吃的东西是不一样的。

二：向上转型

        为理解多态，我们会先引入两个概念，即向上转型和方法重写。我们先来聊向上转型。向上转型，实际就是创建一个子类对象，将其当成父类对象来使用。说白了，父类引用引用子类对象。

语法格式：父类类型 对象名 = new 子类类型()；（左边是爹，右边是儿子）

        猫和狗都是动物，因此将子类对象转化为父类引用是合理的，大范围可以囊括小范围，是安全的。

上述实例的代码如下：

package TEST;
class Animal3 {
    public String name;
    public int age;

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


class Cat3 extends Animal3 {
    public String hair;

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


public class TestDemo5 {
    public static void main(String[] args) {
        Animal3 animal3 = new Cat3();//向上转型
        animal3.name = "大黑";
        animal3.eat();
    }
}

运行结果如下：

1.直接赋值

        上面的实例，就是直接赋值。先创建对象，然后设置其成员变量或引用其成员方法。

2.方法传参

形参为父类型引用，可以接收任意子类的对象。

3. 方法返回

 三：向下转型

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

         现在，出现了这样一种情况：

        显然，这种情况会报错，因为猫能飞吗？不太合适。这就说明，向下转型是不安全的。因为所有的🐱、🐕、🐤都是动物，但未必所有的动物都是🐤。

        在java中，为了提高向下转型的安全性，引入了instanceof ，如果该表达式为true，则可以安全转换。例如：

        此时再去进行编译，就没有问题了！ 

四：重写

package TEST;

class Animal {
    public String name;
    public int age;

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

    protected  void eat() {
        System.out.println(this.name+" 吃饭！Animal");
    }
}

class Cat extends Animal {
    public String hair;
    public Cat(String name,int age,String hair){
       super(name,age);
        this.hair = hair;
    }


    @Override
    protected void eat() {
        System.out.println(this.name+" 吃猫粮！");
    }

    public void mew() {
        System.out.println(this.name+" 正在叫！");
    }
}
public class TestDemo {
    public static void main(String[] args) {
       Animal animal1 = new Cat("马达",14,"黑白");
        animal1.eat();
    }
}

运行结果如下：

 我们需要重点关注的是这个部分：

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

关于重写：

1. 静态方法不能进行重写；
2. private修饰的方法不能进行重写；
3. 子类的访问修饰限定符要大于等于父类；
4. 被final修饰的方法不能进行重写。

 重写和重载的区别：

动态绑定和静态绑定：

• 静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表为函数重载。例如在编译时，根据函数参数的不同就确定了调用的是哪个方法。
• 动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。典型代表为函数重写。 例如上文中介绍重写的这段代码，在调用eat()这个属性时，编译时仍然调用父类Animal中的eat()方法，直到运行时才最终确定调用Cat中的eat()方法。

五：多态

package TEST;

class Animal {
    public String name;
    public int age;

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

    protected  void eat() {
        System.out.println(this.name+" 吃饭！Animal");
    }
}

class Cat extends Animal {
    public String hair;
    public Cat(String name,int age,String hair){
       super(name,age);
        this.hair = hair;
    }


    @Override
    protected void eat() {
        System.out.println(this.name+" 吃猫粮！");
    }

}

class Dog extends Animal {

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

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

class Bird extends Animal {
    public void eat() {
        System.out.println(this.name+" 吃虫子！");
    }
    public Bird(String name,int age){
        super(name,age);
    }

}

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

    public static void main(String[] args) {
       Cat cat1 = new Cat("喜乐",14,"黑白");
       Dog dog1 = new Dog("摩卡",10);
       Bird bird1 = new Bird("哈里鹿",5);
        function(cat1);
        function(dog1);
        function(bird1);
    }
}

多态是这样一种思想，同一个方法，引用的对象不同，表现出的行为不同 ！

多态需要满足这几个条件：

1. 必须在继承体系下；
2. 子类必须要对父类中方法进行重写；
3. 通过父类的引用调用重写的方法。

多态的优缺点：

【优点】 

  1.降低代码的圈复杂度，避免大量重复的if-else语句。

  2.可扩展能力较强。

【缺点】

  代码的运行效率较低。

---

本课内容完！