自学Java第10Day

学习目标：面向对象进阶

---

学习内容：多态

---

学习时间：

        下午 3 点-下午 6 点

---

学习产出： 

面向对象三大特征：封装、继承、多态

多态

什么是多态

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

多态的表现形式

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

多态的前提

        有继承关系。

        有父类引用指向子类对象。

        有方法重写。

多态的好处

        使用父类型作为参数，可以接收所有子类对象。

        体现多态的扩展性与便利。

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 Student extends Person{
    @Override
    public void show() {
        System.out.println("学生的信息为："+getName()+", "+getAge());
    }
}

public class Student 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) {
        Student s=new Student();
        s.setName("旭哥");
        s.setAge(23);
        register(s);

        Teacher t=new Teacher();
        t.setName("蛋姐");
        t.setAge(21);
        register(t);

        Administrator a=new Administrator();
        a.setName("王五");
        a.setAge(99);
        register(a);
    }
    public static void register(Person p){
        p.show();
    }
}

运行结果： 

学生的信息为：旭哥, 23
老师的信息为：蛋姐, 21
管理员的信息为：王五, 99

多态调用成员的特点

         变量调用:编译看左边,运行也看左边。

         方法调用:编译看左边,运行看右边。

package a09demo2;

public class Test {
    public static void main(String[] args) {
        //创建对象(多态方式)
        //Fu f = new Zi();
        Animal a = new Dog();
        //调用成员变量:编译看左边,运行也看左边
        //编译看左边:javac编译代码的时候,会看左边的父类中有没有这个变量,如果有,编译成功,如果没有编译失败。
        System.out.println(a.name);//动物

        //调用成员方法:编译看左边,运行看右边
        //编译看左边:javac编译代码的时候,会看左边的父类中有没有这个方法,如果有,编译成功,如果没有编译失败。
        //运行看右边:java运行代码的时候,实际上运行的是子类中的方法。
        a.show();///Dog --- show方法

        //理解:
        //Animal a = new Dog();
        //现在用a去调用变量和方法的呀?是的
        //而a是Animal类型的,所以默认都会从Anima1这个类中去找

        //成员变量:在子类的对象中,会把父类的成员变量也继承下的。父:name 子:name
        //成员方法:如果子类对方法进行了重写,那么在虚方法表中是会把父类的方法进行覆盖的。


    }
}

class Animal{
    String name="动物";
    public void show(){
        System.out.println("Animal ------ show方法");
    }
}
class Dog extends Animal{
    String name="狗";
    @Override
    public void show() {
        System.out.println("Dog ------ show方法");
    }
}
class Cat extends Animal{
    String name="猫";
    @Override
    public void show() {
        System.out.println("Cat ------ show方法");

    }
}

运行结果： 

动物
Dog ------ show方法

多态的优势

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

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

        定义方法的时候,使用父类型作为参数,可以接收所有子类对象,体现多态的扩展性与便利。

多态的弊端是什么?

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

引用数据类型的类型转换,有几种方式?

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

Person p = new Student (); //自动类型转换
Student s = (Student)p;    //强制类型转换

强制类型转换能解决什么问题?

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

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

        转换的时候用instanceof关键字进行判断。

package a09demo2;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Animal a=new Dog();
        //编译看左边，运行看右边
        a.eat();
        //多态的弊端
        //不能调用子类的特有功能
        //报错的原因?
        //当调用成员方法的时候,编译看左边,运行看右边
        //那么在编译的时候会先检查左边的父类中有没有这个方法,如果没有直接报错。
        //a.lookHome();

        /*if(a instanceof Dog){
            Dog d = (Dog) a;
            d. lookHome();
        }else if(a instanceof Cat) {
            Cat c = (Cat) a;
            c.catchMouse();
        }else{
            System.out.println("没有这个类型,无法转换”);
        }*/

        //新特性
        //先判断a是否为Dog类型,如果是,则强转成Dog类型,转换之后变量名为d
        //如果不是,则不强转,结果直接是false
        if(a instanceof Dog d){
            d. lookHome();
        }else if(a instanceof Cat c){
            c.catchMouse();
        }else{
            System.out.println("没有这个类型,无法转换");

        }
    }
}

class Animal{
    public void eat(){
        System.out.println("动物在吃东西");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗在啃骨头");
    }
    public void lookHome(){
        System.out.println("狗看家");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫在吃小鱼干");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

狗在啃骨头
狗看家