JAVA之旅（八）——多态的体现，前提，好处，应用，转型，instanceof，多态中成员变量的特点，多态的案例

---

一.多态

• 定义

• 比如

• 1. 多态的体现
• 1. 多态的前提
• 3.多态的好处
• 4.多态的应用

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        Cat c = new Cat();
        c.eat();
        dog d = new dog();
        d.eat();
    }
}

/**
 * 动物
 *
 * @author LGL
 *
 */
abstract class Animal {

    // 吃什么不确定，抽象
    abstract void eat();
}

/**
 * 猫
 *
 * @author LGL
 *
 */
class Cat extends Animal {

    @Override
    void eat() {
        System.out.println("猫吃鱼");
    }

}

/**
 * 狗类
 *
 * @author LGL
 *
 */
class dog extends Animal {

    @Override
    void eat() {
        System.out.println("狗吃骨头");
    }

}

Animal a = new Cat();
a.eat();

• 父类的引用指向了自己的子类对象，这就是多态的代码体现形式，人 = new 男人，换句话说，父类的引用也可以接收子类的对象，所以我们可以这样定义一个方法

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */
        AnimalEat(new Cat());
        AnimalEat(new dog());
    }

    public static void AnimalEat(Animal a) {
        a.eat();
    }
}

• 多态的出现大大的提升了程序的扩展性

• 必须类与类之间有关系，要么继承，要么实现
• 通常，还有一个前提就是存在覆盖

• 提高了扩展性，但是只能使用父类的引用访问父类的成员，这是局限性，但是我们侧重扩展性

//类型提升
Animal a = new Cat();
a.eat();

• 强制将父类的引用转为子类类型

        Animal a = new Cat();
        a.eat();

        Cat c = (Cat)a;
        c.sleep();

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        Cat c = (Cat) a;
        c.sleep();
    }
}

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        /**
         * 动物： 猫，狗
         */

        AnimalEat(new Cat());
        AnimalEat(new dog());

    }

    public static void AnimalEat(Animal a) {
        a.eat();

        //如果a的类型是Cat就执行
        if(a instanceof Cat){
            Cat c = (Cat) a;
            c.sleep();
        }

    }
}

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：幼儿园有两个班 大班： 学习，睡觉 小班： 学习，睡觉 可以将两类事物进行抽取
         */
        SmallClass s = new SmallClass();
        s.study();
        s.sleep();

        BigClass b = new BigClass();
        b.study();
    }

}

/**
 * 学生类
 *
 * @author LGL
 *
 */
abstract class Student {
    // 学习的内容不一样，抽象
    public abstract void study();

    // 睡觉
    public void sleep() {
        System.out.println("躺着睡");
    }
}

/**
 * 大班
 *
 * @author LGL
 *
 */
class BigClass extends Student {

    @Override
    public void study() {
        System.out.println("学习大班知识");
    }

}

/**
 * 小班
 *
 * @author LGL
 *
 */
class SmallClass extends Student {

    @Override
    public void study() {
        System.out.println("学习小班知识");
    }

    @Override
    public void sleep() {
        System.out.println("卧着睡");
    }

}

/**
 * 封装工具类
 *
 * @author LGL
 *
 */
class DoStudent {
    public void dosome(Student s) {
        s.study();
        s.sleep();
    }
}

        DoStudent dos = new DoStudent();
        dos.dosome(new BigClass());
        dos.dosome(new SmallClass());

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        zi z = new zi();
        z.method1();
        z.method2();
        z.method3();
    }
}

class Fu {
    void method1() {
        System.out.println("fu method1");
    }

    void method2() {
        System.out.println("fu method2");
    }
}

class zi extends Fu {
    void method1() {
        System.out.println("zi method1");
    }

    void method3() {
        System.out.println("zi method3");
    }

}

• 在编译时期。参阅引用型变量所属的类是否有调用的方法，如果由，编译通过。如果没有编译失败
• 在运行时期，参阅对象所属的类中是否有调用的方法
• 简单总结就是成员函数在多态调用时，编译看左边，运行看右边

        Fu f = new zi();
        System.out.println(f.num);

        zi z = new zi();
        System.out.println(z.num);

• 在多态中，成员变量的特点:无论编译和运行，都参考左边（引用型变量所属）
• 在多态中，静态成员变量的特点：无论编译和运行，都参考左边

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard b = new MainBoard();
        b.run();
    }
}

/**
 * 主板
 *
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

}

/**
 * 网卡
 *
 * @author LGL
 *
 */
class NetCard {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}

import javax.print.attribute.standard.MediaName;

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备，有设备的话之类传进去
        m.userPCI(null);

    }
}

/**
 * 扩展接口
 *
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 *
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {

        /**
         * 需求：电脑运行实例，电脑运行基于主板
         */
        MainBoard m = new MainBoard();
        m.run();
        // 没有设备
        m.userPCI(null);

        // 有设备
        m.userPCI(new NetCard());

    }
}

/**
 * 扩展接口
 *
 * @author LGL
 *
 */
interface PCI {
    public void open();

    public void close();
}

/**
 * 主板
 *
 * @author LGL
 *
 */
class MainBoard {

    public void run() {
        System.out.println("主板运行了");
    }

    public void userPCI(PCI p) {
        if (p != null) {
            p.open();
            p.close();
        } else {
            System.out.println("没有设备");
        }

    }

}

/**
 * 网卡
 *
 * @author LGL
 *
 */
class NetCard implements PCI {
    public void open() {
        System.out.println("打开网络");
    }

    public void close() {
        System.out.println("关闭网络");
    }
}