本文摘自廖雪峰的java教程，有一定的修改和补充。

Java的异常

调用方如何获知调用失败的信息

约定返回错误码：

int code = processFile("C:\\test.txt");
if (code == 0) {
    // ok:
} else {
    // error:
    switch (code) {
    case 1:
        // file not found:
    case 2:
        // no read permission:
    default:
        // unknown error:
    }
}

这种方式的问题在于，调用方必须记住所有的错误码，并且每次调用后都要检查返回码，容易忘记检查，导致错误被忽略。

在语言层面上提供一个异常处理机制
- Java内置了一套异常处理机制，总是使用异常来表示错误。
- 异常是一种class，因此它本身带有类型信息。异常可以在任何地方抛出，但只需要在上层捕获，这样就和方法调用分离了
1. 从继承关系可知：Throwable是异常体系的根，它继承自Object。
2. Throwable有两个体系：Error和Exception，Error表示严重的错误，程序对此一般无能为力，例如：
- OutOfMemoryError：内存耗尽
- NoClassDefFoundError：无法加载某个Class
- StackOverflowError：栈溢出
1. 而Exception则是运行时的错误，它可以被捕获并处理。
  某些异常是应用程序逻辑处理的一部分，应该捕获并处理。例如：
- NumberFormatException：数值类型的格式错误
- FileNotFoundException：未找到文件
- SocketException：读取网络失败
1. 还有一些异常是程序逻辑编写不对造成的，应该修复程序本身。例如：
- NullPointerException：对某个null的对象调用方法或
- IndexOutOfBoundsException：数组索引越界
1. Exception又分为两大类：RuntimeException以及它的子类；
2. 非RuntimeException（包括IOException、ReflectiveOperationException等等）
  
  Java规定：
  必须捕获的异常，包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
  不需要捕获的异常，包括Error及其子类，RuntimeException及其子类。

捕获异常

常用方法

捕获异常使用try...catch语句，把可能发生异常的代码放到try {...}中，然后使用catch捕获对应的Exception及其子类：

try {
    // 可能发生异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 可选的finally块，无论是否发生异常都会执行
}

多个catch块

可以有多个catch块，分别捕获不同类型的异常。
捕获异常时，多个catch语句的匹配顺序非常重要，子类必须放在前面；

finally块

finally块是可选的，它总是在try块执行完后执行，无论是否发生异常。通常用于释放资源，例如关闭文件或网络连接。
如果try块中有return语句，finally块仍然会执行，然后才返回。总是最后执行finally块。

某些情况下，可以没有catch，只使用try ... finally结构：

try {
    // 可能发生异常的代码
} finally {
    // 释放资源的代码
}

测试代码写法

如果是测试代码，上面的写法就略显麻烦。如果不想写任何try代码，可以直接把main()方法定义为throws Exception，这样``方法抛出的异会直接打印到控制台：

// try...catch
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws Exception {
        byte[] bs = toGBK("中文");
        System.out.println(Arrays.toString(bs));
    }

    static byte[] toGBK(String s) throws UnsupportedEncodingException {
        // 用指定编码转换String为byte[]:
        return s.getBytes("GBK");
    }
}

打印异常信息

捕获异常后，可以使用printStackTrace()方法打印异常的堆栈信息，方便调试：

try {
    // 可能发生异常的代码
} catch (Exception e) {
    e.printStackTrace(); // 打印异常堆栈信息
}

即使什么都不做，也要先把异常记录下来

抛出异常

调用printStackTrace()可以打印异常的传播栈，对于调试非常有用；
捕获异常并再次抛出新的异常时，应该持有原始异常信息；
通常不要在finally中抛出异常。如果在finally中抛出异常，应该原始异常加入到原有异常中。调用方可通过Throwable.getSuppressed()获取所有添加的Suppressed Exception。

自定义异常

1. BaseException需要从一个适合的Exception派生，通常建议从RuntimeException派生

1 2	public class BaseException extends RuntimeException { }

其他业务类型的异常就可以从BaseException派生：

public class UserNotFoundException extends BaseException {
}
public class LoginFailedException extends BaseException {
}
...

自定义的BaseException应该提供多个构造方法

public class BaseException extends RuntimeException {
    public BaseException() {
        super();
    }

    public BaseException(String message, Throwable cause) {
        super(message, cause);
    }

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

    public BaseException(Throwable cause) {
        super(cause);
    }
}
//上述构造方法实际上都是原样照抄RuntimeException。这样，抛出异常的时候，就可以选择合适的构造方法。通过IDE可以根据父类快速生成子类的构造方法。

NullPointerException-空指针异常

原则：早暴露，早修复
减少空指针异常的几种方法：
1. 在变量声明时进行初始化，使用空字符串""而不是默认的null
2. 返回空字符串""、空数组而不是null
3. 如果调用方一定要根据null判断，比如返回null表示文件不存在，那么考虑返回Optional<T>
4. 使用注解如@NonNull和@Nullable来标记变量和方法参数
定位NullPointerException:
- java14及更高版本的JDK在抛出NullPointerException时，会在异常信息中包含具体的变量名称，帮助定位问题。
  - 这种增强的NullPointerException详细信息是Java 14新增的功能，但默认是关闭的，我们可以给JVM添加一个-XX:+ShowCodeDetailsInExceptionMessages参数启用它：
    1
    java -XX:+ShowCodeDetailsInExceptionMessages YourClass

使用断言

特点

断言失败时会抛出AssertionError，导致程序结束退出。因此，断言不能用于可恢复的程序错误，只应该用于开发和测试阶段。

使用

实际开发中，很少使用断言。更好的方法是编写单元测试来验证代码的正确性。

// assert的使用示例
public class Main {
    public static void main(String[] args) {
        int x = -1;
        assert x > 0;
        System.out.println(x);
    }
}

注意：默认情况下，Java运行时不会启用断言。要启用断言，需要在运行Java程序时添加-ea或-enableassertions参数：

1
2
3

$ java -ea Main.java
Exception in thread "main" java.lang.AssertionError
	at Main.main(Main.java:5)

还可以有选择地对特定地类启用断言，命令行参数是：-ea:com.itranswarp.sample.Main，表示只对com.itranswarp.sample.Main这个类启用断言。
或者对特定地包启用断言，命令行参数是：-ea:com.itranswarp.sample...（注意结尾有3个.），表示对com.itranswarp.sample这个包启动断言

使用JDK Logging–Java内置的日志系统

Java内置的日志系统称为JDK Logging，位于java.util.logging包下。

输出日志的好处

可以设置输出样式，避免自己每次都写"ERROR: " + var；
可以设置输出级别，禁止某些级别输出。例如，只输出错误日志；
可以被重定向到文件，这样可以在程序运行结束后查看日志；
可以按包名控制日志级别，只输出某些包打的日志；

日志级别

Java内置的日志级别有7个，按严重程度从低到高排列如下：

ALL：输出所有级别的日志
FINEST：非常详细的信息，一般用于调试
FINER：比FINEST稍微少一些的信息
FINE：一般的调试信息
INFO：普通的信息，例如程序启动、关闭等
WARNING：警告信息，表示可能出现问题
SEVERE：严重错误，表示程序无法继续运行
OFF：不输出任何日志

默认的日志级别是INFO，这意味着INFO、WARNING和SEVERE级别的日志会被输出，而FINE、FINER和FINEST级别的日志会被忽略。

如何使用JDK Logging

// logging
import java.util.logging.Level;
import java.util.logging.Logger;
public class Hello {
    public static void main(String[] args) {
        Logger logger = Logger.getGlobal();
        logger.info("start process...");
        logger.warning("memory is running out...");
        logger.fine("ignored.");
        logger.severe("process will be terminated...");
    }
}

输出如下

Mar 02, 2019 6:32:13 PM Hello main
INFO: start process...
Mar 02, 2019 6:32:13 PM Hello main
WARNING: memory is running out...
Mar 02, 2019 6:32:13 PM Hello main
SEVERE: process will be terminated...

logger.fine()没有打印出来，因为默认的日志级别是INFO，FINE级别的日志被忽略了。

使用Commons Logging

特点

Commons Logging是Apache提供的一个日志接口，位于org.apache.commons.logging包下。
它本身不实现日志功能，而是调用底层的日志实现，例如Log4j或JDK Logging。
这样，程序可以通过Commons Logging接口来记录日志，而不依赖于具体的日志实现。

使用

第一步，通过LogFactory获取Log类的实例；第二步，使用Log实例的方法打日志。
Commons Logging下载jar包
下载后，解压，找到commons-logging-1.2.jar这个文件，再把Java源码Main.java放到一个目录下，例如work目录：

work
├─ commons-logging-1.2.jar
└─ Main.java
然后用javac编译Main.java，编译的时候要指定classpath，不然编译器找不到我们引用的org.apache.commons.logging包。编译命令如下：

1	javac -cp commons-logging-1.2.jar Main.java

如果编译成功，那么当前目录下就会多出一个Main.class文件：
work
├─ commons-logging-1.2.jar
├─ Main.java
└─ Main.class
编译成功后，运行Main类，同样要指定classpath：

1	java -cp .;commons-logging-1.2.jar Main

然后就可以使用Commons Logging记录日志了，示例代码如下：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Main {
    public static void main(String[] args) {
        Log log = LogFactory.getLog(Main.class);
        log.info("start...");
        log.warn("end.");
    }
}

日志级别

Commons Logging定义了以下日志级别：

FATAL：严重错误，表示程序无法继续运行
ERROR：错误信息，表示程序出现问题
WARN：警告信息，表示可能出现问题
INFO：普通的信息，例如程序启动、关闭等
DEBUG：调试信息，详细的信息，一般用于调试
TRACE：非常详细的信息，一般用于调试

使用Log4j

我们在实际使用的时候，并不需要关心Log4j的API，而是通过配置文件来配置它。

以XML配置为例，使用Log4j的时候，我们把一个log4j2.xml的文件放到classpath下就可以让Log4j读取配置文件并按照我们的配置来输出日志。下面是一个配置文件的例子：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
	<Properties>
        <!-- 定义日志格式 -->
		<Property name="log.pattern">%d{MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36}%n%msg%n%n</Property>
        <!-- 定义文件名变量 -->
		<Property name="file.err.filename">log/err.log</Property>
		<Property name="file.err.pattern">log/err.%i.log.gz</Property>
	</Properties>
    <!-- 定义Appender，即目的地 -->
	<Appenders>
        <!-- 定义输出到屏幕 -->
		<Console name="console" target="SYSTEM_OUT">
            <!-- 日志格式引用上面定义的log.pattern -->
			<PatternLayout pattern="${log.pattern}" />
		</Console>
        <!-- 定义输出到文件,文件名引用上面定义的file.err.filename -->
		<RollingFile name="err" bufferedIO="true" fileName="${file.err.filename}" filePattern="${file.err.pattern}">
			<PatternLayout pattern="${log.pattern}" />
			<Policies>
                <!-- 根据文件大小自动切割日志 -->
				<SizeBasedTriggeringPolicy size="1 MB" />
			</Policies>
            <!-- 保留最近10份 -->
			<DefaultRolloverStrategy max="10" />
		</RollingFile>
	</Appenders>
	<Loggers>
		<Root level="info">
            <!-- 对info级别的日志，输出到console -->
			<AppenderRef ref="console" level="info" />
            <!-- 对error级别的日志，输出到err，即上面定义的RollingFile -->
			<AppenderRef ref="err" level="error" />
		</Root>
	</Loggers>
</Configuration>

有了配置文件还不够，因为Log4j也是一个第三方库，我们需要从这里下载Log4j，解压后，把以下3个jar包放到classpath中：
- log4j-api-2.x.jar
- log4j-core-2.x.jar
- log4j-jcl-2.x.jar
因为Commons Logging会自动发现并使用Log4j，所以，把上一节下载的commons-logging-1.2.jar也放到classpath中。