Java-内部类（成员内部类、局部内部类、静态内部类、匿名内部类）

Bro_cat

于 2024-08-28 19:50:00 发布

阅读量897

点赞数 8

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Broken_x/article/details/141647843

版权

Java 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

在Java中，内部类是指在一个类的内部定义的类。内部类可以分为几种不同的类型，包括匿名内部类、静态内部类、成员内部类和局部内部类。每种内部类都有其特定的用途和特性。

在了解这些内部类时，我们得先知道什么是静态？什么是成员？

什么是成员：

在Java中，成员通常指的是类的属性（字段）和方法。成员可以是静态的（使用static修饰）或非静态的。静态成员属于类，而非静态成员属于类的实例。

什么是静态：

在Java中，"静态"（static）是一个关键字，用于修饰类的成员（如变量、方法、代码块和嵌套类）。静态成员属于类本身，而不是类的实例。这意味着无论创建多少个类的实例，静态成员只有一份副本，并且可以通过类名直接访问，而不需要创建类的实例。

匿名内部类：

匿名内部类是一种没有名字的内部类，通常用于实现接口或继承类，并且只使用一次。匿名内部类通常用于简化代码，特别是在需要创建一个只使用一次的类的实例时。匿名内部类不能有构造器，因为它们没有名字。

// 定义一个接口
interface GreetingService {
    void sayHello(String name);
}

public class AnonymousInnerClassExample {
    public static void main(String[] args) {
        // 使用匿名内部类实现GreetingService接口
        GreetingService greetingService = new GreetingService() {
            @Override
            public void sayHello(String name) {
                System.out.println("Hello, " + name);
            }
        };

        // 调用匿名内部类的方法
        greetingService.sayHello("World");
    }
}

注意事项：

匿名内部类通常用于一次性实现接口或继承类。
匿名内部类不能有构造器。
匿名内部类可以访问外部类的成员变量和方法。

静态内部类：

静态内部类是使用static关键字修饰的内部类。与非静态内部类不同，静态内部类不依赖于外部类的实例，可以直接通过外部类名访问。静态内部类只能访问外部类的静态成员，不能访问非静态成员。

public class StaticInnerClassExample {
    private static String outerStaticField = "Outer Static Field";

    // 静态内部类
    static class StaticInner {
        public void display() {
            System.out.println("Accessing outer static field: " + outerStaticField);
        }
    }

    public static void main(String[] args) {
        // 创建静态内部类的实例
        StaticInnerClassExample.StaticInner inner = new StaticInnerClassExample.StaticInner();
        inner.display();
    }
}

注意事项：

静态内部类不依赖于外部类的实例，可以直接通过外部类名访问。
静态内部类只能访问外部类的静态成员。
静态内部类可以有静态成员和非静态成员。

成员内部类：

成员内部类是定义在外部类的成员位置上的内部类，没有使用static修饰。成员内部类可以访问外部类的所有成员（包括私有成员），但外部类要访问成员内部类的成员时，必须先创建成员内部类的对象。

这个听起来可能有点抽象不太好理解，没关系，我们看代码

public class MemberInnerClassExample {
    private String outerField = "Outer Field";

    // 成员内部类
    class MemberInner {
        public void display() {
            System.out.println("Accessing outer field: " + outerField);
        }
    }

    public static void main(String[] args) {
        // 创建外部类的实例
        MemberInnerClassExample outer = new MemberInnerClassExample();
        // 创建成员内部类的实例
        MemberInnerClassExample.MemberInner inner = outer.new MemberInner();
        inner.display();
    }
}

这里的成员内部类就是 MemberInner 这个类，没有使用static修饰，它所对应的外部类就是MemberInnerClassExample ，也就是说，这个成员内部类 MemberInner 可以直接访问 MemberInnerClassExample的所有成员（属性以及方法），私有的也可以访问，而外部类想要访问内部类的成员时，需要先创建这个内部类所对应得实例才能进行访问

注意事项：

成员内部类可以访问外部类的所有成员，包括私有成员。
外部类要访问成员内部类的成员时，必须先创建成员内部类的对象。
成员内部类不能有静态成员，除非是常量。

局部内部类：

局部内部类是定义在方法或代码块内部的类，其作用域仅限于该方法或代码块。局部内部类不能有访问修饰符，但可以访问外部类的成员和当前代码块内的常量。

public class LocalInnerClassExample {
    private String outerField = "Outer Field";

    public void outerMethod() {
        final int localVar = 10; // 局部变量，必须是final或effectively final

        // 局部内部类
        class LocalInner {
            public void display() {
                System.out.println("Accessing outer field: " + outerField);
                System.out.println("Accessing local variable: " + localVar);
            }
        }

        // 创建局部内部类的实例并调用其方法
        LocalInner inner = new LocalInner();
        inner.display();
    }

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

注意事项

作用域限制：局部内部类的作用域仅限于定义它的方法或代码块。
访问权限：局部内部类不能有访问修饰符（如public、private、protected）。
访问外部成员：局部内部类可以访问外部类的所有成员，包括私有成员。
访问局部变量：局部内部类只能访问方法中的final或effectively final的局部变量。
实例化限制：局部内部类只能在定义它的方法或代码块内实例化。

最后再说一下和静态内部类比较容易混淆的一个概念

静态代码块：

静态代码块是使用static关键字定义的代码块，它在类加载时执行，并且只执行一次。静态代码块通常用于初始化静态变量或执行一些静态初始化操作。

public class StaticBlockExample {
    static {
        System.out.println("Static block executed");
    }

    public static void main(String[] args) {
        System.out.println("Main method executed");
    }
}