2023年5月21日，抽象类及抽象方法，匿名，对象的转型/引用数据类型的转型，接口的多态，类的多态，接口类

//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}

package com.fy.test03;

public class test01 {
    /**
     * 知识点：类和多态
     * 需求：采用多态的思想实现自行车和汽车的案例，并在测试类进行测试
     * 分析：
     *      1. 定义交通工具类（Vehicle）
     *              成员变量： XXXXXX
     *              构造方法：无参，带参
     *              成员方法：get/set open(),close()
     *      2. 定义汽车类（Car）继承交通工具类（Vehicle）
     *              构造方法：无参，带参
     *              成员方法:重写open(),close()
     *      3. 定义自行车类（Bike）继承交通工具类（）
     *              构造方法：无参，带参
     *              成员方法:重写open(),close()
     *      4. 定义测试类（test01），进行测试
     * @param args
     */
    public static void main(String[] args) {
        Vehicle car=new Car();
        car.open();
        car.close();
        System.out.println("-------------------");
        Vehicle bike= new Bike();
        bike.open();
        bike.close();
    }
}

package com.fy.test03;

public abstract class Vehicle {
    public abstract void open();
    public abstract void close();

}

package com.fy.test03;

public class Car extends Vehicle{

    @Override
    public void open() {
        System.out.println("小汽车：一键启动，踩下油门");
    }

    @Override
    public void close() {
        System.out.println("小汽车：踩下刹车，熄火");
    }
}

package com.fy.test03;

public class Bike extends Vehicle{
    @Override
    public void open() {
        System.out.println("自行车：踩脚踏");
    }

    @Override
    public void close() {
        System.out.println("自行车：刹车");
    }
}

package com.fy.test04;

public class test01 {
    /**
     * 需求：模拟电脑的外部设备
     * @param args
     */
    public static void main(String[] args) {
        Computer computer =new Computer();
        //接口的引用中存储的是实现类对象在堆中的地址
        IUSB usb= new Key();
        //传入实现类对象的地址
        computer.connection(usb);
    }
}

package com.fy.test04;

public class Computer {
    public void connection(IUSB usb){
        usb.use();
    }
}

package com.fy.test04;

public interface IUSB {
    public void use();
}

package com.fy.test04;

public class Key implements IUSB{

    @Override
    public void use() {
        System.out.println("键盘：输入数据");
    }
}

package com.fy.test04;

public class Mouse implements IUSB{
    @Override
    public void use() {
        System.out.println("鼠标：左点点、右点点");
    }
}

package com.fy.test04;

public class SSD implements IUSB{
    @Override
    public void use() {
        System.out.println("硬盘：文件上传、下载");
    }
}

package com.fy.test05;

public class test01 {
    /**
     * 知识点：对象的转型/引用数据类型的转型
     *
     * 分类：
     * 	向上转型/自动转型：子类类型 转 父类类型
     * 	向下转型/强制转型：父类类型 转 子类类型
     *
     * 知识点：对象的转型 -- 向上转型
     * 		可以调用父类非私有化的成员属性
     * 		可以调用父类非私有化的成员方法
     * 		可以调用子类重写父类的成员方法
     * 		不可以调用子类的属性
     * 		不可以调用子类的方法
     *
     * 扩展：向上转型就是多态
     * 		多态的优点：需求升级时，不违反OCP原则，增强代码的可维护性
     * 		多态的缺点：不可以调用子类独有的属性和方法
     *
     */
    public static void main(String[] args) {

        Father father = new Son();

        System.out.println(father.fatherAttr);
        father.fatherMethod();
        father.method();

    }
}

package com.fy.test05;

public class Father {

    String fatherAttr = "父类属性";

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

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

}

package com.fy.test05;

public class Son extends Father{

    String sonAttr = "子类属性";

    static String xxx = "xxx";

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

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