【Java基础】多态在继承关系上的使用

一、多态

①多态是Java面向对象的三大特性之一：封装，继承，多态。
②多态是同一个行为具有不同表现形式或形态的能力。
③表现形式：父类名 父类对象 = new 子类名（）。
⑤使用的前提条件：有继承关系或实现关系（这里只讨论继承关系）。

二、多态的使用

（应用场景：例如在学校的教务管理系统中要写一个方法同时能满足学生和老师的注册）
1.创建一个标准的javabean的父类

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

2.创建两个子类对象（子类对象中要有对父类方法的重写）

public class Student extends Person{
    @Override
    public void show() {
        System.out.println("学生姓名"+getName()+"，学生年龄"+getAge());
    }
}

public class Teacher extends Person{
    @Override
    public void show() {
        System.out.println("老师姓名"+getName()+"，老师年龄"+getAge());
    }
}

3.创建测试类

public class Test {
    public static void main(String[] args) {

        Person p = new Teacher();
        p.setName("abc");
        p.setAge(20);

        Person q = new Student();
        q.setName("123");
        q.setAge(18);

        getResult1(p);
        getResult1(q);
    }

    public static void getResult1(Person p){
        p.show();
    }
}

4.测试结果

老师姓名abc，老师年龄20
学生姓名123，学生年龄18

三、调用成员变量和成员方法的特点

（一）、成员变量：编译看左边，运行看左边

父类

public class Person {
    String name="person";
}

子类

public class Student extends Person{
    String name="Student";
}

测试类

public class Test {
    public static void main(String[] args) {
        Person p = new Student();
        System.out.println(p.name);
    }
}

结果

person

javac编译的时候看等号左边，如果左边的对象中没有name变量，会直接报错，运行的时候也是看左边对象中的变量。

（二）、成员方法：编译看左边，运行看右边

public class Test {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();

        Person q = new Teacher();
        q.show();
    }
}
//创建父类
class Person {
    public void show(){
        System.out.println("Person");
    }
}
//创建子类
class Student extends Person{
    @Override
    public void show() {
        System.out.println("Student");
    }
}
//创建子类
class Teacher extends Person{
    @Override
    public void show() {
        System.out.println("Teacher");
    }
}

运行结果

Student
Teacher

结果说明调用的不是父类中的方法，而是子类中的方法
当父类中没有show方法时明显会报错（把子类中的方法上的@Override删掉也会报错），而且编译时也是看的等号左边是否存在这个方法，运行的时候看右边，调用右边对象中的方法。

四、多态的优势和弊端以及弊端的解决办法

（一）优势

在方法中，当父类对象作为参数时可以接收所有的子类对象

（二）弊端

不能调用子类中特有的方法，只能调用从父类中继承并且重写的方法。
调用成员方法时编译看左边，运行看右边，当使用左边的父类中不存在的方法时会报错。

（三）解决办法

当需要使用子类中特有的方法时需要对创建的父类对象进行强制转换，如：Person p = new Student();要进行Student s = (Student) p;
在复杂的项目中，一般在转换的时候需要利用instanceof进行判断，判断此对象是否是另一个对象的子类。

if(p instanceof Person) {
            Student a = (Student) p;
            a.workS();
        }

也可以写成

if(p instanceof Person a){
            a.workS();
        }

public class Test {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();

        Person q = new Teacher();
        q.show();

        if(p instanceof Person) {
            Student a = (Student) p;
            a.workS();
        }

    }
}
class Person {
    public void show(){
        System.out.println("Person");
    }
}

class Student extends Person{
    @Override
    public void show() {
        System.out.println("Student");
    }
    public void workS(){
        System.out.println("上课");
    }
}

class Teacher extends Person{
    @Override
    public void show() {
        System.out.println("Teacher");
    }
    public void workT(){
        System.out.println("教课");
    }

}

Student
Teacher
上课

注意：在进行对象的转换时不能随意转换，如：Student a = (Student) t;
(t为创建的Teacher的对象)