Java异常处理-java教程-PHP中文网

Java Exception Handling

基础知识

理解异常：出现问题时会发生什么？

想象一下你正在玩一个游戏，突然，你的角色掉进了一个坑里。你会怎么办？下次你可能会重新启动游戏或找到避免陷入困境的方法。在编程中，类似的事情也可能发生：你的代码可能会陷入一个称为异常的“坑”。发生这种情况时，程序可能会停止工作或执行意外操作。

什么是异常？

异常就像代码运行时出现问题的信号。也许您试图将数字除以零（这是不允许的），或者您可能试图打开一个不存在的文件。当这些问题出现时，Java 会举起一个标志并说：“嘿！这里有问题！”

如果没有异常处理会发生什么？

如果我们不处理异常，程序可能会崩溃，所有进度都会丢失——就像你不保存游戏而电脑突然关闭一样。

让我们看一个例子：

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;
        int result = number / 0; // This will cause an exception!
        System.out.println("Result: " + result); // This line will never be reached.
    }
}

登录后复制

当你尝试运行这段代码时，它会停下来并抱怨说：“你不能除以零！”

我们怎样才能避免掉坑？

为了避免这个问题，Java 给我们提供了一种叫做 try 和 catch 的东西。

尝试阻止：这是您尝试执行可能导致问题的操作的地方。
catch 块： 这是您在发生问题时捕获问题的地方，这样您的程序就不会崩溃。

让我们重写我们的示例：

public class BasicExample {
    public static void main(String[] args) {
        int number = 10;

        try {
            int result = number / 0; // We know this might cause a problem.
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

登录后复制

这是现在发生的事情：

try 块尝试除以零。
当 Java 发现问题时，它会跳到 catch 块并说：“哎呀！你不能除以零。”

捕捉不同的问题

有关捕获异常的更多信息

既然您知道如何捕获异常，您可能会想，“如果我的代码可能存在不同类型的问题怎么办？我如何捕获所有这些问题？”

想象一下您正在游戏中尝试打开一个宝箱。有时，钥匙不合适（这是一个问题），有时，箱子是空的（这是另一个问题）。您肯定想知道到底出了什么问题，对吧？

不同类型的异常

在 Java 中，存在不同类型的问题，或异常。例如：

ArithmeticException：当你尝试做没有意义的数学运算时，比如除以零。
NullPointerException：当您尝试使用尚不存在的东西时（例如尝试打开一个不存在的宝箱）。
ArrayIndexOutOfBoundsException：当您尝试访问数组以获取超出其限制的内容时，例如在只有 10 个的罐子中请求第 11 个 cookie。

捕获多个异常

让我们看看如何捕获代码中不同类型的问题：

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will cause an ArrayIndexOutOfBoundsException!
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Oops! You tried to access an index that doesn’t exist.");
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        }
    }
}

登录后复制

发生的事情是这样的：

try 块中的代码尝试执行可能导致问题的操作。
如果遇到 ArrayIndexOutOfBoundsException，它会跳转到第一个 catch 块。
如果遇到 ArithmeticException，它会跳转到第二个 catch 块。

如果我想发现任何问题怎么办？

有时，您可能不知道会出现什么问题，但您仍然想发现任何问题。您可以使用通用异常来捕获任何错误：

public class GeneralExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an ArithmeticException!
        } catch (Exception e) {
            System.out.println("Oops! Something went wrong.");
        }
    }
}

登录后复制

这样，如果出现任何问题，catch 块仍然会处理它，并且你的程序不会崩溃。

清理并创建自定义异常

最后一个区块

想象一下，你正在玩一个游戏，你发现了宝藏，但无论你成功与否，你总是想在完成后关闭宝箱。在 Java 中，finally 块就像确保宝箱始终关闭，无论发生什么。

最后一个区块是什么？

finally 块是一段无论是否发生异常都会始终运行的代码。它用于清理，例如关闭文件、停止计时器或收起宝箱。

让我们看一个例子：

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will cause an exception.
        } catch (ArithmeticException e) {
            System.out.println("Oops! You can’t divide by zero.");
        } finally {
            System.out.println("This will always run, no matter what.");
        }
    }
}

登录后复制

发生的事情是这样的：

The try block tries to do something risky.
The catch block catches the problem if it happens.
The finally block always runs, even if there’s no problem.

Making Your Own Custom Exceptions

Sometimes, the problems you face in your code are special. Maybe the game doesn’t just have treasure chests, but also magical doors that can sometimes be locked. You might want to create a special exception for when the door is locked.

Creating a Custom Exception

You can create your own exceptions by making a new class that extends Exception. Let’s create an exception called LockedDoorException:

class LockedDoorException extends Exception {
    public LockedDoorException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            openDoor(false);
        } catch (LockedDoorException e) {
            System.out.println(e.getMessage());
        }
    }

    private static void openDoor(boolean hasKey) throws LockedDoorException {
        if (!hasKey) {
            throw new LockedDoorException("The door is locked! You need a key.");
        }
        System.out.println("The door is open!");
    }
}

登录后复制

Here’s how it works:

We create a new exception called LockedDoorException.
When we try to open the door without a key, we throw the LockedDoorException.
The catch block catches our custom exception and tells us what went wrong.

Summary

In this post, we’ve learned that:

Exceptions are problems that happen when your code is running.
try and catch blocks help us handle these problems, so our program doesn’t crash.
Different types of exceptions are like different kinds of problems.
We can catch multiple exceptions to handle specific problems.
We can also catch any exception using the general Exception type.
The finally block is used to clean up, and it always runs no matter what.
You can create custom exceptions to handle special problems in your code.