200806学习笔记（多态）

extends继承或者implements实现，是多态性的前提
代码中体现多态性：父类引用指向子类对象
格式：
父类名称 对象名=new 子类名称();
接口名称 对象名=new 实现类名称();
Father obj=new Son();

访问成员变量的两种方式
1.直接通过对象名称访问成员变量：看等号左边是谁则优先用谁，没有则向上找。
2.间接通过成员方法访问成员变量：看该方法属于谁就优先用谁，没有则向上找
成员方法：
在多态的代码中，成员方法的访问规则是：
看new的是谁就优先用谁，否则往上找

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

成员变量

public class Demo01MultiField {
    public static void main(String[] args) {
        //使用多态的写法，父类引用指向子类对象
        Father obj=new Son();//等号左边是父。方法才能进行覆盖重写，成员变量不能override覆盖重写所以是父类的值
        System.out.println(obj.num);
        //System.out.println(obj.age);//错误写法,son里的age，从father向上找到object都没有

        obj.showNum();//如果此方法只有父类有，子类没有覆盖重写，就是父类的值，子类覆盖重写了就是子类的值
    }
}

成员方法

    public static void main(String[] args) {
        Father obj = new Son();//多态

        obj.method();//父子都有，new的是子，优先用子
        obj.methodFa();//子类没有父类有，向上找到父类

        //编译看左，左边是Father，Father中没有methodSon()所以报错
        //obj.methodSon();//错误写法

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

public class Son extends Father {
    int num=20;
    int age=16;

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

对象的向上转型，其实就是多态写法
格式：父类对象 对象名 = new 子类名称();
Father obj= new Son();
Animal animal = new Cat();小范围的猫向上转换为更大范围的动物
含义：右侧创建一个子类对象，把它当做父类来看待使用
注意：向上转型一定是安全的
类似于double num=100;//正确，int->double

        //对象的向上转型就是：父类引用指向子类对象
        Animal animal=new Cat();
        //左边有，找右边实现
        animal.eat();

对象的向下转型，其实是一个还原的动作
格式：
子类名称 对象名=（子类名称）父类对象；
含义：将父类对象。【还原】成为本来的子类对象
Animal animal=new Cat();//本来是猫，向上转型成为动物
Cat cat=(Cat) animal;//本来是猫，当成动物，还原成为本来的猫
注意事项：
a.必须保证对象本来创建的时候就是猫，才能向下转型成为猫
b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错(ClassCastException类转换错误）
类似于
int num = (int) 10.0;//可以
int num=(int) 10.5;//不可以，精度损失

public static void main(String[] args) {
        //对象的向上转型就是：父类引用指向子类对象
        Animal animal=new Cat();//本来创建的时候是一只猫
        //左边有，找右边实现
        animal.eat();
        //animal.catchMouse();//错误写法

        //向下转型，进行【还原】动作
        Cat cat=(Cat) animal;
        cat.catchMouse();//猫抓老鼠

        //下面是错误的向下转型
        Dog dog=(Dog) animal;//错误写法，编译不会报错，运行会出现异常，java.lang.ClassCastException类转换异常}

如何知道一个父类引用的对象本来是什么子类
格式：
对象 instanceof 类名称
这将得到一个boolean值结果，判断前面的对象能不能当做后面的类型

public class Demo02Instanceof {
    public static void main(String[] args) {
        giveMeAPet(new Dog());
        }
    public static void giveMeAPet(Animal animal){
        //如果希望用子类特有方法，需要向下转型
        //判断一下父类引用animal本来是不是Dog
            if(animal instanceof Dog){
                Dog dog=(Dog) animal;
                dog.watchHouse();}
            if (animal instanceof Cat){
                Cat cat=(Cat) animal;
                cat.catchMouse();
            }
        }
        }

实例：一个笔记本电脑

public static void main(String[] args) {
        //首先创建一个笔记本电脑
        Laptop laptop=new Laptop();
        laptop.powerOn();

        //准备一个鼠标供电脑使用
//        Mouse mouse=new Mouse();
        //首先进行向上转型
        USB mouse=new Mouse();//左接口右实现类
        laptop.useDevice(mouse);//传递进去

        //创建一个USB键盘
        Keyboard keyboard=new Keyboard();//没有使用多台写法
        //方法参数是USB类型，传递进去的是实现类对象
        laptop.useDevice(keyboard);//正确写法，发生了向上转型
        //使用子类对象、匿名对象，也可以
        laptop.useDevice(new Keyboard());//也是正确写法

        laptop.powerOff();
    }

public interface USB {
    public abstract void open();//打开设备
    public abstract void close();//关闭设备
}

public class Laptop {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    //使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb){
        //打开设备
        usb.open();
        if(usb instanceof Keyboard){Keyboard keyboard=(Keyboard) usb;//向下转型
            keyboard.type(); }
        if(usb instanceof Mouse){Mouse mouse=(Mouse) usb;//向下转型
            mouse.click(); }
        //关闭设备
        usb.close();
    }
}

public class Keyboard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }
    public void type(){
        System.out.println("键盘输入");
    }
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("点击");
    }
}