4.6 Java中内部类全解（静态内部类、匿名内部类）

最新推荐文章于 2024-10-31 15:56:11 发布

Argonaut_

最新推荐文章于 2024-10-31 15:56:11 发布

阅读量745

点赞数 24

分类专栏：从零开始的Java路程文章标签： java 开发语言静态内部类匿名内部类

本文链接：https://blog.csdn.net/Argonaut_/article/details/142602641

版权

从零开始的Java路程专栏收录该内容

51 篇文章 1 订阅

订阅专栏

文章目录

4.6.1 Java成员内部类
4.6.3 Java静态内部类
4.6.4 Java匿名内部类

4.6.1 Java成员内部类

在Java中，成员内部类（也称为非静态内部类）是定义在另一个类中的类。这种内部类可以访问外部类的所有成员，包括私有成员。

概念

成员内部类：定义在另一个类的内部，作为外部类的一个成员。
访问外部类的成员：可以直接访问外部类的属性和方法。
访问限制：不能被声明为static。

代码案例

// 外部类
class OuterClass {
    private String outerField = "Outer Field";

    // 成员内部类
    class InnerClass {
        private String innerField = "Inner Field";

        void display() {
            System.out.println("Inner Field: " + innerField);
            System.out.println("Outer Field: " + outerField);
        }
    }

    void createInnerClass() {
        InnerClass innerObject = new InnerClass();
        innerObject.display();
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        OuterClass outerObject = new OuterClass();
        outerObject.createInnerClass(); // 输出:
        // Inner Field: Inner Field
        // Outer Field: Outer Field
    }
}

在这个例子中，InnerClass是一个成员内部类，它可以直接访问外部类OuterClass的属性outerField。

流程图

下面是描述上述代码案例的流程图：

说明

定义外部类：首先定义一个OuterClass类。
定义成员内部类：在OuterClass类中定义一个成员内部类InnerClass。
访问外部类的成员：InnerClass可以直接访问OuterClass的属性outerField。
创建内部类对象：在OuterClass的createInnerClass方法中，创建一个InnerClass对象并调用其display方法。
测试：在TestInnerClass类中，创建一个OuterClass对象，并调用其createInnerClass方法。

成员内部类是定义在另一个类的内部的类，它可以访问外部类的所有成员，包括私有成员。这使得成员内部类在访问外部类的属性和方法时非常方便。

4.6.3 Java静态内部类

在Java中，静态内部类是定义在另一个类中的类，并且被声明为静态（static）。它可以不依赖于外部类的实例而存在，也就是说，它可以在没有外部类实例的情况下被创建和访问。

概念

静态内部类：定义在另一个类中，并且被声明为static的类。
独立于外部类：可以在没有外部类实例的情况下被创建。
访问限制：不能访问外部类的非静态成员。

代码案例

// 外部类
class OuterClass {
    private String outerField = "Outer Field";

    // 静态内部类
    static class StaticInnerClass {
        private String innerField = "Inner Field";

        void display() {
            System.out.println("Inner Field: " + innerField);
            // System.out.println("Outer Field: " + outerField); // 错误，无法访问外部类的非静态成员
        }
    }

    static void createStaticInnerClass() {
        StaticInnerClass innerObject = new StaticInnerClass();
        innerObject.display();
    }
}

public class TestStaticInnerClass {
    public static void main(String[] args) {
        // 不需要外部类的实例即可创建静态内部类对象
        OuterClass.StaticInnerClass innerObject = new OuterClass.StaticInnerClass();
        innerObject.display(); // 输出: Inner Field: Inner Field

        // 也可以通过外部类的实例来创建静态内部类对象，但这不是必须的
        OuterClass outerObject = new OuterClass();
        OuterClass.StaticInnerClass anotherInnerObject = outerObject.new StaticInnerClass();
        anotherInnerObject.display(); // 输出: Inner Field: Inner Field

        // 调用静态方法来创建静态内部类对象
        OuterClass.createStaticInnerClass();
    }
}

在这个例子中，StaticInnerClass是一个静态内部类，它可以直接访问外部类OuterClass的静态成员，但不能访问非静态成员。

流程图

下面是描述上述代码案例的流程图：

说明

定义外部类：首先定义一个OuterClass类。
定义静态内部类：在OuterClass类中定义一个静态内部类StaticInnerClass。
访问限制：StaticInnerClass不能访问OuterClass的非静态成员。
创建静态内部类对象：可以在没有OuterClass实例的情况下创建StaticInnerClass对象。
测试：在TestStaticInnerClass类中，通过OuterClass类直接创建StaticInnerClass对象，并调用其display方法。

静态内部类在设计模式中很有用，特别是当内部类不需要访问外部类的实例成员时。此外，静态内部类可以定义静态成员，这使得它们可以完全独立于外部类的任何实例。

4.6.4 Java匿名内部类

在Java中，匿名内部类是没有名字的内部类，通常用于创建需要单次使用的类，或者在需要时快速实现某个接口或抽象类的方法。匿名内部类在定义时是匿名的，并且大多数情况下是直接在方法中定义和使用的。

概念

匿名：没有类名。
内部类：定义在另一个类或方法内部。
单用类：通常只使用一次。

代码案例

// 定义一个接口
interface Animal {
    void makeSound();
}

public class TestAnonymousInnerClass {
    public static void main(String[] args) {
        // 创建匿名内部类对象
        Animal myAnimal = new Animal() {
            @Override
            public void makeSound() {
                System.out.println("Animal makes a sound");
            }
        };
        myAnimal.makeSound(); // 输出: Animal makes a sound
    }

    void testInterface() {
        // 在方法中定义并使用匿名内部类
        Animal myDog = new Animal() {
            @Override
            public void makeSound() {
                System.out.println("Dog barks");
            }
        };
        myDog.makeSound(); // 输出: Dog barks
    }
}