多态

一个对象拥有多个形态，即对象的多态性。

多态性，就是：父类引用指向子类对象。

/**
 * @program: intellij idea
 * @description:
 * 代码当中体现多态性，就是：父类引用指向子类对象。
 * 格式：
 * 父类名称 对象名 = new 子类名称（）；
 * 或者
 * 接口名称 对象名 = new 实现类名称();
 * @author: lixy
 * @create: 2020-04-29 16:59
 **/
public class Demo01Multi {
    public static void main(String[] args) {
        //左侧父类的引用，指向了右侧子类的对象
        Fu fu = new Zi();
        fu.method();
        fu.methodFu();
    }
}

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

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

1、成员变量的使用

/**
 * @program: intellij idea
 * @description:
 * 访问成员变量的两种方式:
 * 1、直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有就向上找。
 * 2、间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有就向上找。
 *
 * 注意：只有方法才可以覆盖重写。
 * @author: lixy
 * @create: 2020-04-29 17:33
 **/
public class Demo02 {
    public static void main(String[] args) {
        //多态写法，父类引用指向子类的对象
        Fu obj = new Zi();
        System.out.println(obj.num);

        //子类没有覆盖重写，就是父：10
        //子类有覆盖重写，就是字:20
        obj.show();
    }
}

public class Fu {
    int num = 10;
    public void show(){
        System.out.println(num);
    }
}

public class Zi extends Fu {
    int num = 20;

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

2、成员方法的使用

/**
 * @program: intellij idea
 * @description:在多态的代码当中，成员方法的访问规则是：
 * 看new的是谁，就优先用谁，没有就向上找。
 * 口诀:
 * 成员方法：编译看左边，运行看右边。
 * 成员变量：编译肯右边，运行看左边。
 * @author: lixy
 * @create: 2020-04-29 18:49
 **/
public class Demo03Main {
    public static void main(String[] args) {
        //多态，父类引用指向子类对象
        Fu obj = new Zi();

        obj.method();//父子类都有，优先用子。
        obj.methodFu();//子类没有父类有，向上找到父类

        obj.methodZi();//错误写法
    }
}

public class Fu {
    int num = 10;
    public void show(){
        System.out.println(num);
    }
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

public class Zi extends Fu {

    int num = 20;

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

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

3、上、下转型及instanceof

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

public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void sleep(){
        System.out.println("猫睡觉觉");//猫咪特有的方法
    }
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void lookHome(){
        System.out.println("狗狗看家");//狗狗独有的方法
    }
}

public class Demo04Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat();//本来是一只猫
        animal.eat();

        if (animal instanceof Cat){
            Cat cat = (Cat) animal;//向下转型
            cat.sleep();
        }

        getAnimal(new Dog());
    }
    public static void getAnimal(Animal animal){
        if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.lookHome();
        }else if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.sleep();
        }
    }
}