目录

1.多态
2.重写
3.向上转型和向下转型
4.多态优缺点

引言

已完成Java封装和继承篇。
这是面向对象最后一篇----多态篇。

1.多态

1.1多态的概念

多态就是当不同的对象做同一件事时（同一个行为），会产生不同的状态。

1.2多态的实现条件

必须满足以下几个条件：
1.必须在继承体系下
2.子类必须要对父类中的方法进行重写
3.通过父类的引用调用重写的方法

代码如下：

class Person {
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(this.name + "正在吃饭。。。");
    }

}
class Techer extends Person{

    public Techer(String name, int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(this.name + "正在吃西餐。。。");
    }
}
class Student extends Person{
    public Student(String name,int age) {
        super(name, age);
    }
    public void eat(){
        System.out.println(this.name + "正在吃中餐。。。");
    }
}
public class Test {

    public static void func(Person person){
        person.eat();
    }
    public static void main(String[] args) {
        Techer techer = new Techer("张三",36);
        Student student = new Student("小明",12);

        //通过父类的引用调用重写的方法
        func(techer);
        func(student);
    }
}

执行结果：

1.3多态的体现

1.4动态绑定

2.重写

前提条件：
在继承体系下子类对父类非静态，非private修饰，非final修饰，非构造方法等的方法进行重新编写。

2.1重写的规则

子类和父类的方法名，返回值和参数（个数、类型和顺序）都要完全一样。

注意事项：
1.不能是静态方法（类方法）
2.子类重写父类的方法，访问权限要大于等于父类的方法
3.不能是private修饰的方法（私有方法）
4.不能是final修饰的方法（密封方法）
5.返回值的类型可以不一样，但是必须具有父子关系。

2.2重写与重载的区别

3.向上转型和向下转型

3.1向上转型

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

public class Test {

    public static Person test2(String var){
        if("学生".equals(var)){
            System.out.println(1111111);
            return new Student("xiaoming",16);
        }else if("老师".equals(var)){
            System.out.println(2222222);
            return new Techer("zhangsan",36);
        }else {
            return null;
        }
    }
    public static void test1(Person person){
        person.eat();
    }
    public static void main(String[] args) {
        //1.直接赋值
        Person person = new Student("xiaoming",16);
        //2.方法传参
        test1(new Techer("zhangsan",36));
        //3.方法返回
        test2("学生");
    }
}

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

3.1向下转型

public class Test {
 public static void main(String[] args) {
        Techer techer = new Techer("张三",36);
        Student student = new Student("小明",12);

        // 向上转型
        Person person = techer;
        person = student;
        
        //向下转型
        // 程序可以通过编程，但运行时抛出异常---因为：person实际指向的是student
        // 现在要强制还原为Techer，无法正常还原，运行时抛出：ClassCastException
        techer = (Techer) person;
        //向上转型成功
        student = (Student) person;
    }
}

注意事项：
向下转型不安全，转换失败，运行时就会抛出异常，如果要避免转换失败，可以用instanceof关键字。如果该表达式为true，则可以安全转换。

public class Test {
    public static void main(String[] args) {
        Techer techer = new Techer("张三",36);
        Student student = new Student("小明",12);

        // 向上转型
        Person person = techer;
        person = student;

        //person 这个引用 是否引用了 Techer这个对象
        if(person instanceof Techer){
            techer = (Techer) person;
        }
        //person 这个引用 是否引用了 Student这个对象
        if(person instanceof Student){
            student = (Student) person;
        }
    }
}

4.多态优缺点

【优点】
1.能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
2.可扩展能力更强

【缺点】代码的运行效率降低
1.属性没有多态性当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
2.构造方法没有多态性