Java基础题的复习----第四章

题目：

---

1.异常有什么用
2.异常在java中以什么形式存在 
3.是否可以自定义，如何自定义异常
4.三种处理方式 ，五个关键字如何使用，各自都什么情况下用，举例
5.error和exception的差别  
6.两种异常都是什么，都什么时候用 
7.举例五个以上检查异常
8.final，finally，finalize差别

---

 

---

1.异常有什么用

异常（Exception）是编程中的一种机制，用于处理程序运行过程中出现的错误和特殊情况。其主要作用包括：

1.错误处理：异常使得程序能够在遇到错误时不中断执行，而是捕获错误并进行适当的处理。例如，文件读取失败、网络连接断开等情况，可以通过异常捕获来处理，而不是直接导致程序崩溃。

2.代码清晰性：使用异常可以将错误处理代码与正常业务逻辑代码分离，使代码更加清晰和易读。正常业务逻辑和错误处理逻辑分开写，可以更好地维护和理解代码。

3.资源管理：异常机制可以帮助管理资源，例如文件句柄、数据库连接等。当出现异常时，可以确保资源被正确释放，避免资源泄露。

4.提高程序健壮性：通过捕获和处理异常，程序可以应对各种不可预见的情况，避免因意外情况导致程序崩溃，从而提高程序的健壮性和稳定性。

5.调试与测试：异常信息通常包含错误的详细信息和堆栈跟踪，有助于调试和定位问题。此外，通过编写测试代码触发和捕获异常，可以测试程序在异常情况下的表现，确保其可靠性。

2.异常在java中以什么形式存在 

 在Java中，异常是通过类和对象的形式存在的。

3.是否可以自定义，如何自定义异常

可以自定义异常。

自定义异常的步骤
1.创建一个新的类继承Exception或RuntimeException。
2.提供一个或多个构造方法，用于初始化异常对象。
3.可选：添加一些自定义的属性和方法，以便传递更多的异常信息。

示例代码
以下是一个自定义受检查异常的示例：

// 自定义异常类，继承自Exception
public class MyCustomException extends Exception {
    // 构造方法
    public MyCustomException(String message) {
        super(message);
    }

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

// 使用自定义异常
public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (MyCustomException e) {
            System.out.println("Caught MyCustomException: " + e.getMessage());
        }
    }

    // 抛出自定义异常的方法
    public static void validateAge(int age) throws MyCustomException {
        if (age < 18) {
            throw new MyCustomException("Age must be 18 or older.");
        }
        System.out.println("Age is valid.");
    }
}

解释：在这个例子中，我们创建了一个名为MyCustomException的自定义异常类，并在validateAge方法中使用它。当年龄小于18时，抛出MyCustomException异常。

自定义未受检查异常
未受检查异常继承自RuntimeException，以下是一个示例：

// 自定义异常类，继承自RuntimeException
public class MyUncheckedException extends RuntimeException {
    // 构造方法
    public MyUncheckedException(String message) {
        super(message);
    }

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

// 使用自定义异常
public class UncheckedExceptionDemo {
    public static void main(String[] args) {
        try {
            processInput(null);
        } catch (MyUncheckedException e) {
            System.out.println("Caught MyUncheckedException: " + e.getMessage());
        }
    }

    // 抛出自定义未受检查异常的方法
    public static void processInput(String input) {
        if (input == null || input.isEmpty()) {
            throw new MyUncheckedException("Input cannot be null or empty.");
        }
        System.out.println("Processing input: " + input);
    }
}

在这个例子中，我们创建了一个名为MyUncheckedException的自定义异常类，并在processInput方法中使用它。当输入为空时，抛出MyUncheckedException异常。

4.三种处理方式 ，五个关键字如何使用，各自都什么情况下用，举例

三种处理方式
1.捕获异常并处理（try-catch）：使用try-catch块捕获并处理异常。
2.声明异常（throws）：在方法签名中使用throws关键字声明可能抛出的异常。
3.抛出异常（throw）：使用throw关键字在方法体内抛出异常。

 五个关键字
1.try：用于包围可能抛出异常的代码块。
2.catch：用于捕获并处理在try块中抛出的异常。
3.finally：无论是否发生异常，finally块中的代码总是会执行，用于清理资源等收尾工作。
4.throw：用于显式抛出异常对象。
5.throws：用于在方法签名中声明该方法可能抛出的异常。

1.try-catch-finally

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("This will always execute.");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // 可能抛出ArithmeticException
    }
}

2. 声明异常（throws）

public class ThrowsExample {
    public static void main(String[] args) {
        try {
            readFile("nonexistentfile.txt");
        } catch (IOException e) {
            System.out.println("Caught IOException: " + e.getMessage());
        }
    }

    public static void readFile(String filePath) throws IOException {
        if (filePath == null || filePath.isEmpty()) {
            throw new IOException("File path is invalid.");
        }
        // 模拟文件读取操作
        throw new IOException("File not found.");
    }
}

3.抛出异常（throw)

public class TestThrow {
    public static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be 18 or older");
        } else {
            System.out.println("Age is valid");
        }
    }

    public static void main(String[] args) {
        checkAge(15);  // This will throw an IllegalArgumentException
    }
}

5.error和exception的差别  

• Error：

  • 表示严重的、不可恢复的系统级错误。
  • 通常由JVM抛出，程序不需要捕获。
  • 例如：OutOfMemoryError, StackOverflowError.

• Exception：

  • 表示程序中可以捕获并处理的异常情况。
  • 可以通过try-catch块捕获并处理。
  • 分为受检查异常（必须捕获或声明）和未检查异常（可以选择捕获）。
  • 例如：IOException, SQLException, NullPointerException.

6.两种异常都是什么，都什么时候用 

在Java中，异常分为两类：受检查异常（checked exceptions）和非受检查异常（unchecked exceptions）。 

1. Checked Exceptions（受检查异常）
  受检查异常是编译时异常，必须在代码中明确处理，否则编译器会报错。这类异常通常用于处理程序可以预见且可以恢复的异常情况。

常见的受检查异常：

1.IOException: 处理输入/输出操作失败时引发，例如文件读写错误。
2.SQLException: 数据库访问错误时引发。
3.ClassNotFoundException: 找不到类时引发。
使用场景：

受检查异常通常用于处理那些程序可以预见并可能进行恢复的错误。例如，文件操作、网络连接等。这些异常要求程序员在代码中显式地处理异常情况。示例：

import java.io.*;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("nonexistentfile.txt");
            BufferedReader br = new BufferedReader(reader);
            System.out.println(br.readLine());
            br.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("I/O error: " + e.getMessage());
        }
    }
}

2. Unchecked Exceptions（未检查异常）
未检查异常是在运行时引发的异常，包括RuntimeException及其子类。这类异常通常表示程序逻辑错误或程序员的失误，通常不要求强制捕获或声明。

常见的未检查异常：

1.NullPointerException: 当程序尝试访问一个空对象的成员时引发。
2.ArrayIndexOutOfBoundsException: 当数组访问越界时引发。
3.ArithmeticException: 例如除以零时引发。

使用场景：

未检查异常通常用于表示程序逻辑中的错误，例如非法参数、数组越界等。这些异常不强制要求程序员捕获或声明，但应在开发过程中进行处理，以提高程序的健壮性。

示例：

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index out of bounds: " + e.getMessage());
        }
    }
}

总结
受检查异常（Checked Exceptions）：用于处理可以预见且可以恢复的异常情况，必须在代码中明确处理。适用于IO操作、数据库访问等。
未检查异常（Unchecked Exceptions）：表示程序逻辑错误或程序员失误，不强制捕获或声明。适用于非法参数、数组越界等。

7.举例五个以上检查异常

IOException：用于处理输入输出操作中的异常，如文件读写、网络连接等。例如，尝试读取一个文件，但文件不存在或不可读时，将抛出FileNotFoundException异常。

try {
    File file = new File("path/to/file.txt");
    FileReader reader = new FileReader(file);
    // 其他文件读取操作
} catch (FileNotFoundException e) {
    System.out.println("文件未找到");
    e.printStackTrace();

SQLException：用于处理数据库操作中的异常，如连接数据库失败、执行SQL语句错误等。例如，尝试执行一个错误的SQL语句时，将抛出SQLException异常。

try {
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbname", "username", "password");
    Statement statement = connection.createStatement();
    // 执行SQL语句
} catch (SQLException e) {
    System.out.println("SQL语句执行错误");
    e.printStackTrace();
}

ClassNotFoundException：用于处理类加载失败的异常，当尝试加载一个不存在的类时抛出。例如，尝试加载一个不存在的类时，将抛出ClassNotFoundException异常。

try {
    Class.forName("com.example.MyClass");
} catch (ClassNotFoundException e) {
    System.out.println("类加载失败");
    e.printStackTrace();
}

InterruptedException：用于处理线程中断异常，当线程在等待、休眠或阻塞状态被中断时抛出。例如，当线程在休眠状态被中断时，将抛出InterruptedException异常。

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    System.out.println("线程中断异常");
    e.printStackTrace();
}

FileNotFoundException：用于处理文件未找到异常，当尝试访问一个不存在的文件时抛出。例如，尝试打开一个不存在的文件时，将抛出FileNotFoundException异常。

try {
    FileReader reader = new FileReader("file.txt");
    // 其他文件读取操作
} catch (FileNotFoundException e) {
    System.out.println("文件未找到");
    e.printStackTrace();
}

8.final，finally，finalize差别

1. final

final是一个关键字，可以用于声明类、方法和变量。

使用场景：

final类：声明为final的类不能被继承。

final方法：声明为final的方法不能被子类重写。

final变量：声明为final的变量是常量，一旦赋值后就不能改变。

2. finally

finally是一个代码块，用于保证无论是否发生异常，某段代码都会被执行。通常与try-catch结构一起使用，用于释放资源等操作。

使用场景：

确保执行清理代码：无论是否发生异常，finally块中的代码都会执行，通常用于关闭文件、释放资源等。

3. finalize

finalize是一个方法，由Java虚拟机在垃圾回收器准备释放对象之前调用。finalize方法的目的是允许对象在被回收前进行清理工作，但它不保证会被及时调用，甚至可能永远不会被调用。

使用场景：

• 垃圾回收前的清理工作：finalize方法允许对象在被垃圾回收前执行清理代码。然而，使用finalize已不被推荐，因为其执行时间不确定，且存在性能问题。建议使用try-with-resources或显式的资源管理方式来替代。