java基础-day09-面向对象3.0

面向对象3.0

1. JavaBeans规范类对象调用

package com.qfede.a_javabeans;

class Person {
    // 成员变量 Field
    private int id;
    private String name;
    private char gender;

    public Person() {
    }

    public Person(int id, String name, char gender) {
        this.id = id;
        this.name = name;
        this.gender = gender;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
    
}

public class Demo1 {
    // Alt + / 自动补齐
    public static void main(String[] args) {
        // Ctrl + 1 快速修复功能，可以给予当前方法生成局部变量
        // Assign statement to new local variable
        Person person = new Person();
        
        person.setId(1);
        person.setName("彭于晏");
        person.setGender('男');
        
        System.out.println("ID:" + person.getId() + " Name:" + person.getName() + " Gender:" + person.getGender());
    }
}

2. 多类合作【重点】

2.1 汽修厂和汽车

第一个问题：
    汽修厂和汽车是否可以各自看做是一个类???
        汽修厂类 汽车类
    
第二个问题:
    汽修厂和汽车之间什么关系???
        汽修厂最重要的目标是修理汽车，汽修厂中必须有一个方法，方法的目的是修车。

汽车类:
    成员变量:
        品牌
        颜色
        轮胎个数
    成员方法:
        飙车 race
        
汽修厂:
    成员变量:
        名字
        地址
        联系方式
    成员方法:
        修理汽车

2.2 汽车类代码实现

package com.qfede.b_car;

/**
 * 汽车类
 *      后期代码中，一个类对应一个文件，要求类名和文件一致，并且有public修饰
 *      public修饰的类名必须和文件名一致
 * 
 * @author Anonymous
 */
public class Car {
    // 成员变量 Field
    private String name;
    private String color;
    private int wheelCount;

    // 构造方法 Constructor
    public Car() {
    }

    public Car(String name, String color, int wheelCount) {
        this.name = name;
        this.color = color;
        this.wheelCount = wheelCount;
    }

    /*
     * 飙车方法
     *      飙车方法有一个限制，轮胎个数必须为4，如果轮胎个数不为4无法飙车
     */
    /**
     * 飙车方法 功能方法
     */
    public void race() {
        // 轮胎个数为4 ，可以飙车
        if (4 == wheelCount) {
            System.out.println("开着" + color + name + "在路上120KM/h飙车");
        } else {
            System.out.println("轮胎出问题了，快去修理厂！！！");
        }
    }
    
    // Setter and getter method
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getWheelCount() {
        return wheelCount;
    }

    public void setWheelCount(int wheelCount) {
        this.wheelCount = wheelCount;
    }
}

2.3 修理厂代码实现

package com.qfede.b_car;

public class Factory {
    // 成员变量 Field
    private String name;
    private String address;
    private String tel;
    
    // 构造方法 Constructor
    public Factory() {
    }

    public Factory(String name, String address, String tel) {
        this.name = name;
        this.address = address;
        this.tel = tel;
    }
    
    /*
     * 修理汽车方法
     * 
     * 方法分析：
     *      权限修饰符:
     *          public
     *      返回值类型:
     *          void
     *      方法名:
     *          fixCar
     *      形式参数列表:
     *          修理厂修车，需要修理的是外来车辆，不是修理厂自有车辆！！！
     *          当前方法需要的参数是一个汽车类对象，也就是Car类对象
     *          (Car car)
     *
     * 方法声明:
     *      public void fixCar(Car car)
     */
    /**
     * 修理厂类 Factory修理汽车方法，需要的参数是一个Car类的对象
     * 
     * @param car Car类对象，是当前方法所需的外来数据
     * @throws Exception 
     */
    public void fixCar(Car car) throws Exception {
        // 检查轮胎情况
        if (car.getWheelCount() < 4) {
            System.out.println("车辆轮胎出现问题，维修中....");
            Thread.sleep(1000);
            
            // 修理汽车轮胎，赋值为4
            car.setWheelCount(4);
            System.out.println("修理完毕，请付款10W");
            Thread.sleep(1000);
            System.out.println("微信收款 10万元");
        } else {
            System.out.println("车辆轮胎无问题，是否需要保养，保养一次32W");
        }
    }
    

    // Setter and getter method
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }   
}

2.4 main方法

package com.qfede.b_car;

public class MainProject {
    public static void main(String[] args) throws Exception {
        // 创建一个Car类对对象
        Car car = new Car("Audi A4L 45 TFSI", "白色", 4);
        
        for (int i = 0; i < 10; i++) {
            /*
             * Ctrl + 1 快速修复，敲回车
             * 当前代码休眠1s
             */
            Thread.sleep(1000);
            
            // 通过Cat类对象调用race方法 飙车！！！
            car.race();
        }
        
        // 轮胎Boom 
        System.out.println("轮胎炸了 ");
        Thread.sleep(1000);
        
        // 轮胎个数 修改为3 爆胎一个
        car.setWheelCount(3);
        Thread.sleep(1000);

        // 爆胎之后继续飙车，结果需要进入修理厂
        car.race();

        // 修理厂准备完毕
        Factory factory = new Factory();
        
        factory.setName("汽修店");
        factory.setAddress("Tokyo JDM");
        factory.setTel("138后面随便");
        
        // 面向对象使用的方法，要什么给什么???
        factory.fixCar(car);
    
        for (int i = 0; i < 10; i++) {
            /*
             * Ctrl + 1 快速修复，敲回车
             * 当前代码休眠1s
             */
            Thread.sleep(1000);
            
            // 通过Cat类对象调用race方法 飙车！！！
            car.race();
        }
    }
}

2.5 笔记本电脑，键盘和屏幕

第一个问题:
    电脑，键盘和屏幕都可以看做是一个类

第二个问题:
    电脑，是包含键盘和屏幕。
    
键盘类:
    成员变量:
        品牌
        按键个数
    成员方法:
        提供成员变量修改和获取方法，Setter and Getter
    
屏幕:
    成员变量:
        品牌
        尺寸
    成员方法:
        提供成员变量修饰和获取方法，Setter and Getter

电脑类【重点】:
    成员变量:
        屏幕类对象
        键盘类对象
    成员方法:
        换屏幕方法
        换键盘方法
        展示屏幕和键盘的属性。

2.6 键盘类代码实现

package com.qfedu.b_computer;

public class KeyBoard {
    // 成员变量 Field
    private String name;
    private int keyCount;
    
    // 构造方法 Constructor Alt + Shift + S
    public KeyBoard() {
    }

    public KeyBoard(String name, int keyCount) {
        this.name = name;
        this.keyCount = keyCount;
    }

    // Setter and getter 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getKeyCount() {
        return keyCount;
    }

    public void setKeyCount(int keyCount) {
        this.keyCount = keyCount;
    }
    
}

2.7 屏幕类对象

package com.qfedu.b_computer;

public class Screen {
    // 成员变量 Field
    private String name;
    private float size;

    // 构造方法 Constructor
    public Screen() {
    }

    public Screen(String name, float size) {
        this.name = name;
        this.size = size;
    }

    // Setter and getter method
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public float getSize() {
        return size;
    }

    public void setSize(float size) {
        this.size = size;
    }

}

2.8 电脑类对象

package com.qfedu.b_computer;

public class Computer {
    /**
     * 键盘类对象，作为电脑类成员变量，Keyboard类是自定义类型
     */
    KeyBoard keyBoard;

    /**
     * 屏幕类对象，作为电脑类成员变量，Screen类是自定义类型
     */
    Screen screen;

    public Computer() {
    }

    /**
     * Computer类带有参数构造方法
     * 
     * @param keyBoard 使用Keyboard类对象作为初始化参数
     * @param screen   使用Screen类对象作为初始化参数
     */
    public Computer(KeyBoard keyBoard, Screen screen) {
        this.keyBoard = keyBoard;
        this.screen = screen;
    }
    
    /**
     * Setter方法，修改屏幕类对象数据，我们可以理解为换屏幕，这里需要的
     * 参数是一个Screen类对象
     *  
     * @param screen Screen类对象，新屏幕对象
     */
    public void setScreen(Screen screen) {
        this.screen = screen;
    }
    
    /**
     * Setter方法，修改键盘类对象数据，这里可以理解为换键盘，需要的参数
     * 是一个新键盘类对象
     * 
     * @param keyBoard Keyboard类对象
     */
    public void setKeyBoard(KeyBoard keyBoard) {
        this.keyBoard = keyBoard;
    }
    
    public Screen getScreen() {
        return screen;
    }
    
    public KeyBoard getKeyBoard() {
        return keyBoard;
    }
    
    /**
     * 展示键盘和屏幕的属性
     */
    public void show() {
        System.out.println("键盘品牌 : " + keyBoard.getName() + " 按键个数 : " + keyBoard.getKeyCount());
        System.out.println("屏幕品牌 : " + screen.getName() + " 屏幕尺寸 : " + screen.getSize());
    }
}

2.9 main方法

package com.qfedu.b_computer;

public class MainProject {
    public static void main(String[] args) {
        // 进货，创建键盘类对象和屏幕类对象
        KeyBoard keyBoard = new KeyBoard("双飞燕", 104);
        Screen screen = new Screen("三星", 27F);
        
        // 使用键盘类对象和屏幕类对象创建一个Computer电脑类对象
        Computer computer = new Computer(keyBoard, screen);
        
        // 展示电脑键盘配置和屏幕配置
        computer.show();
        
        System.out.println("~~~~~换屏幕~~~~~");
        
        // 创建新屏幕类对象
        Screen screen2 = new Screen("ROG", 32F);
        computer.setScreen(screen2);
        
        computer.show();
        
        System.out.println("~~~~~换键盘~~~~~");
        
        // 创建新键盘类对象
        KeyBoard keyBoard2 = new KeyBoard("HHKB", 60);
        computer.setKeyBoard(keyBoard2);

        computer.show();
        
    }
}

2.10 多类合作总结

1. 方法参数或者返回值为自定义类对象类型。
    fixCar(Car car); 
        当前方法所需参数是Car类对象
    Computer(Keyboard keyboard, Screen screen); 
        当前构造方法所需参数是Keyboard类对象和Screen类对象
    【方法需要什么类型，我们给什么数据类型】
    
2. 类和类之间是存在包含关系的！！！
    电脑 {
        键盘类对象;
        屏幕类对象;
    }
    自定义数据类型整合，包含关系是非常常见的！！！

3. 从生活角度理解和分析代码！！！
    代码来自生活，最后反馈于生活！！！

3. 匿名对象

3.1 匿名对象是什么？

    匿名对象就是没有对象名字的对象。
    在创建对象的过程中
        Person p1 = new Person();   
    真正意义上创建对象的语句是 【new Person();】
    p1 对象名，同时也是一个引用数据类型的变量，保存类对象在内存【堆区】空间首地址。
    
匿名对象 
    new 构造方法();
    
匿名对象不推荐直接调用或者赋值成员变量，有去无回！！！

3.2 匿名对象推荐使用方式

两种方式:
    1. 匿名对象直接调用类内的成员方法
    2. 匿名对象作为其他方法的参数【很常用】

package com.qfedu.d_anonymous;

class SingleDog {
    public void test() {
        System.out.println("路见不平一声吼，你还没有女朋友~~~");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        // 匿名对象直接调用类内的成员方法
        new SingleDog().test();
        
        // 匿名对象直接作为方法的参数
        needSingleDog(new SingleDog());
        
        // 创建缓冲输入字节流对象，需要参数是字节流输入对象和文件对象
        // new BufferedInputStream(new FileInputStream(new File("D:/aaa/1.txt")));
    }
    
    public static void needSingleDog(SingleDog singleDog) {
        System.out.println("这是一个单身狗" + singleDog);
    }
}