大白话拆解内部类Ⅱ

前言：书接上回，我们继续讲解内部类。

成员内部类：

1.1概述：

如果成员内部类中不使用外部类的非静态成员，那么通常将内部类声明为静态 内部类，否则声明为非静态内部类。

语法格式：

[修饰符] class 外部类{ 
[其他修饰符] [static] class 内部类{ 
} 
}

• 成员内部类作为类的成员的角色： 

和外部类不同，Inner class 还可以声明为private或protected；

可以调用外部类的结构。

Inner class 可以声明为static 的，但此时就不能再使用外层类的非static的 成员变量；

• 成员内部类作为类的角色： 

可以在内部定义属性、方法、构造器等结构

可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部 类的父类和父接口无关 可以声明为abstract类 ，因此可以被其它的内部类继承

可以声明为final的，表示不能被继承

编译以后生成OuterClass$InnerClass.class 字节码文件（也适用于局部内部类）

1.2三条规则，注意点

人话拆解  和  代码实例：

• 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式

• 成员内部类可以直接使用外部类的所有成员，包括私有的数据

• 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

1. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式：

这句话的意思是，如果要在外部类中访问成员内部类的成员，你需要先创建一个内部类的对象，然后通过这个对象来访问其成员变量或方法。你不能直接使用内部类的名字来访问它的成员，因为成员内部类依赖于外部类的实例。

public class OuterClass {
    // 成员内部类
    class InnerClass {
        int innerField = 10;
        
        void innerMethod() {
            System.out.println("Inner method called");
        }
    }

    // 外部类的方法
    public void outerMethod() {
        // 创建内部类的对象
        InnerClass innerObject = new InnerClass();
        
        // 通过内部类对象访问内部类的成员
        System.out.println(innerObject.innerField); // 输出: 10
        innerObject.innerMethod(); // 输出: Inner method called
    }

    public static void main(String[] args) {
        // 创建外部类的对象
        OuterClass outerObject = new OuterClass();
        
        // 调用外部类的方法
        outerObject.outerMethod();
    }
}

2. 成员内部类可以直接使用外部类的所有成员，包括私有的数据：

这句话说明了成员内部类拥有对外部类所有成员的完全访问权限，即使这些成员被声明为private。这是因为成员内部类与外部类之间有着紧密的关联，它们共享相同的命名空间。

public class OuterClass {
    private int outerPrivateField = 20;

    // 成员内部类
    class InnerClass {
        void accessOuterMembers() {
            // 直接访问外部类的私有成员
            System.out.println(outerPrivateField); // 输出: 20
        }
    }

    public static void main(String[] args) {
        OuterClass outerObject = new OuterClass();
        OuterClass.InnerClass innerObject = outerObject.new InnerClass();
        innerObject.accessOuterMembers();
    }
}

3. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的：

这句话是指，如果你想从外部类的静态上下文中（例如静态方法或静态初始化块）创建内部类的对象并访问其成员，那么内部类必须被声明为static，即静态内部类（也称为嵌套静态类）。静态内部类不依赖于外部类的实例，因此可以在没有外部类实例的情况下创建。

public class OuterClass {
    // 静态内部类
    static class StaticInnerClass {
        static int staticInnerField = 30;
        
        void staticInnerMethod() {
            System.out.println("Static inner method called");
        }
    }

    // 静态方法
    public static void staticOuterMethod() {
        // 可以直接创建静态内部类的对象
        StaticInnerClass staticInnerObject = new StaticInnerClass();
        
        // 访问静态内部类的成员
        System.out.println(staticInnerObject.staticInnerField); // 输出: 30
        staticInnerObject.staticInnerMethod(); // 输出: Static inner method called
        
        // 也可以直接访问静态内部类的静态成员
        System.out.println(StaticInnerClass.staticInnerField); // 输出: 30
    }

    public static void main(String[] args) {
        // 调用静态方法
        staticOuterMethod();
    }
}

1.3创建成员内部类对象

概述＋语法格式：

• 实例化静态内部类：

外部类名.静态内部类名 变量 = 外部类名.静态内部类名();

变量.非静态方法();

• 实例化非静态内部类：

外部类名 变量1 = new 外部类();

外部类名.非静态内部类名 变量2 = 变量1.new 非静态内部类名();

变量2.非静态方法();

人话拆解＋代码实例：

实例化静态内部类：

静态内部类是被static关键字修饰的内部类。由于它是静态的，所以它不依赖于外部类的实例。你可以直接通过外部类的名字来创建静态内部类的对象。

public class OuterClass {
    // 静态内部类
    static class StaticInnerClass {
        void display() {
            System.out.println("This is a static inner class method.");
        }
    }

    public static void main(String[] args) {
        // 1. 使用外部类名.静态内部类名 来创建静态内部类对象
        OuterClass.StaticInnerClass staticInnerObject = new OuterClass.StaticInnerClass();
        
        // 2. 调用静态内部类对象的非静态方法
        staticInnerObject.display(); // 输出: This is a static inner class method.
    }
}

人话拆解：

①我们定义了一个名为OuterClass的外部类。

②在OuterClass中，我们定义了一个名为StaticInnerClass的静态内部类。

③在main方法中，我们使用OuterClass.StaticInnerClass来创建了StaticInnerClass的一个实例staticInnerObject。

④然后我们调用了staticInnerObject的display方法，这会打印一条消息到控制台。

⑤因为StaticInnerClass是静态的，所以我们不需要创建OuterClass的实例就能创建StaticInnerClass的实例。

实例化非静态内部类：

非静态内部类（Non-static Inner Class）没有被static关键字修饰。它与外部类的实例紧密相关，因此在创建非静态内部类的对象时，必须先有一个外部类的实例。

public class OuterClass {
    // 非静态内部类
    class NonStaticInnerClass {
        void display() {
            System.out.println("This is a non-static inner class method.");
        }
    }

    public static void main(String[] args) {
        // 1. 先创建外部类的实例
        OuterClass outerObject = new OuterClass();
        
        // 2. 使用外部类的实例.new 非静态内部类名() 创建非静态内部类对象
        OuterClass.NonStaticInnerClass nonStaticInnerObject = outerObject.new NonStaticInnerClass();
        
        // 3. 调用非静态内部类对象的非静态方法
        nonStaticInnerObject.display(); // 输出: This is a non-static inner class method.
    }
}

人话拆解：

①我们同样定义了一个名为OuterClass的外部类。

②这次我们在OuterClass中定义了一个名为NonStaticInnerClass的非静态内部类。

③在main方法中，我们首先创建了OuterClass的一个实例outerObject。

④接着我们使用outerObject.new NonStaticInnerClass()来创建了NonStaticInnerClass的一个实例nonStaticInnerObject。注意这里我们需要先有outerObject才能创建NonStaticInnerClass的实例。

⑤最后我们调用了nonStaticInnerObject的display方法，这会打印另一条消息到控制台。

⑥因为NonStaticInnerClass是非静态的，所以我们需要一个OuterClass的实例才能创建NonStaticInnerClass的实例。

好，小编今天分享的内容就暂时到这里，我们下次继续！！！

局部内部类：