@[TOC]

内部类

Java内部类（Inner Class）是嵌套在其他类中的类，它可以访问外部类的成员变量和方法，同时也可以被外部类访问。Java内部类主要有四种类型：

1. 成员内部类（Member Inner Class）
2. 局部内部类（Local Inner Class）
3. 匿名内部类（Anonymous Inner Class）
4. 静态内部类（Static Inner Class）

下面我们将分别对这四种内部类进行详解，并且给出相应的示例代码。

成员内部类

成员内部类是定义在另一个类中的类，它通常用于封装一些业务逻辑，只有在创建了外部类的对象之后才能够创建成员内部类的对象。成员内部类在访问外部类的成员变量和方法时，需要通过外部类的实例来访问。

public class Outer {
    private int outerNum = 10;

    public class Inner {
        public void print() {
            System.out.println("Outer Num: " + outerNum);
        }
    }

    public void test() {
        Inner inner = new Inner();
        inner.print();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test(); // 输出：Outer Num: 10
    }
}

在上面的代码中，Inner类是成员内部类，它访问了外部类的outerNum成员变量。

局部内部类

局部内部类是定义在方法体内部的类，它只在该方法中有效，因此局部内部类不需要访问外部类的成员变量和方法时使用。与成员内部类不同的是，局部内部类可以访问方法中的final类型的局部变量。

public class Outer {
    public void test(final int x) {
        final int y = 10;

        class Inner {
            public void print() {
                System.out.println("x: " + x + ", y: " + y);
            }
        }

        Inner inner = new Inner();
        inner.print(); // 输出：x: 100, y: 10
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test(100);
    }
}

在上面的代码中，Inner类是局部内部类，它访问了test方法中的x和y局部变量。

匿名内部类

匿名内部类是没有名称的内部类，它通常用于实现接口或继承抽象类，并且只需要创建一个对象的场景。由于匿名内部类没有名称，因此它无法被其他方法或类所引用，在创建后只能使用一次。

public class Outer {
    public void test() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running.");
            }
        });

        thread.start();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test(); // 输出：Thread is running.
    }
}

在上面的代码中，我们使用匿名内部类实现了Runnable接口，并创建了一个新的线程。

静态内部类

静态内部类是被声明为static的内部类，它不需要依赖于外部类的实例就可以创建对象。与成员内部类相比，静态内部类只能访问外部类的静态成员变量和方法。

public class Outer {
    private static int outerNum = 10;

    public static class Inner {
        public void print() {
            System.out.println("Outer Num: " + outerNum);
        }
    }

    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.print(); // 输出：Outer Num: 10
    }
}

在上面的代码中，Inner类是静态内部类，它访问了外部类的outerNum静态成员变量。

总结一下，Java内部类是嵌套在其他类中的类，它可以访问外部类的成员变量和方法。Java内部类主要有四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。不同类型的内部类适用于不同的场景，能够提高程序的灵活性和可读性。

异常处理

Java异常处理是指在程序运行时可能出现的错误或异常情况进行捕获、处理和抛出。Java语言中的所有异常都继承自Throwable类，其中又分为两种类型：Checked Exception和Unchecked Exception。

• Checked Exception（受检异常）：必须在方法签名中声明或者捕获处理，否则编译不通过，例如IOException、SQLException等。
• Unchecked Exception（非受检异常）：不需要在方法签名中声明或者捕获处理，例如NullPointerException、ArrayIndexOutOfBoundsException等。

下面我们结合示例代码来详解Java异常处理。

异常捕获与处理

Java程序中的异常通常可以通过try-catch-finally语句块进行捕获和处理。try块内包含可能会产生异常的代码，当发生异常时，会跳转到相应的catch块进行处理。

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // 抛出ArithmeticException异常
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) { // 捕获ArithmeticException异常
            System.out.println("Divide by zero.");
            e.printStackTrace(); // 打印异常信息
        } finally {
            System.out.println("Finally block executed.");
        }
    }
}

在上面的代码中，我们进行了除以0的操作，抛出了一个算术异常ArithmeticException，然后使用catch块捕获并打印异常信息。最后执行了finally块中的代码。

多重异常捕获和处理

在一个try语句块中，可以使用多个catch语句分别捕获不同类型的异常，并进行相应的处理。

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); // 抛出ArrayIndexOutOfBoundsException异常
        } catch (ArrayIndexOutOfBoundsException e) { // 捕获数组下标越界异常
            System.out.println("Array index out of bounds.");
        } catch (Exception e) { // 捕获其他异常
            System.out.println("Other exception.");
        }
    }
}

在上面的代码中，我们使用了两个catch块来分别捕获数组下标越界异常和其他异常。

抛出异常

有时候，在方法内部无法解决某些问题时，需要抛出一个异常，告知调用者该方法无法正常运行，并提供异常信息。在Java中，可以使用throw关键字抛出一个异常对象。

public class ExceptionDemo {
    public static void main(String[] args) throws FileNotFoundException {
        loadFile("test.txt");
    }

    public static void loadFile(String fileName) throws FileNotFoundException {
        File file = new File(fileName);
        if (!file.exists()) {
            throw new FileNotFoundException("File does not exist.");
        }
    }
}

在上面的代码中，我们定义了一个loadFile方法，当文件不存在时，抛出一个FileNotFoundException异常。

总结一下，Java异常处理是在程序运行时可能出现的错误或异常情况进行捕获、处理和抛出。Java语言中的所有异常都继承自Throwable类，其中又分为两种类型：Checked Exception和Unchecked Exception。Java程序中的异常通常可以通过try-catch-finally语句块进行捕获和处理，也可以使用throw关键字抛出一个异常对象。