内部类是什么呢？

Java内部类，是定义在一个类内部的类。在Java编程语言中，内部类是一个十分独特且强大的结构，它允许在一个外部类的内部定义另一个类。这种结构不仅增加了代码的封装性，还提供了访问外部类的私有成员的能力，从而在某些情况下简化了代码设计。

内部类的概念：

内部类是指在一个外部类的内部定义的类。它可以访问包含它的外部类的所有成员，包括私有成员。

内部类可以定义为非静态或静态。非静态内部类持有外部类的引用，而静态内部类则不需要。

内部类的分类：

成员内部类、局部内部类、静态内部类、匿名内部类

一、成员内部类

概念

成员内部类（Member Inner Class）是指在一个外部类的内部定义的类。成员内部类和外部类有着紧密的联系，能够访问外部类的所有成员，包括私有成员。成员内部类通常用来逻辑上关联外部类，并且可以更好地封装数据和行为。

特点

访问权限：成员内部类可以访问外部类的所有成员（包括私有成员）。
与外部类实例的关联：成员内部类的实例与创建它的外部类实例相关联。要创建成员内部类的实例，必须首先创建一个外部类的实例。
外部类引用：成员内部类可以使用 OuterClass.this来引用外部类的实例。

public class OuterClass {
    private String name = "外部类";
    public void printName() {
        System.out.println("外部类名称： " + name);
    }
    class InnerClass {
        public void accessOuterClass() {
            System.out.println("内部类访问外部类成员：");
            System.out.println("外部类名称： " + OuterClass.this.name);
            OuterClass.this.printName();
        }
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.accessOuterClass();
    }
}

在这个例子中，InnerClass通过OuterClass.this.name和OuterClass.this.printName()访问了外部类OuterClass的成员变量和方法。

实例化方式：要实例化成员内部类，必须先实例化外部类，然后使用外部类的实例来实例化内部类。

成员内部类是定义在外部类中的类，并且与外部类的实例相关联。它们可以访问外部类的所有成员，包括私有成员。使用成员内部类可以使相关类之间的关系更加紧密，并且有助于封装和组织代码。

代码实现

public class OuterClass {
    private String outerField = "Outer Field";
   
    // 成员内部类
    class InnerClass {
        private String innerField = "Inner Field";
       
        // 内部类的方法
        public void display() {
            // 访问外部类的成员
            System.out.println("Outer Field: " + outerField);
            // 访问内部类的成员
            System.out.println("Inner Field: " + innerField);
        }
    }
   
    // 外部类的方法，用于创建和使用内部类的实例
    public void useInnerClass() {
        InnerClass inner = new InnerClass();
        inner.display();
    }
   
    public static void main(String[] args) {
        // 创建外部类的实例
        OuterClass outer = new OuterClass();
        // 使用外部类的方法来使用内部类
        outer.useInnerClass();
       
        // 直接创建内部类的实例
        OuterClass.InnerClass innerDirect = outer.new InnerClass();
        innerDirect.display();
    }
}

二、局部内部类

概念

局部内部类（Local Inner Class）是定义在一个方法、构造器或代码块中的类。局部内部类只能在其定义的范围内使用，并且通常用于封装仅在该方法中需要的逻辑。局部内部类可以访问外部类的成员变量和方法，但外部类不能直接访问局部内部类的成员。

特点

局部内部类只能访问外部类的 final 变量或者实际上不变的变量。
局部内部类可以直接访问外部类的成员，包括私有成员。
局部内部类不能含有 static 的变量和方法。

注意事项

局部内部类的定义必须在方法内部，不能在类的其他部分定义。
局部内部类的对象创建时机是在方法调用时，随方法执行完毕而销毁。

代码实现

// 定义一个名为OuterClass的外部类
public class OuterClass {
    // 定义一个私有成员变量name，并初始化为"外部类"
    private String name = "外部类";
    // 定义一个公共方法printName()，用于打印name的值
    public void printName() {
        System.out.println("外部类名称： " + name);
    }
    // 定义一个公共方法method()
    public void method() {
        // 在method()方法中定义一个局部内部类LocalInnerClass
        class LocalInnerClass {
            // 定义一个私有成员变量innerName，并初始化为"局部内部类"
            private String innerName = "局部内部类";
            // 定义一个公共方法printInnerName()，用于打印innerName和访问外部类成员
            public void printInnerName() {
                System.out.println("局部内部类名称： " + innerName);
                System.out.println("访问外部类成员： " + name);
                printName();
            }
        }
        // 创建LocalInnerClass的一个实例localInner
        LocalInnerClass localInner = new LocalInnerClass();
        // 调用localInner的printInnerName()方法
        localInner.printInnerName();
    }
    // 定义主方法main()
    public static void main(String[] args) {
        // 创建OuterClass的一个实例outer
        OuterClass outer = new OuterClass();
        // 调用outer的method()方法
        outer.method();
    }
}

这段代码定义了一个名为OuterClass的外部类，其中包含一个私有成员变量name和一个公共方法printName()。在method()方法中，定义了一个局部内部类LocalInnerClass，该类包含一个私有成员变量innerName和一个公共方法printInnerName()。在main()方法中，创建了OuterClass的一个实例outer，并调用其method()方法。

三、静态内部类

概念

静态内部类（Static Nested Class）是在外部类中使用 static 修饰符定义的内部类。与非静态内部类不同，静态内部类不需要外部类的实例即可创建。静态内部类通常用于外部类的逻辑分组，并且可以访问外部类的静态成员。静态内部类是定义在另一个类中的静态类。它类似于顶级类，但被嵌套在另一个类中。静态内部类不依赖于外部类的实例，可以直接创建。

特点

无需外部类实例：静态内部类的实例可以独立于外部类的实例创建。

访问外部类的静态成员：静态内部类只能访问外部类的静态成员（变量和方法），不能直接访问外部类的非静态成员。

类似于顶级类：静态内部类在许多方面类似于顶级类，但它们可以被嵌套在其他类中，用于逻辑分组。

注意事项

成员访问限制：静态内部类不能直接访问外部类的非静态成员。如果需要访问，可以通过外部类的实例来实现。

静态上下文：静态内部类本身是在静态上下文中定义的，因此它的所有直接成员（字段和方法）也必须是静态的，除非在实例方法中访问。

代码实现

public class OuterClass {
    private static String staticOuterField = "Static Outer Field";
    private String instanceOuterField = "Instance Outer Field";
    // 静态内部类
    public static class StaticInnerClass {
        private String innerField = "Inner Field";
        public void display() {
            // 访问外部类的静态成员
            System.out.println("Static Outer Field: " + staticOuterField);
            // 不能直接访问外部类的非静态成员
            // System.out.println("Instance Outer Field: " + instanceOuterField); // 错误
        }
        // 静态内部类中的静态方法
        public static void staticDisplay() {
            // 访问外部类的静态成员
            System.out.println("Static Outer Field: " + staticOuterField);
        }
    }
    public static void main(String[] args) {
        // 创建静态内部类的实例
        StaticInnerClass inner = new StaticInnerClass();
        inner.display();
        // 调用静态内部类的静态方法
        StaticInnerClass.staticDisplay();
    }
}

这段代码定义了一个名为OuterClass的外部类，其中包含一个静态成员变量staticOuterField和一个实例成员变量instanceOuterField。在OuterClass中还定义了一个静态内部类StaticInnerClass，该类包含一个成员变量innerField和两个方法display()和staticDisplay()。在main()方法中，创建了StaticInnerClass的一个实例inner，并调用了其display()方法和StaticInnerClass的静态方法staticDisplay()。

四、匿名内部类

概念

匿名内部类（Anonymous Inner Class）是没有名字的内部类，通常用于简化代码，只在某个特定场景下使用一次。匿名内部类可以用来继承一个类或实现一个接口。匿名内部类定义在方法、构造器或初始化块中，用于即时实例化一个对象。匿名内部类通常用于需要快速创建类的实例并覆盖其方法的情况。

特点

没有名字：匿名内部类没有名字，不能在其他地方引用或复用。

一次性使用：匿名内部类通常只在创建它的地方使用一次。

简化代码：匿名内部类可以直接定义在使用它们的地方，减少了定义新类的繁琐步骤。

可以继承一个类或实现一个接口：匿名内部类可以用来继承一个现有的类或实现一个接口。

注意事项

访问局部变量：匿名内部类可以访问包含它的作用域中的局部变量，但这些变量必须是 final 或有效 final。

构造器：匿名内部类没有构造器，可以通过初始化块来初始化实例变量。

限制：由于匿名内部类没有名字，不能在定义之外的其他地方引用或复用它们。

匿名内部类是一种简化代码的方式，用于即时创建类的实例并覆盖其方法。它没有名字，通常只在创建它的地方使用一次。匿名内部类可以继承一个类或实现一个接口，可以访问外部类的成员变量和包含它的局部变量（这些变量必须是 final 或有效 final）。匿名内部类在简化代码、封装临时逻辑方面非常有用。

代码实现

public class OuterClass {
    private String outerField = "Outer Field";
    public void outerMethod() {
        final String localVar = "Local Variable";  // 局部变量，必须是 final 或有效 final
        // 使用匿名内部类创建线程
        Thread thread = new Thread() {
            @Override
            public void run() {
                // 访问外部类的成员
                System.out.println("Outer Field: " + outerField);
                // 访问局部变量
                System.out.println("Local Variable: " + localVar);
            }
        };
        thread.start();
        // 使用匿名内部类实现接口
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 访问外部类的成员
                System.out.println("Outer Field: " + outerField);
                // 访问局部变量
                System.out.println("Local Variable: " + localVar);
            }
        };
        new Thread(runnable).start();
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();
    }
}

上述代码使用匿名内部类实现接口：

// 使用匿名内部类实现接口
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 访问外部类的成员
                System.out.println("Outer Field: " + outerField);
                // 访问局部变量
                System.out.println("Local Variable: " + localVar);
            }
        };
        new Thread(runnable).start();

匿名内部类：这里定义了一个实现 Runnable 接口的匿名内部类，并重写了其 run 方法。该匿名内部类在创建的同时定义并实例化。

访问外部类成员：匿名内部类能够直接访问外部类的私有成员 outerField。

访问局部变量：匿名内部类能够访问方法内的局部变量 localVar，因为它是 final 的。

启动线程：创建一个新的 Thread 实例，并将 Runnable 类型的匿名内部类实例 runnable 传递给 Thread 构造器，随后调用 start 方法启动线程，这会调用 run 方法。

总结

成员内部类适合在需要访问外部类的实例成员时使用，必须通过外部类的实例创建。

局部内部类适合在方法内部使用，需要局部类逻辑封装时使用，局部变量需 final。

静态内部类适合在不需要外部类实例的情况下使用，可以直接访问外部类的静态成员。

匿名内部类适合临时实现一个类或接口，通常用于简化代码和一次性使用的场景。

每种内部类都有其特定的使用场景和限制，合理使用内部类可以使代码更加简洁和具有层次性。

希望本文对你理解和使用Java内部类提供了帮助。如果你有任何问题或建议，请随时留言。

【Java基础】内部类（成员内部类、局部内部类、静态内部类、匿名内部类）

一、成员内部类

概念

特点

代码实现

二、局部内部类

概念

特点

注意事项

代码实现

三、静态内部类

概念

特点

注意事项

代码实现

四、匿名内部类

概念

特点

注意事项

代码实现

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【Java基础】 内部类 （成员内部类、局部内部类、静态内部类、匿名内部类）

一、成员内部类

概念

特点

代码实现

二、局部内部类

概念

特点

注意事项

代码实现

三、静态内部类

概念

特点

注意事项

代码实现

四、匿名内部类

概念

特点

注意事项

代码实现

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【Java基础】内部类（成员内部类、局部内部类、静态内部类、匿名内部类）