花几千上万学习Java，真没必要！（三十）

异常：

测试测试代码1：

package catchtest.com;
public class TryCatchExample {  
	//使用一个或多个 catch 块捕获并处理异常。
    public static void main(String[] args) {  
        try {  
            // 尝试执行的代码块  
            int result = 10 / 0; // 引发 ArithmeticException  
            System.out.println("Result: " + result);  
        } catch (ArithmeticException e) {  
            // 捕获 ArithmeticException 并处理  
            System.out.println("捕获到算术异常: " + e.getMessage());  
        } catch (Exception e) {  
            // 捕获所有其他类型的异常  
            // 在实际应用中，通常不建议这样捕获所有异常，它会隐藏一些问题。  
            System.out.println("捕获到异常: " + e.getMessage());  
        } finally {  
            // finally 块，无论是否捕获到异常，都会执行  
            // 常用于关闭资源，如文件、数据库连接等  
            System.out.println("finally 块执行了");  
        }  
  
        // try-catch 之后的代码会继续执行，除非在 try 或 catch 块中显式地中断（如使用 return、throw 或 System.exit()）  
        System.out.println("程序继续执行...");  
    }  
}

测试代码2：

package catchtest.com;
public class ThrowableDemo {
	// Throwable 类是所有错误和异常的超类。
	// getMessage()：获取异常的详细消息字符串。
	// toString()：获取异常的简短描述字符串。
	// printStackTrace()：打印异常的堆栈跟踪到标准错误流。
	// getCause() 和 initCause(Throwable cause)：这个例子没有使用
	// initCause()（因为它在异常被抛出后不能被再次设置），但展示了如何检查异常的 cause（如果存在）。
	// initCause(Throwable cause) 方法通常用于在创建异常对象时设置其原因。
	// 一旦异常被抛出，其 cause 就不能再被更改。如果尝试在异常被抛出后调用 initCause()，将抛出 IllegalStateException。
	public static void main(String[] args) {
		// 创建一个自定义异常，并传递一个消息
		MyCustomException myException = new MyCustomException("这是一个自定义异常");

		try {
			// 抛出一个异常。
			throw myException;

		} catch (MyCustomException e) {
			// 使用Throwable的成员方法
			System.out.println("异常消息: " + e.getMessage());
			System.out.println("异常的字符串表示: " + e.toString());
			e.printStackTrace(); // 打印异常的堆栈跟踪到标准错误流

			// 假设这个异常是由另一个异常引起的
			Throwable cause = new Throwable("这是引起异常的原因");
			// 一旦异常被抛出，它的cause就不能再被设置
			// 在实际场景中，应该在创建异常对象时设置cause
			// e.initCause(cause); //
			// 抛出IllegalStateException，因为cause已经被设置了（默认是null，但一旦设置就不能再改）

			// 但是，我们可以检查并打印cause（如果它存在）
			if (e.getCause() != null) {
				System.out.println("异常的原因: " + e.getCause().getMessage());
			} else {
				System.out.println("此异常没有直接的原因。");
			}

			// 没有为myException设置cause，所以getCause()返回null
		}
	}

	// 定义一个自定义异常类
	static class MyCustomException extends Exception {
		public MyCustomException(String message) {
			super(message); // 调用父类的构造器来设置消息
		}
		// 根据需要添加其他构造器或方法
	}
}

测试代码3：

package catchtest.com;
public class ThrowsDemo {  
	  
    // 自定义一个编译时异常  
    static class MyCheckedException extends Exception {  
        public MyCheckedException(String message) {  
            super(message);  
        }  
    }  
  
    // 声明一个可能会抛出MyCheckedException的方法  
    public static void mightThrowException() throws MyCheckedException {  
        // 假设这里有一些可能抛出MyCheckedException的代码  
        // 直接抛出一个异常  
        throw new MyCheckedException("这是一个可能发生的异常");  
    }  
  
    public static void main(String[] args) {  
        try {  
            // 调用mightThrowException方法，捕获抛出的MyCheckedException  
            mightThrowException();  
        } catch (MyCheckedException e) {  
            // 处理异常  
            System.out.println("捕获到异常: " + e.getMessage());  
        }  
  
        // 如果不捕获异常，并且方法签名中没有使用throws声明异常，编译器会报错  
        // 下面的这行代码如果取消注释，会导致编译错误  
        // mightThrowException(); // 编译错误：Unhandled exception: MyCheckedException  
    }  
  
    // 运行时异常（RuntimeException及其子类），即使不使用throws声明，  
    // 也可以在方法内部抛出，并且调用者可以选择捕获或不捕获这些异常。  
    // 编译时异常（即Exception及其非RuntimeException的子类），  
    // 如果方法内部抛出了这些异常，并且没有在方法内部捕获它们，  
    // 就必须在方法签名中使用throws关键字声明这些异常，  
    // 或者在方法内部使用try-catch块捕获并处理它们。  
}

自定义异常：

创建一个编译时异常类：

package catchtest.com;
//自定义编译时异常
public class MyCustomCheckedException extends Exception {  
    // 构造函数，可以有多个，根据需要定义  
    public MyCustomCheckedException() {  
        // 调用父类的无参构造方法 
        super();  
    }  
  
    public MyCustomCheckedException(String message) {  
        // 调用父类的带有详细信息的构造方法 
        super(message);  
    }  
  
    // 根据需要添加其他构造方法、方法和属性  
}

 创建一个运行时异常类：

package catchtest.com;
//自定义运行时异常
public class MyCustomRuntimeException extends RuntimeException {  
 // 构造函数，可以有多个，根据需要定义  
 public MyCustomRuntimeException() {  
     // 调用父类的无参构造方法  
     super();  
 }  

 public MyCustomRuntimeException(String message) {  
     // 调用父类的带有详细信息的构造方法  
     super(message);  
 }  

 // 根据需要添加其他构造方法、方法和属性  
}

在Main方法中测试： 

package catchtest.com;
public class TestException {  
  
    // 抛出自定义编译时异常的方法  
    public static void mightThrowCheckedException() throws MyCustomCheckedException {  
        // 抛出MyCustomCheckedException  
        throw new MyCustomCheckedException("这是一个自定义的编译时异常");  
    }  
  
    // 抛出自定义运行时异常的方法  
    public static void mightThrowRuntimeException() {  
        // 抛出MyCustomRuntimeException  
        throw new MyCustomRuntimeException("这是一个自定义的运行时异常");  
    }  
  
    public static void main(String[] args) {  
        try {  
            // 调用可能会抛出编译时异常的方法，并捕获该异常  
            mightThrowCheckedException();  
        } catch (MyCustomCheckedException e) {  
            System.out.println("捕获到自定义编译时异常: " + e.getMessage());  
        }  
  
        // 调用可能会抛出运行时异常的方法  
        // 运行时异常不需要在编译时被强制捕获或声明抛出  
        try {  
            mightThrowRuntimeException();  
        } catch (MyCustomRuntimeException e) {  
            // 捕获并处理自定义运行时异常 
            System.out.println("捕获到自定义运行时异常: " + e.getMessage());  
        }  
  
        // 如果不捕获自定义运行时异常，它将按照Java的异常处理机制被传播  
        // 导致程序终止并打印堆栈跟踪  
        mightThrowRuntimeException(); // 直接打印堆栈跟踪，因为异常没有被捕获  
    }  
}

运行结果如下：