Java核心技术卷1ch7-8

《Core Java Volume 1》（Java核心技术卷1）读书笔记、代码。

Ch07 异常 断言 日志

简化的异常层次结构：

Throwable

• Exception
  • RuntimeException（程序错误导致，如数组越界）
  • IOException（程序本身没问题，但I/O错误，如打开的文件不存在）
  • ……
• Error（Java运行时系统的内部错误和资源耗尽错误，如OOM）
  • ……

如果出现 RuntimeException，那么就一定是你的问题。（Note：实际上讨论的所有异常都发生在runtime， RuntimeException其实指逻辑错误）

非受查（unchecked）异常：派生于Error类、RuntimeException类。其它异常则为check异常，编译器将检查是否提供异常处理器。

注意区分：

• throws：用于声明异常，在方法首部声明所有可能抛出的受查异常。
• throw：用于抛出异常，程序如果出现不正常情况，希望手动抛出异常。

// throws声明可能出现FNFE异常
public static void openFile() throws FileNotFoundException {
    InputStream in = new FileInputStream("name");
}

// throws声明可能出现IO异常，throw手动抛出异常（同时也要在首部声明）
public static void readFile(InputStream in) throws IOException, MyException {
    if (in.read() == -1) {
        throw new MyException("End Of File");
    }
    // ...
}

/**
 * 自定义异常类
 */
public class MyException extends Exception {

    // 关于继承 注意：构造器不是方法，不能继承

    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }
}

如何处理异常：一个方法必须声明所有可能抛出的受查异常（throws），或捕获异常（try-catch），而非受查异常要么不可控制（Error），要么就应该避免发生（RuntimeException）。一个方法应该捕获那些知道如何处理的异常，而将那些不知道怎样处理的异常继续进行传递（抛给调用者），调用者方法亦如是。（但如果编写一个覆盖超类的方法，父类方法无throws，则子类只能用try-catch，即不允许在子类的throws说明符中出现超过超类方法所列出的异常类范围）。

public class ExceptionTest {

    public static void subSystem() throws Throwable {
        InputStream in;
        // 解耦合try/catch、try/finally语句块，提高清晰
        // 外层：确保报告所有错误，包括finally块内错误
        try {
            in = new FileInputStream("name");
            // 内层：确保关闭输入流
            try {
                in.read();
            }finally {
                in.close();
            }
        } catch (IOException e) {
//            e.printStackTrace();
            // 改变异常类型，再次抛出异常
            Throwable myE = new MyException("IO exception ...");
            myE.initCause(e);
            throw myE;
        }
    }

    public static void callSubSystem() {
        try {
            subSystem();
        } catch (Throwable myE) {
            Throwable e = myE.getCause();
        }
    }

    public static void tryWithRes() {
        String path = "src/com/company/coreJava/v1ch07/";
        // 可打开多个资源
        try (Scanner in = new Scanner(new FileInputStream(path + "file.txt"));
             PrintWriter out = new PrintWriter(path + "file.out")) {
            while (in.hasNext()) {
                out.println(in.next().toLowerCase());
            }
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        // 自动调用in.close() out.close() 关闭资源
    }

}

使用assert完成参数检查：断言只用于测/开阶段，定位内部程序的错误。不出现任何断言失败（这是致命的）后才可发布代码（当断言被禁用，类加载器将跳过断言代码，不会降低运行速度）。

>java -ea MyApp    // 启用断言

Ch08 泛型程序设计

// 泛型类
public class GenericTest<U, V> {

    // 泛型方法
    public static <T> T getMid(T... a) {
        return a[a.length / 2];
    }

    // 限定类型
    // <T extends BoundingType> T是绑定类型的子类型，两者可以是类或接口，借extends表示
    public static <T extends Comparable & Serializable> T getMin(T[] a) {
        a[0].compareTo(a[1]);
        return null;
    }

    // 通配符类型     类型限定：extends: <=  ，  super: >=
    public static void print(List<? extends AbsPeople> list) {
        for (AbsPeople people : list) {
            System.out.println(people.getDescription());
        }
    }

    public static void callPrint() {
        List<Student> students = new ArrayList<>();
        List<AbsPeople> people = new ArrayList<>();
        students.add(new Student("a", "cs"));
        people.add(new Student("b", "it"));
        people.add(new Teacher("c", 22));
        // 统一调用print()，且print()不用重载
        print(students);
        print(people);
    }
    
    public static void main(String[] args) {
        String s = GenericTest.getMid("a", "bc", "df");
        double d = getMid(1.2, 3.5, 4.0, 5.0);
        System.out.println(getMid(1.2, 3.5, 4, 5));

    }
}

Java泛型转换事实：

• JVM中没有泛型，只有普通的类和方法。
• 所有类型参数都用限定类型替换。