1.多态的基本概念

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 8:57
 *面向对象有三大特征：封装、继承、多态
 * 封装、继承是面向于类或者接口；
 * 多态面向的是对象，指的是对象的多态性
 * --------------------------------------------------
 * 代码中的多态性，其实就是一句话，父类引用指向子类对象，就是父类可以引用不同子类的对象，产生不同种 
 * 形态
 * 格式：
 * 父类名称 对象名 = new 之类名称();
 * 或者：
 * 接口名称 对象名 = new 实现类名称();
 */
public class Multi {
    public static void main(String[] args) {
        // 使用多态方法
        // 左侧父类的调用，指向右侧子类的对象
        // 一只猫被当做动物看待是没有问题的
        Animal obj = new Cat();

        obj.method();    // 子类方法，new的是谁就指向谁
        obj.methodFu();  // 父类特有方法，如果子类没有，就会向上找父类
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 8:59
 */
public class Animal {
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:00
 */
public class Cat extends Animal {

    @Override
    public void method(){
        System.out.println("子类方法");
    }
}

2.多态成员变量的使用特点

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 *访问成员变量的两种方式：
 *
 * 1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找，不会向下找。
 * 2.间接通过成员方法访问成员变量: 看该方法属于谁，优先用谁，没有则向上找，不会向下找。
 */
public class Multi {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu fu = new Zi();
        System.out.println(fu.num);
//        System.out.println(fu.age); // 错误写法，向下查找

        // 子类没有覆盖重写父类方法，就是父：10
        // 子类如果覆盖重写父类方法，就是子：20
        fu.showNum();
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 */
public class Fu {
    int num = 10;

    public void showNum(){
        System.out.println(num);
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 */
public class Zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }
}

3.多态成员方法的访问规则

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 *访问成员变量的两种方式：
 *
 * 1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找，不会向下找。
 * 2.间接通过成员方法访问成员变量: 看该方法属于谁，优先用谁，没有则向上找，不会向下找。
 *
 * 在多态的代码当中成员方法的访问规则是：
 *  *  看new的是谁，就优先使用谁，没有则向上找。
 *
 * 口诀：编译看左边，运行看右边。
 */
public class Multi {
    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num);
//        System.out.println(fu.age); // 错误写法，向下查找

        // 子类没有覆盖重写父类方法，就是父：10
        // 子类如果覆盖重写父类方法，就是子：20
        obj.showNum();

        // 编译看左面，没问题；运行的时候method()是运行的子类中的方法
        obj.method();   // 子类是new的，并且有，先用子类
        // 编译看左面，没问题；运行的时候method()是运行的子类中的方法，子类中没有向上找到父类
        obj.methodFu(); // 子类没有向上找

        // 编译看左边，左边是Fu obj()，没有methodZi()，所以编译报如下错误
//        obj.methodZi();  // 错误写法
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 */
public class Fu {
    int num = 10;

    public void showNum(){
        System.out.println(num);
    }

    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

/**
 * @author : sunkepeng E-mail:[email protected]
 * @date : 2020/7/22 9:14
 */
public class Zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }

    @Override
    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

4.使用口诀

成员变量：编译看左边，运行还是看左边

成员方法：编译看左边，运行看右边

5.多态的用处

就上图示例，等号左面的都是Employee对象，不关心等号右面是讲师、助教、保安等，使得代码更加灵活。