JAVA面向对象三大特征之一多态

一、什么是多态？

同类型的对象，变现出的不同形态。

二、多态的表现形式

父类类型   对象名称   =   子类对象；

三、多态的前提

a、有继承/实现关系

b、有父类引用指引子类对象     例子：Fu f = new zi()；

c、有方法重写

四、多态的好处

使用父类型作为参数，可以接受所有子类对象，体现多态的扩展性与便利。

实例：

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);
    }
}

public class Student1 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());
    }
}

public class Administrator extends Person{
    @Override
    public  void show() {
        System.out.println("管理员的信息为" + getName() + "," + getAge());
    }
}

public class Test {
    public static void main(String[] args) {
        Student1 s = new Student1();
        s.setName("夏磊");
        s.setAge(18);

        Teacher t = new Teacher();
        t.setName("刘云");
        t.setAge(27);

        Administrator a = new Administrator();
        a.setName("管理员");
        a.setAge(30);

        register(s);
        register(t);
        register(a);
    }

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

运行结果：

学生的信息为夏磊,18
教师的信息为刘云,27
管理员的信息为管理员,30

五、多态调用成员的特点

a、变量调用：编译看左边，运行也看左边。

b、方法调用：编译看左边，运行看右边。

实例：

public class Practice11 {
    public static void main(String[] args) {
        //创建对象（多态方法）
        Animal a = new Dog();
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：java编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，若没有，则直接编译失败
        //运行也看左边：java运行代码的时候，实际获取的就是左边父类中的成员变量的值
        System.out.println(a.name); //动物
        //调用成员方法：编译看左边，运行看右边
        //编译看左边：java编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，若没有，则直接编译失败
        //运行看右边：java运行代码的时候，实际获取的就是右边本类中的成员方法的值
        a.show();
    }
}
class Animal {
    String name = "动物";
    public void show() {
        System.out.println("Animal的方法");
    }
}
class Dog extends Animal {
    String name = "狗";
    @Override
    public void show() {
        System.out.println("Dog的方法");
    }
}
class Cat extends Animal {
    String name = "猫";
    @Override
    public void show() {
        System.out.println("Cat的方法");
    }
}

运行结果：

动物
Dog的方法

六、多态的优势与弊端及解决

1.多态的优势

a、在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

Person p =  new Student();
p.work();  //业务逻辑发生改变时，后续代码不用修改

b、定义方法的时候，使用父类型作为参数，可以接受所有子类对象，体现了多态的扩展性和便利。

2.多态的弊端

不能使用子类的独有功能。

实例：

public class Practice11 {
    public static void main(String[] args) {
        //创建对象（多态方法）
        Animal a = new Dog();
        Animal b = new Cat();
        //多态的弊端
        //不能调用子类的特有功能
        //报错原因？
        //当调用成员方法的时候，编译看左边，运行看那右边
        //那么在编译的时候会先检查左边的父类中有没有这个方法，如没有直接报错
        //如：a.lookhome();
        //细节：转换的时候不能瞎转，如果转换成其他类的类型，就会报错
        Dog d = (Dog) a;
        d.lookHome();
        Cat c = (Cat) b;
        c.catMouse();

    }
}
class Animal {
    String name = "动物";
    public void eat() {
        System.out.println("Animal在吃东西");
    }
}
class Dog extends Animal {
    String name = "狗";
    @Override
    public void eat() {
        System.out.println("Dog吃骨头");
    }
    public void lookHome() {
        System.out.println("Dog在看家");
    }

}
class Cat extends Animal {
    String name = "猫";
    @Override
    public void eat() {
        System.out.println("Cat吃鱼");
    }
    public void catMouse() {
        System.out.println("Cat抓老鼠");
    }
}

3.引用数据类型的类型转换，有几种方式？

自动类型转换、强制类型转换

Person p = new Student();

Student s = (Student)p;

4.强制类型转换能解决什么问题？

a、可以转换成真正的子类类型，从而调用子类独有功能。

b、转换类型与真实对象类型不一致会报错