一、練習

package com.alice.innerclass_.innerclass03;

/**
 * @author alice_huijing
 * @version 1.0
 */

/**
 * 第一題：
 *  以下代碼的執行結果
 */
public class Homework01 {
//    public static void main(String[] args) {
//        Car c = new Car(); // 創建一個實例化對象，初始化靜態，普通，最后構造器，price = 9, color = red，無參構造方法
//        Car c1 = new Car(100);  // 創建一個實例化對象，靜態信息只加載一次，因為類已經加載過了，執行有參構造price=100,color=red
//        System.out.println(c); //9.0 red
//        System.out.println(c1);//100.0	red
//    }
}

class Car {
    double price = 10;  // 類型為double，結果保留小數
    static String color = "white"; // 靜態屬性，只加載一次，實例化對象共享屬性
    public String toString() {  // 打印對象引用返回這個
        return price + "\t" + color;
    }
    public Car() {
        this.price = 9;
        this.color ="red";
    }
    public Car(double price) {
        this.price = price;
    }
}

/**
 * 第二題：
 *  1.在Frock類中聲明私有的靜態屬性currentNum，為int類型，初始值為100000，作為衣服出廠的序列號起始值。
 *  2.聲明公有的靜態方法getNextNum，作為生成上衣唯一序列號的方法。每次調用，將currentNum增加100，并且作為返回值。
 *  3、在TestFrock類的main方法中，分別兩次調用getNextNum方法，獲取序列號并打印輸出。
 *  4，在Frock類中聲明serialNumber（序列號）屬性，并提供對象的get方法；
 *  5，在Frock類的構造器中，通過調用getNextNum方法為Frock對象獲取唯一的序列號，賦給serialNumber屬性
 *  6、在TestFrock類的main方法中，分別創建三個Frock對象，并打印三個對象的序列號，驗證是否為按100遞增。
 */
class Frock {
    private static int currentNum = 100000;
    private int serialNumber;
    public Frock() {
        serialNumber = getNextNum();
    }
    public static int getNextNum() {
        currentNum += 100;
        return currentNum;
    }

    public int getSerialNumber() {
        return serialNumber;
    }
}
class TestFrock {
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());
        System.out.println(Frock.getNextNum());
        Frock frock = new Frock();
        Frock frock1 = new Frock();
        Frock frock2 = new Frock();
        System.out.println(frock.getSerialNumber());
        System.out.println(frock1.getSerialNumber());
        System.out.println(frock2.getSerialNumber());
    }
}
// 2
package com.alice.innerclass_.innerclass03;

/**
 * @author alice_huijing
 * @version 1.0
 */

/**
 * 第三題：
 * 按要求實現下列問題
 * 1、動物類Animal包含了抽象方法shout();
 * 2、Cat類繼承了Animal，并且實現了方法shout，打印“貓會喵喵叫”
 * 3、Dog類繼承了Animal，并且實現了方法shout，打印“狗會汪汪叫”
 * 4、在測試類中實例化對象Animal cat = new Cat(),并調用cat的shout方法
 * 5、在測試類中實例化對象Animal dog = new Dog(),并調用dog的shout方法
 */
public class Homework02 {
//    public static void main(String[] args) {
//        Animal cat = new Cat();  // 上轉型 編譯類型是Animal，可以點出的方法有shout
//        Animal dog = new Dog();  // 上轉型 編譯類型是Animal，可以點出的方法有shout
//        // 由于動態綁定機制的存在，并且這些類中重寫了父類Animal中的shout方法，所以產生了多態
//        cat.shout(); // 貓會喵喵叫
//        dog.shout(); // 狗會汪汪叫
//    }
}

abstract class Animal {  // 有抽象方法之后，這個類必須是抽象類
    abstract void shout();
}

class Cat extends Animal {  // 繼承了抽象類就需要實現抽象類中所有的抽象方法
    @Override
    void shout() {
        System.out.println("貓會喵喵叫");
    }
}

class Dog extends Animal {
    @Override
    void shout() {
        System.out.println("狗會汪汪叫");
    }
}

/**
 * 第四題
 * 1、計算器接口具有work方法，功能是運算，有一個手機類Cellphone，定義方法testWork測試計算功能
 * 調用計算接口的work方法，
 * 2、要求調用CallPhone對象的testWork方法，使用上匿名內部類
 */
interface Calculator {
    double work(double... nums);
}

class Cellphone {
    public Calculator testWork() {
        return new Calculator() {
            // 匿名內部類在方法中，當前運行類型是Calculator，但是運行類型是Cellphone$1
            // 所以這里能夠點出work，但是運行的是匿名內部類的重寫的work，new Calculator就相當于是實現的什么接口
            // 返回的是編譯類型，但是一旦調用運行則是運行類型
            @Override
            public double work(double... nums) {
                System.out.println(getClass());  // Cellphone$1
                double sum = 0;
                for (int i = 0; i < nums.length; i++) {
                    sum += nums[i];
                }
                return sum;
            }
        };
    }

    public void testWorkA(Calculator calculator, double... nums) {
        double res = calculator.work(nums);  // 當前編譯類型能夠點出work，但是執行的時候還是使用匿名內部類重寫的方法
        System.out.println("老韓的方式的結果 = " + res);
    }
}

class CellphoneX implements Calculator {  // 類實現一個接口，就要重寫這個接口中的所有方法
    @Override
    public double work(double... nums) {
        System.out.println(getClass());  // CellphoneX
        double sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

class Test01 {
    public static void main(String[] args) {
        double sum = new CellphoneX().work(20, 100.45, 88, 99.9, 3.14);
        System.out.println("使用傳統的方式：" + sum);
        double sum1 = new Cellphone().testWork().work(20, 100.45, 88, 99.9, 3.14);  // 編譯類型點出work，一旦運行
        // 執行Cellphone$1重寫的方法
        System.out.println("使用匿名內部類的方式：" + sum1);
        new Cellphone().testWorkA(new Calculator() {  // 直接通過傳入匿名內部類的方式
            @Override
            public double work(double... nums) {
                System.out.println(getClass());  // Test01$1
                double sum = 0;
                for (int i = 0; i < nums.length; i++) {
                    sum += nums[i];
                }
                return sum;
            }
        }, 20, 100.45, 88, 99.9, 3.14);  // 這種方式更加靈活，可以調整計算的方式
    }
}
// 3
package com.alice.innerclass_.innerclass03;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Homework03 {
    public static void main(String[] args) {
        A a = new A();  // 創建A實例化對象調用bb，編譯類型為A所以可以點出bb，運行類型為A，所以調用的是AA的bb方法
        a.bb();
        System.out.println("A  " + a);
    }
}

/*
    內部類：
    1、編寫一個類A，在類定義局部內部類B，在B中有一個私有常量name，有一個方法show()打印常量name，進行測試
    2、進階：A中也定義一個私有的變量name，在show方法中打印測試
 */
class A {
    private String name = "bob";
    public void bb() {
        class B {  // 這個類在方法體中，使用class修飾，這個類是局部內部類，還可以定義在普通代碼塊中
            public B(String name) {  // 常量不能通過set方法進行修改，這里使用構造器進行添加
                this.NAME = name;
            }

            private final String NAME;  // 常量需要final關鍵字修飾，按照規范常量名大寫

            public void show() {
                System.out.println("show() 方法打印局部內部類常量name = " + this.NAME);
                System.out.println("show() 方法中打印外部類的變量name = " + A.this.name);
                // 如果局部內部類和外部類重名可以使用外部類的類名.this.這個成員
                // 這里的this指的是b，然后A.this指的是a
                System.out.println(this);
                System.out.println("A  " + A.this);
            }
        }
        B b = new B("alice");  // 局部內部類在外部其他類中無法創建，所以需要在這個方法中創建，將這個返回出去也可以在外部其他調用
        b.show();
    }
}
// 4
package com.alice.innerclass_.innerclass03;

import com.alice.houserent.domain.House;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Homework04 {
    public static void main(String[] args) {
    /*
        5、實例化Person對象“唐僧”，要求一般情況下使用Horse作為交通工具，遇到大河的時候使用
            Boat作為交通工具。
    */
//        Person person = new Person("唐僧", Factory.getHorse());
//        person.getVehicles().work();
//        System.out.println("遇到大河了，需要使用船作為交通工具。");
//        person.setVehicles(Factory.getBoat());
//        person.getVehicles().work();
        Person tang = new Person("唐僧", new Horse());
        tang.common();
        tang.passRiver();
        tang.common();
        tang.passRiver();
        tang.passRiver();
        tang.passRiver();
        tang.passRiver();
        tang.passFireHill();
        /*
            Person person = new Person("唐僧", Factory.getHorse());
            person.getVehicles().work();
            System.out.println("遇到大河了，需要使用船作為交通工具。");
            person.setVehicles(Factory.getBoat());
            person.getVehicles().work();

            這個地方老韓將
            要求一般情況下使用Horse作為交通工具，遇到大河的時候使用Boat作為交通工具
            這里封裝成方法來進行使用，這里體現了一個封裝的思想。這里我沒有封裝。
         */

    }
}

/*
    1、有一個交通工具接口類Vehicles，有work接口
    2、有Horse類和Boat類分別實現Vehicles
    3、創建交通工具工廠類，有兩個方法分別獲取交通工具Horse和Boat
    4、有Person類，有name和Vehicles屬性，在構造器中為兩個屬性賦值
    5、實例化Person對象“唐僧”，要求一般情況下使用Horse作為交通工具，遇到大河的時候使用
        Boat作為交通工具。
 */
interface Vehicles { // Vehicles是交通工具的意思
    void work();  // 要求實現接口類的類是實現這個方法
}

class Horse implements Vehicles {  // 馬這個交通工具

    @Override
    public void work() {
        System.out.println("白龍馬蹄朝西，后面跟著唐僧的三徒弟。");
    }
}

class Boat implements Vehicles {  // 船這個交通工具

    @Override
    public void work() {
        System.out.println("讓我們蕩起雙槳，小船兒推開波浪。。");
    }
}

//class Factory {
//    public Horse getHorse() {
//        return new Horse();
//    }
//
//    public Boat getBoat() {
//        return new Boat();
//    }
//}  ， 因為這是一個工廠類，相當于是一個工具類，我們一般不會創建這個工具類，這里應該寫成一個靜態的方法。
// 老韓提醒1.
class Factory {
    // 為了保持一匹馬
    private static Horse horse = new Horse();  // 餓漢式
    public static Horse getHorse() {  // 這里還需要注意一點，這里我也沒有考慮，這里不能直接返回一匹新的馬，需要一直是白龍馬
//        return new Horse();
        return horse;
    }

    public static Boat getBoat() {
        return new Boat();
    }

    public static Plane getPlane() {
        return new Plane();
    }
}

class Person {
    private String name;
    private Vehicles vehicles;

    // 在創建人對象的時候，先分配一個交通工具
    // 如何不浪費，在創建對象的時候，傳入的交通工具對象
    // 在我們取馬或者是船的時候去判斷一下是否已經有了這個工具
    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }

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

    public void setVehicles(Vehicles vehicles) {
        this.vehicles = vehicles;
    }

    public String getName() {
        return name;
    }

    public Vehicles getVehicles() {
        return vehicles;
    }

    public void passRiver() {
//        Boat boat = Factory.getBoat();
//        boat.work();
        if(!(vehicles instanceof Boat)) {  // 是空或者是馬
            // 但是如果都是(vehicles == null)判斷為空，如果交通工具是馬也是不空的，如果交通工具是船也是不空的，這樣就都是馬了。
            // 所以需要使用instanceof
            vehicles = Factory.getBoat();
        }
        vehicles.work();
    }

    public void common() {
//        Horse horse = Factory.getHorse();
//        horse.work();
        if(!(vehicles instanceof House)) {  // 是空或者是船
            vehicles = Factory.getHorse();
        }
        vehicles.work();
    }

    public void passFireHill() {
        if(!(vehicles instanceof Plane)) {  // 是空或者是船
            vehicles = Factory.getPlane();
        }
        vehicles.work();
    }
}

// 思考：最后再增加一個情況，如果唐僧過火焰山，需要使用飛機，這里就體現程序的擴展性了，基于前面的結構我們非常好擴展。
// 這里可以直接增加一個飛機類
// 在工廠再返回一個飛機
// 在人中再增加一個過火焰山的情況
class Plane implements Vehicles {
    @Override
    public void work() {
        System.out.println("過火焰山，使用飛機。。。");
    }
}
//5
package com.alice.innerclass_.innerclass03;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Homework05 {
    public static void main(String[] args) {
        new Car01(39.9);
        new Car01(-2);
        Car01 c = new Car01(42);
        c.getAir().flow();
    }
}

/*
    第七題：
        內部類練習
        有一個Car類，有屬性temperature溫度，車內有Air空調類，有吹風的功能flow，
        Air會監視車內的溫度，如果溫度超過40度則吹冷風，如果溫度低于0度則吹暖氣，如果在這之間
        則關閉空調。實例化具有不同溫度的Car對象，調用空調的flow方法，測試空調吹的風是否正確。
 */
class Car01 {
    private double temperature;

    public Car01(double temperature) {
        this.temperature = temperature;
        new Air().flow();
    }

    class Air {
        void flow() {
            if (Car01.this.temperature > 40) {
                System.out.println("正在吹冷風。。。");
            } else if (Car01.this.temperature < 0) {
                System.out.println("正在吹暖風。。。");
            } else {
                System.out.println("空調關閉中。。。");
            }
        }
    }

    // 老韓通過返回Air對象的方式
    public Air getAir() {
        return new Air();
    }
}
// 6
package com.alice.innerclass_.innerclass03;

import java.util.Arrays;

/**
 * @author alice_huijing
 * @version 1.0
 */

/*
    第八題
        枚舉類
        1、創建一個Color枚舉類
        2、有RED，BLUE，BLACK，YELLOW，GREEN這五個枚舉值
        3、Color有三個屬性redValue，greenValue，blueValue，
        RED（紅）: (255, 0, 0)

        BLUE（藍）: (0, 0, 255)

        BLACK（黑）: (0, 0, 0)

        YELLOW（黃）: (255, 255, 0)（紅+綠混合）

        GREEN（綠）: (0, 255, 0)
        4、創建構造方法，參數包括這三個屬性
        5、每個枚舉值都需要給這三個屬性賦值
        6、定義接口，里面有方法show，要求Color實現該接口
        7、show方法中顯示三屬性的值
        8、將枚舉對象在switch語句中匹配使用
 */
public class Homework06 {
    public static void main(String[] args) {
        Color[] values = Color.values();
        System.out.println("顏色數組->" + Arrays.toString(values));
        for (Color value: values) {
            value.useInSwitch();
        }

    }
}

interface ColorInterface {
    void show();
}

enum Color implements ColorInterface {
    RED(255, 0, 0), BLUE(0, 0, 255),
    BLACK(0, 0, 0), YELLOW(255, 255, 0),
    GREEN(0, 255, 0);
    private int redValue;
    private int greenValue;
    private int blueValue;

    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    @Override
    public void show() {
        System.out.println("(" + redValue + ',' + greenValue + ',' + blueValue + ")");
    }

    public void useInSwitch() {
        switch (this.toString()) {
            // 這里我是按照字符串來判斷的，其實還可以支持枚舉類型，這里我忘記了。，也就是this，然后判斷不用加雙引號
            case "RED":
                System.out.println("紅色的RGB是：");
                show();
                break;
            case "BLUE":
                System.out.println("藍色的RGB是：");
                show();
                break;
            case "BLACK":
                System.out.println("黑色的RGB是：");
                show();
                break;
            case "YELLOW":
                System.out.println("黃色的RGB是：");
                show();
                break;
            case "GREEN":
                System.out.println("綠色的RGB是：");
                show();
                break;
        }
    }
}

二、異常（未完）

// 01
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */

/*
    異常對應的英文單詞是Exception
    這個章節主要講解的內容：
    1、異常的概念
    2、異常的體系圖，重要
    3、常見的異常
    4、異常處理概念
    5、異常處理分類
    6、自定義異常
    7、throw和throws的對比
    首先還是通過一段代碼引出異常和異常處理機制

 */
public class Exception01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;
        // 如果程序員覺得一段代碼可能出現異常，或者說問題，可以使用try catch異常處理機制來解決，從而保證程序的
        // 健壯性和容錯性。
        // 為了快捷的使用這個語法，我們只需要將可能出現異常的語句塊使用光標選中
        // 然后Ctrl + Alt + t然后選擇try catch即可
        try {
            int res = num1 / num2;  // 可以看到這里的語法并沒有什么錯誤，但是當我們運行的時候就會拋出異常，這里除以0
        } catch (Exception e) {
            // 如果進行異常處理，那么即使出現了異常，程序也可以繼續執行。
            // e.printStackTrace();  // 這里程序的異常還是拋出了，但是并沒有什么影響，程序還是繼續執行，因為這里是直接拋出，所以是紅色
            // 也可以打印
            System.out.println(e.getMessage());  // 將你異常的原因輸出
        }
        // 拋出異常之后程序終止，后面的程序不會再被運行ArithmeticException
        // Exception in thread "main" java.lang.ArithmeticException: / by zero
        // 這樣并不好，因為軟件如果出現這樣的問題，直接不能執行，這樣的軟件健壯性就太差了，一點點錯誤導致整個軟件崩潰
        // 一個軟件不可避免的會出現異常，但是這樣不好，我們只需要保證沒有語法錯誤，異常不能忍受。
        // 所以Java提供了一個異常處理機制來解決這個問題。因為這個問題不是什么致命的問題。

        System.out.println("程序繼續運行。。。");
    }
}
// 02
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Exception02 {
}

/*
    接下來對異常進行一個介紹
    基本概念：
        Java語言中，將程序執行中發生的不正常情況稱為“異?！保_發過程當中語法錯誤和邏輯錯誤不是異常（這點需要強調）
    執行過程中所發生的異常可以分成兩類：
        1Error錯誤，Java虛擬機無法解決的嚴重問題。如JVM系統內部錯誤，資源耗盡等嚴重的情況。
        比如StackOverflowError棧溢出和OOM out of memory，Error是嚴重錯誤，程序會崩潰

        2Exception：其他因為編程錯誤或者偶然的外在因素導致的一般性問題，可以使用針對性的代碼進行處理。例如
        空指針訪問，試圖讀取不存在的文件，網絡連接中斷等等，Exception分成兩大類，運行時異常和編譯時異常。

        運行時異常和編譯時異常發生的時間不一樣
        運行時異常是在程序運行時，發生的異常
        編譯時異常是在編程時，編譯器檢查出的異常。

        前面的除零就是一個運行時異常。
 */
// 03
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Exception03 {
    public static void main(String[] args) {
//        Throwable
    }
}

/*
    異常體系圖，異常體系圖是一個重點，這里直接畫圖
    在main中輸入Throwable，然后我們進入到這個類中
    右鍵Diagrams然后show Diagram...可以看到IDEA幫我們生成的圖
    這里的Throwable就相當于是所有異常類的根類
    接下來點擊這個根類，然后右鍵Show Implementations可以查看到實現類
    下面所有實現類或者說是接口有哪些，接下來會彈出一個彈窗我們輸入Error
    可以將該類添加到當前這幅圖當中
    這個Error是這里異常根類的一個子類，就是剛剛將的異?？梢苑殖蓛纱箢惖?    第一個Error
    在Error下面還有StackOverflowError棧溢出
    還有內存溢出OutOfMemoryError

    除了Error之外還有一個子類是Exception
    在Exception下面還有一個RuntimeException
    而在RuntimeException有幾個常見的異常
    比如空指針異常
    NullPointerException
    比如算術異常
    ArithmeticException，就是剛才除零的
    比如數組索引越界的異常
    ArrayIndexOutOfBoundsException
    還有類型轉換異常
    ClassCastException
    還有數字格式異常
    NumberFormatException
    這些都是運行時異常

    還有一組是編譯時異常
    也是屬于Exception
    FilNotFoundException
    以上都是最常見的

    最后我們再將Throwable的父類打印出來，可以點擊它然后右鍵show Parents
    虛線表示實現了這個接口I
    Error是一個致命錯誤，無法通過異常捕獲，程序直接會死
    而異常這塊除了編譯異常還有運行異常

    小結：
        1、異常分成兩大類，運行時異常和編譯時異常。
        2、運行時異常，編譯器不要求強制處理的異常。一般是指編程的時候的邏輯錯誤，是程序員應該避免的異常，
        比如前面編譯器不會知道這里是除的是零，因為當前語法正確。
        java.lang.RuntimeException類以及它的子類都是運行時異常。
        3、對于運行時異常，可以不作處理，因為這類異常很普遍，因為這類異常比較普遍，如果全部處理可能會對程序的可讀性
        和運行效率產生影響。
        4、編譯時異常，是編譯器要求必須處置的異常。
 */
// 04
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Exception04 {
    public static void main(String[] args) {
        // 1、NullPointerException空指針異常
        String name = "alice";
        System.out.println(name.length());  // 現在name是不為空的，正常統計個數5
        String nameNull = null;  // 當為空的時候就是null.length()這里會拋出異常
//        System.out.println(nameNull.length());  // Exception in thread "main" java.lang.NullPointerException
        // 2、ArithmeticException是數學運算異常，這個之前除以零的時候見到過了。
        // 3、ArrayIndexOutOfBoundsException數組下標越界異常
        int[] arr = {1, 2, 4};
//        for (int i = 0; i <= arr.length; i++) {  // 這里會拋出數組下標越界異常，因為arr[3]這里剛好超過了能夠訪問的max索引arr[2]
//            System.out.println(arr[i]);  // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
//        }
        // 4、ClassCastException類型轉換異常
        A b = new B();  // 編譯類型是A，運行類型是B，B繼承了A，這是一個向上轉型，指向的是B，是A的b指向了B
        B b2 = (B)b;  // 編譯類型為A想要轉換成B，這是一個向下轉型，因為原本指向的是B所以可以轉換
//        C c2 = (C)b;  // 因為b現在編譯類型和運行類型都是B，B和C沒有什么繼承關系B不繼承C，C不繼承B，并且b現在指向的是B不是C，所以不能轉
        // Exception in thread "main" java.lang.ClassCastException
//        5、NumberFormatException數字格式不正確異常[]
        String str = "123";
        int num = Integer.parseInt(str);  // 將一個整數字符串轉換為一個整型int可以
        String str1 = "hello";
        int num1 = Integer.parseInt(str1);  // 這個字符串是一個英文字符串
        // Exception in thread "main" java.lang.NumberFormatException
    }
}
class A {}
class B extends A{}
class C extends A{}
/*
    常見的運行時異常
    常見的運行時異常包括：
        1、NullPointerException空指針異常
            當應用程序試圖在需要對象的地方使用null時，拋出該異常
        2、ArithmeticException數學運算異常
            當出現異常的運算條件時，拋出此異常，比如除以零會拋出此類的一個實例。
        3、ArrayIndexOutOfBoundsException數組下標越界異常
            使用非法的索引方法數組時拋出的異常。如果索引為負或者大于等于數組大小，則該索引為非法索引
        4、ClassCastException類型轉換異常
            當試圖將對象強轉為不是實例的子類的時候，拋出該異常，
        5、NumberFormatException數字格式不正確異常[]
            NumberFormatException數字格式不正常異常
            當應用程序試圖將字符串轉換成一種數值類型，但是該字符串不能轉換為適當格式的時候會拋出該異常。
            使用異常我們可以確保輸入是滿足條件的數字。
 */
// 05
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Exception05 {
    public static void main(String[] args) {
//        // 第一題
//        String friends[]={"tom","jack","milan"};
//        for(int i = 0; i < 4; i++) {  // 這里多了一個3，會出現數組下標越界的異常
//            System.out.println(friends[i]);
//        }
//        // 第二題
//        Cat c = new Cat();
//        cat = null;
//        System.out.println(cat.name);  // null.name空指針異常
//        // 第三題
//        public class AAA {
//            int x;
//            public static void main(String[] args) {
//                int y;
//                AAA a = new AAA();
//                y = 3/a.x;  // 類成員被默認初始化為0，所以這里產生一個除零的異常-數學運算異常
//                System.out.println("program ends ok!");
//            }
//        }
//        // 第四題
//        class Person {
//            public static void main(String[] args) {
//                Object obj = new Date();  // 一個上轉型，當前編譯類型為Object，當前運行類型為Date，指向Date
//                Person person;
//                person = (Person)obj;  // 這里應該轉成Date可以，而Person和Date之間沒有任何的關系。轉不了
//                System.out.println(person);  // ClassCastException類型轉換異常
//            }
//        }
    }
}
/*
    編譯異常
    介紹：
        編譯異常是指在編譯期間，就必須處理的異常，否則代碼不能通過編譯。
    常見的編譯異常
        編譯異常一般發生在網絡，數據庫和文件的時候
        SQLException 操作數據庫的時候，查詢表可能會發生異常
        IOException  操作文件的時候，發生的異常
        FileNotFoundException 當操作一個不存在的文件的時候發生的異常
        ClassNotFoundException 加載類，而該類不存在的時候發生異常
        EOFException 操作文件，到文件結尾，發生異常
        IllegalArgumentException 參數異常
 */

/*
    關于異常的課堂練習
    看看下面代碼是否正確，為什么。
 */
// 06
package com.alice.innerclass_.innerclass03.Exception_;

/**
 * @author alice_huijing
 * @version 1.0
 */
public class Exception06 {
    public static void main(String[] args) {
        // 第一個小細節。
        // 注意使用快捷鍵來快速生成異常處理代碼
        // Ctrl + Alt + t
//        try {  // 比如這段代碼可能會出現異常，先選中這段代碼，然后快捷鍵選擇try catch
//            String str = "hello";
//            int a = Integer.parseInt(str);
//            System.out.println("數字：" + a); // 前面出現了異常直接跳到catch中執行，這行代碼不會被執行。
//        } catch (NumberFormatException e) {
//            System.out.println("異常信息為：" + e.getMessage());
//        }
//        System.out.println("后面的代碼正常執行。");
        // 第二個小細節
//        try {  // 比如這段代碼可能會出現異常，先選中這段代碼，然后快捷鍵選擇try catch
//            String str = "123";
//            int a = Integer.parseInt(str);
//            System.out.println("數字：" + a);  // 這里可以正常通過轉換
//        } catch (NumberFormatException e) {  // catch中的代碼不會被執行，因為沒有異常，也就不會捕獲到異常
//            System.out.println("異常信息為：" + e.getMessage());
//        }
//        System.out.println("后面的代碼正常執行。");
        // 第三個小細節
        try {
            String str = "123";
            int a = Integer.parseInt(str);
            System.out.println("數字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("異常信息為：" + e.getMessage());
        } finally {  // 管你有沒有異常都會執行。
            System.out.println("finally代碼被執行。。。");
        }
        System.out.println("后面的代碼正常執行。");
        // tip：IDEA的終端右上角的小齒輪的View Mode的Float可以將終端浮動哦，相當于我們執行的時候會有終端彈出。
//        // 第四個小細節，Exception作為這些異常的父類可以都捕獲，但是只能捕獲先發生的。
//        try {
//            Person person = new Person();
//            person = null;  // 出現一個異常直接拋出，后面的直接不執行。
//            System.out.println(person.getName());  // 空指針異常
//            int n1 = 10;
//            int n2 = 0;
//            int res = n1 / n2; // 算數運算異常
//        } catch (Exception e) {
//            System.out.println(e.getMessage());  // 因為這兩種異常都是Exception的子類，所以都能夠捕獲到
//        } finally {
//            System.out.println("不管是否異常都會執行。");
//        }
        // 第五個小細節，可以寫多個catch就可以捕獲各種指定的異常，要求子類異常寫道前面，父類異常寫道后面
        // 因為如果父類寫在前面就沒有意義了，后面的異常永遠不會被執行
//        try {
//            Person person = new Person();
//            person = null;  // 出現一個異常直接拋出，后面的直接不執行。
//            System.out.println(person.getName());  // 空指針異常
//            int n1 = 10;
//            int n2 = 0;
//            int res = n1 / n2; // 算數運算異常
//        } catch (NullPointerException e) {  // 單獨捕獲空指針異常
//            System.out.println("空指針異常=" + e.getMessage());
//        } catch (ArithmeticException e) {
//            System.out.println("算數異常=" + e.getMessage());
//        } catch (Exception e) {
//            System.out.println(e.getMessage());
//        } finally {
//            System.out.println("不管是否異常都會執行。");
//        }
        try {
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        } finally {
            System.out.println("執行了finally...");
        }
        System.out.println("程序繼續執行...");  // 因為不會捕獲異常，所以直接崩了，這句代碼不會執行到。程序退出。
    }
}

/*
    異常處理的兩種方式
    異常處理
    基本介紹：
        異常處理就是當異常發生的時候，對異常處理的方式
    異常處理的方式：
        1、try-catch-finally方式
            程序員在代碼中捕獲發生的異常，自行進行處理
        2、throws
            將發生的異常拋出，交給調用者（方法）來處理，最頂級的處理人就是JVM

    細節：
        1、如果異常發生了，則異常發生后面的代碼不會執行，直接進入到catch塊。
        2、如果異常沒有發生，則順序執行try的代碼塊，不會進入到catch。
        3、如果希望不管是否發生異常，都執行某段代碼（比如關閉連接，釋放資源等，則使用下面的finally這個）
        4、可以有多個catch語句，捕獲不同的異常（進行不同的業務處理），要求父類異常在后面，子類異常在前面，
        比如Exception在后面，NullPointerException在前面，如果發生異常，只會匹配一個catch。
        5、第五點可以只使用try-finally配合使用，這種用法相當于沒有捕獲異常，因此程序會直接崩掉。
        應用場景是執行一段代碼，不管是否發生異常，都必須執行某個業務邏輯。
        本質是沒有捕獲異常，程序結束。
 */

三、附圖