Java基础——01

今日学习 2020-2-27

Java多态

多态性格式

/*
代码中体现多态性 其实就是一句话：父类指向子类对象
格式：
父类名称 对象名= new 子类名称（）；
或者
接口名称 对象名 = new 实现类名称();

 */
public class Demo01Polymorphism {
    public static void main(String[] args) {
        //多态写法
        //左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();
        obj.method();
        obj.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.直接通过对象名称访问成员变量；看等号左边是谁，优先用谁，没有则向上找
2.间接通过成员方法访问:该方法属于谁优先用谁 没有则向上找
 */
public class Demo01MutiField {
    public static void main(String[] args) {
        //多态的写法
        Fu obj = new Zi();
        System.out.println(obj.num);
//        System.out.println(obj.age);//错误写法
        System.out.println("============");
        //子类没有覆盖重写，就是父：10
        //子类如果覆盖重写，就是字：20
        obj.showNum();

    }
}
//父类
public class Fu {
    int num = 10;

    public void showNum(){
        System.out.println(num);
    }
}
//子类
public class Zi extends Fu {
    int num = 20;
    int age = 16;

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

成员方法

/*
多态中的代码中，成员方法的访问规则是：
 看new的是谁，就优先用谁，没有则向上找


 口诀：编译看左，运行看右边
 成员变量：编译看左，运行还看左

 */
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();//多态

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

//        obj.methodZi();//编译出错，左边是父类，当中没有methodZi方法所以编译报错


    }
}

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("父类特有方法");
    }
}

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("子类特有方法");
    }
}

对象的向上转型

public class Demo01Main {
    public static void main(String[] args) {
        //对象的向上转型，就是父类引用指向子类对象
        Animal animal = new Cat();
        animal.eat();
    }
}

public abstract class Animal {
    public abstract void eat();//抽象方法

    }
    
    public class Cat extends Animal {

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

向下转型

/*
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

解决方法：
用对象的向下转型【还原】
格式:
子类名称 对象名 = (子类名称) 父类对象；
含义：将父类对象，还原 成为本来的子类对象

 */
public class Demo01Main {
    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 类转换异常
    }
}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    //子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃SHIt");
    }
    public void WacthHouse(){
        System.out.println("看家");
    }
}

instanceof关键字

/*
r如何才能知道一个父类引用的对象，本来是上面子类
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例

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

笔记本USB接口案例

public interface USB {
    public abstract void open();//打开设备

    public abstract  void close();//关闭设备
}

//鼠标就是一个USB设备
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("鼠标点击");
    }
}

//键盘就是一个USB设备
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 Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    //使用USB设备的方法，使用接口作为方法发参数
    public void useDevice(USB usb){
        usb.open();//打开设备

        if (usb instanceof Mouse){//先判断
            Mouse mouse = (Mouse) usb;//向下转型
            mouse.click();
        }else if(usb instanceof  Keyboard){//先判断
            Keyboard keyboard = (Keyboard) usb;//向下转型
            keyboard.type();
        }

        usb.close();//关闭设备
    }
}

public class DemoMain {
    public static void main(String[] args) {
        //创建一个笔记本
        Computer computer = new Computer();

        computer.powerOn();

        //首先进行向上转型
        USB usbMouse = new Mouse();//多态写法
        //参数是USB类型，我正好传递进去的就是USB鼠标
        computer.useDevice(usbMouse);

        //创建一个USB键盘
        Keyboard keyboard = new Keyboard();//没有使用多态写法
        //方法参数是USB类型，传递进去的是实现类对象  类似 基本数据类型转换
        computer.useDevice(keyboard);//正确写法
        //computer.useDevice(new Keyboard());//正确写法


        computer.powerOff();
    }
}

发红包案例