自学Java Day13

学习目标：

• 多态

---

学习内容：

1、多态的概念

同一个对象在不同时刻表现不同形态

举例：猫

猫 cat = new 猫();

动物 animal = new 猫();

多态的前提和体现

有继承/实现关系

有方法重写

有父类引用向子类对象

public class TestPolymorphic {
    /*
        多态的前提：

            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3.要有父类引用，指向子类对象
     */
    public static void main(String[] args) {
        //当前事物，是一只猫
        Cat c = new Cat();
        //当前事物是一只动物
        Animal a = new Cat();
        a.eat();
    }
}

class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

 2、 多态中成员访问特点

构造方法：同继承一样，子类会通过super访问父类构造方法

成员变量：编译看左边（父亲），执行看左边（父亲） 10

成员方法：编译看左边（父亲），执行看右边（父亲）  zi

public class Test2Polymorpic {
    /*
        多态的成员访问特点
         成员变量、成员方法

     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

class Fu{
    int num = 10;

    public void method(){
        System.out.println("Fu...method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method() {
        System.out.println("Zi...method");

    }
}

3、 多态的好处和弊端

多态的好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类型作为参数，该方法就可以接受这父类的任意子类对象

多态的弊端：不能使用子类的特有功能

public class Test3Polymorphic {
    public static void main(String[] args) {
       useAnimal(new Dag());
       useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){ //Animal a = new Dag();
                                            //Animal a = new Cat();
        a.eat();
    }
}

abstract class Animal {
    public abstract void eat();
}

class Dag extends Animal {
    public void eat(){
        System.out.println("狗吃肉");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

4、多态中的转型

向上转型：

       从子到父

       父类引用指向子类对象

 向下转型：

       从父到子

       父类引用转化为子类对象

public class Test4Polymorphic {
    public static void main(String[] args) {
        //1.向上转型：父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        //多态的弊端：不能调用子类特有的成员
        //f.method();

        //A:直接创建子类对象
        //B:向下转型

        Zi z = (Zi)f;
        z.method();
    }
}

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

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi...show...");
    }

    public void method(){
        System.out.println("我是子类特有方法，methor");
    }
}

5、多态中类型转换的风险

概述：如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候会出现ClassCastException

避免强转出现的问题

关键字：instanceof

使用格式：

       变量名instancaof 类型

       

public class Test3Polymorphic {
    public static void main(String[] args) {
       useAnimal(new Dog());
       useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){ //Animal a = new Dag();
                                            //Animal a = new Cat();
        a.eat();

        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome(); //ClassCastException 类型转换异常
        }
    }
}

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

6、多态在信息管理系统中的应用

public class StudentDaoFactory {
    public static BasicStudentDao getStudentDao(){
        return new OtherStudentDao();
    }
}

//通过学生库管工厂类，获取库管对象
private BasicStudentDao studentDao = StudentDaoFactory.getStudentDao();

---