【Java基础】Java 的内部类

前言

在 Java 编程的浩瀚宇宙中，内部类宛如一颗独具魅力的星辰，为代码的组织与设计开辟了新的天地。内部类，从字面意义理解，就是定义在另一个类内部的类。这种看似简单的嵌套结构，却蕴含着强大的能量，不仅极大地增强了代码的封装性，还让代码变得更加模块化和易于维护。为了更形象地理解内部类与外部类的关系，我们可以把最外面的类想象成一个完整的“人”，而内部类就如同“人”身体里至关重要的“心脏”。通常情况下，若要创建内部类的实例，就如同要拥有一颗具体的“心脏”，必须先有一个“人”的存在，也就是要先创建外部类的实例。不过，这个形象的比喻也有一定的局限性，对于某些特殊的内部类，比如静态内部类，就不太适用了，后续我们会详细阐述。接下来，就让我们一同踏上深入探索 Java 内部类奥秘的奇妙之旅。

内部类的定义与作用

定义

内部类是定义在其他类内部的类。从类的结构角度来看，它打破了传统类独立存在的模式，以一种嵌套的方式存在于另一个类之中。内部类与外部类之间存在着紧密的联系，它可以访问外部类的成员，包括私有成员。这是因为内部类在编译后会生成一个独立的 .class 文件，但它会持有一个指向外部类对象的引用，借助这个引用，内部类便能够访问外部类的各种成员。

作用

实现多继承效果

在 Java 语言中，类是不支持多继承的，即一个类不能直接继承多个父类。然而，通过内部类，我们可以在一定程度上模拟多继承的效果。一个类可以通过内部类继承不同的类或实现多个接口，从而整合多个类的特性。例如，一个外部类可以有多个内部类，每个内部类继承不同的父类，这样外部类就可以借助这些内部类间接拥有多个父类的功能。

提高封装性

封装是面向对象编程的重要特性之一，它的目的是将数据和操作数据的方法捆绑在一起，隐藏对象的内部实现细节，只对外提供必要的接口。内部类可以很好地实现这一目标，将内部类隐藏在外部类中，对外提供更简洁的接口。外部类可以对内部类的访问进行严格控制，减少外部对内部实现细节的访问，增强了代码的安全性和可维护性。即使内部类的实现发生了变化，只要外部接口保持不变，对外部代码的影响就会降到最低。

方便事件处理

在 Java 的图形用户界面（GUI）编程中，事件处理是一个重要的部分。内部类常被用作事件监听器，用于处理各种用户交互事件，如按钮点击、鼠标移动等。使用内部类作为事件监听器可以方便地访问外部类的成员，从而更灵活地处理事件。而且，由于内部类可以直接访问外部类的私有成员，我们可以在不暴露外部类内部细节的情况下完成事件处理逻辑。

内部类的类型

成员内部类

成员内部类是定义在外部类的成员位置的类，它就像外部类的一个普通成员变量一样，拥有自己的属性和方法。成员内部类可以使用各种访问修饰符，如 public、private、protected 等，来控制其访问权限。

访问外部类成员

成员内部类可以访问外部类的所有成员，包括私有成员。这是因为成员内部类持有一个指向外部类对象的引用，通过这个引用，它可以直接访问外部类的成员。例如：

class OuterClass {
    private int outerVariable = 10;

    // 成员内部类
    public class InnerClass {
        public void printOuterVariable() {
            System.out.println("访问外部类的变量: " + outerVariable);
        }
    }

    public void createInnerObject() {
        InnerClass inner = new InnerClass();
        inner.printOuterVariable();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.printOuterVariable();
    }
}

在上述代码中，InnerClass 是 OuterClass 的成员内部类。在 InnerClass 的 printOuterVariable 方法中，我们可以直接访问外部类的私有变量 outerVariable。要创建成员内部类的对象，需要先创建外部类的对象，然后通过外部类对象来创建内部类对象，这就如同我们要拥有一颗“心脏”，得先有一个“人”。

注意事项

当成员内部类中的变量名与外部类的变量名相同时，为了区分它们，可以使用 OuterClass.this 来引用外部类的对象。例如：

class OuterClass {
    int num = 10;

    class InnerClass {
        int num = 20;

        public void printNums() {
            System.out.println("内部类的 num: " + num);
            System.out.println("外部类的 num: " + OuterClass.this.num);
        }
    }
}

静态内部类

静态内部类是用 static 修饰的内部类，它与成员内部类有着明显的区别。静态内部类不依赖于外部类的实例，可以直接通过外部类名来访问。这就好像是一个特殊的“心脏”，它不需要依附于某个具体的“人”就能独立存在。

访问外部类成员

静态内部类只能访问外部类的静态成员，这是因为静态内部类没有持有外部类对象的引用，它只与外部类的类本身相关。例如：

class OuterClass {
    private static int outerStaticVariable = 20;

    // 静态内部类
    static class StaticInnerClass {
        public void printOuterStaticVariable() {
            System.out.println("访问外部类的静态变量: " + outerStaticVariable);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.printOuterStaticVariable();
    }
}

在这个例子中，StaticInnerClass 是静态内部类，我们可以直接通过 OuterClass.StaticInnerClass 来创建对象，而不需要先创建外部类的对象。

创建对象和访问成员

创建静态内部类的对象时，不需要先创建外部类的对象。静态内部类可以有自己的静态成员和非静态成员，静态成员可以通过类名直接访问，非静态成员需要通过对象来访问。

局部内部类

局部内部类是定义在方法或代码块内部的类，它的作用域仅限于所在的方法或代码块。局部内部类就像是一个临时的“小助手”，只在特定的方法或代码块中发挥作用。

访问局部变量

局部内部类只能访问方法中声明为 final 或 effectively final 的局部变量。effectively final 是指变量在初始化后没有被重新赋值。这是因为局部变量存储在栈中，当方法执行结束后，局部变量就会被销毁，而局部内部类的对象可能在方法执行结束后仍然存在，如果局部内部类可以访问非 final 的局部变量，就会导致变量的不一致问题。例如：

class OuterClass {
    public void outerMethod() {
        final int localVar = 30;

        // 局部内部类
        class LocalInnerClass {
            public void printLocalVariable() {
                System.out.println("访问局部变量: " + localVar);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.printLocalVariable();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();
    }
}

在上述代码中，LocalInnerClass 是局部内部类，它只能在 outerMethod 方法内部使用。在 LocalInnerClass 的 printLocalVariable 方法中，我们可以访问 final 修饰的局部变量 localVar。

注意事项

局部内部类不能使用访问修饰符，因为它的作用域仅限于所在的方法或代码块。局部内部类可以访问外部类的所有成员，包括私有成员。

匿名内部类

匿名内部类是一种没有类名的内部类，通常用于创建只需要使用一次的类。它可以实现接口或继承抽象类。在 Java 8 及以后的版本中，匿名内部类在实现函数式接口时可以进行简写，使用 Lambda 表达式，让代码更加简洁。

传统匿名内部类写法

传统的匿名内部类语法比较繁琐，需要在创建对象的同时实现接口或继承抽象类。例如：

interface MyInterface {
    void doSomething();
}

public class Main {
    public static void main(String[] args) {
        // 传统匿名内部类
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("匿名内部类实现接口方法");
            }
        };
        myInterface.doSomething();
    }
}

在上述代码中，我们创建了一个实现 MyInterface 接口的匿名内部类对象，并调用了其 doSomething 方法。

Lambda 表达式简写

Lambda 表达式是 Java 8 引入的一种简洁的语法，用于创建函数式接口的实例。函数式接口是指只包含一个抽象方法的接口。使用 Lambda 表达式可以避免创建匿名内部类时的繁琐语法，让代码更加简洁易读。例如：

interface MyInterface {
    void doSomething();
}

public class Main {
    public static void main(String[] args) {
        // Lambda 表达式简写
        MyInterface myInterface = () -> System.out.println("使用 Lambda 表达式实现接口方法");
        myInterface.doSomething();
    }
}

在这个例子中，我们使用 Lambda 表达式 () -> System.out.println("使用 Lambda 表达式实现接口方法") 来实现 MyInterface 接口，代码变得更加简洁。

适用场景

匿名内部类适用于需要快速实现接口或继承抽象类的场景，特别是在只需要使用一次的情况下。例如，在事件处理、线程创建等场景中，匿名内部类可以让代码更加简洁明了。

内部类的应用场景

事件处理

在 Java 的 GUI 编程中，匿名内部类常被用作事件监听器，用于处理用户的交互事件。而 Lambda 表达式的引入，让事件处理代码更加简洁。例如：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ButtonExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Button Example");
        JButton button = new JButton("Click me");

        // 传统匿名内部类作为事件监听器
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(frame, "Button clicked!");
            }
        });

        // Lambda 表达式简写
        button.addActionListener(e -> JOptionPane.showMessageDialog(frame, "Button clicked with Lambda!"));

        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

在上述代码中，我们使用传统匿名内部类和 Lambda 表达式分别为按钮添加了事件监听器。可以看到，使用 Lambda 表达式的代码更加简洁。

实现策略模式

内部类可以用于实现策略模式，将不同的算法封装在不同的内部类中，方便在运行时动态切换算法。策略模式是一种行为设计模式，它定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。例如：

interface Strategy {
    int execute(int a, int b);
}

class Calculator {
    public int calculate(int a, int b, Strategy strategy) {
        return strategy.execute(a, b);
    }

    // 加法策略
    public class AdditionStrategy implements Strategy {
        @Override
        public int execute(int a, int b) {
            return a + b;
        }
    }

    // 减法策略
    public class SubtractionStrategy implements Strategy {
        @Override
        public int execute(int a, int b) {
            return a - b;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        Calculator.AdditionStrategy addition = calculator.new AdditionStrategy();
        Calculator.SubtractionStrategy subtraction = calculator.new SubtractionStrategy();

        int result1 = calculator.calculate(5, 3, addition);
        int result2 = calculator.calculate(5, 3, subtraction);

        System.out.println("加法结果: " + result1);
        System.out.println("减法结果: " + result2);
    }
}

在这个例子中，Calculator 类定义了一个 calculate 方法，它接受两个操作数和一个 Strategy 对象作为参数。AdditionStrategy 和 SubtractionStrategy 是 Calculator 类的成员内部类，分别实现了加法和减法策略。通过传递不同的策略对象，我们可以在运行时动态切换算法。

总结

Java 内部类是一个功能强大且灵活的特性，它为代码的设计和组织提供了更多的选择。通过合理使用不同类型的内部类，我们可以提高代码的封装性、可维护性和复用性。特别是在 Java 8 引入 Lambda 表达式后，匿名内部类的使用更加简洁高效。在实际编程中，我们应该根据具体的需求选择合适的内部类类型，并充分发挥内部类的优势，让代码更加优雅和高效。希望通过本文的详细介绍，你对 Java 内部类有了更深入的理解和掌握，能够在编程实践中灵活运用内部类来解决各种问题。

---

可以说在一定程度上，匿名内部类是子类或实现类的一种简写方式，但内部类的概念更为宽泛：

匿名内部类：子类或实现类的简写

• 实现接口时的简写：当我们需要实现一个接口，并且这个实现类只使用一次时，使用匿名内部类可以避免创建一个完整的类文件。

interface MyInterface {
    void doSomething();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        // 传统方式：创建实现类
        class MyInterfaceImpl implements MyInterface {
            @Override
            public void doSomething() {
                System.out.println("传统实现类执行操作");
            }
        }
        MyInterface traditionalObj = new MyInterfaceImpl();
        traditionalObj.doSomething();

        // 匿名内部类方式
        MyInterface anonymousObj = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("匿名内部类执行操作");
            }
        };
        anonymousObj.doSomething();

        // Java 8+ 的 Lambda 表达式方式（接口为函数式接口）
        MyInterface lambdaObj = () -> System.out.println("Lambda 表达式执行操作");
        lambdaObj.doSomething();
    }
}

在上述代码中，使用匿名内部类避免了显式创建一个实现 MyInterface 的类，让代码更加简洁。而 Java 8 引入的 Lambda 表达式进一步简化了匿名内部类在函数式接口场景下的写法。

• 继承抽象类或普通类时的简写：同理，当继承一个抽象类或者普通类，并且只需要使用一次该子类时，也可以使用匿名内部类。

abstract class MyAbstractClass {
    abstract void doWork();
}

public class AnonymousClassInheritance {
    public static void main(String[] args) {
        // 匿名内部类继承抽象类
        MyAbstractClass obj = new MyAbstractClass() {
            @Override
            void doWork() {
                System.out.println("匿名内部类继承抽象类执行工作");
            }
        };
        obj.doWork();
    }
}