总结：Java各种内部类与外部类的关系

一·权限修饰符：影响所修饰代码，能不能被其他地方代码引用，不同权限修饰符，影响的范围不一样

1.私有(private)：

修饰的代码，只能够在代码所属类里面，任意地方引用

2. 默认(package-private)：

修饰的代码，只能够在代码类所属包下面的所有类里面，任意地方引用

3.受保护(protected)：

修饰的代码，只能够在本类以及所有子类里面，无论子类在哪个包下，任意地方引用

4.公共(public)：

修饰的代码，能够在所有类里面，任意地方引用

二·static关键字：影响所修饰代码，在类加载的时候执行顺序；static修饰代码比非static修饰代码先加载执行；且static修饰的代码是被该类的所有对象实例共享

三·final关键字：影响所修饰代码保持不变

1. 修饰类：当一个类被声明为 final 时，意味着这个类不能被其他类继承。这样做的目的是为了保护类的设计完整性或者防止误用
2. 修饰方法：如果一个方法被声明为 final，那么该方法不能在其子类中被重写（override）。
3. 修饰变量：当 final 关键字修饰实例变量（成员变量）时，该变量必须在声明时初始化或者在构造函数中赋值，一旦赋值后就无法更改其引用指向的对象。final经常用于创建常量，尤其是在静态上下文中。

四·什么是外部类？

1. 一个个普通独立类就是外部类，外部类只能使用两种权限修饰符（缺省、public），以及final修饰符，不能使用static修饰

五·什么是内部类？

1.概念：嵌套在外部类里面的类，就是内部类

2.分类：静态内部类、普通内部类、局部内部类、匿名内部类

六·各种内部类与外部类之间的联系

1.静态内部类：

1. 示例代码：

//外部类
public class OuterClass {
    public static void main(String[] args) {
        // 创建静态内部类实例
        StaticNestedClass nested = new StaticNestedClass();
        nested.displayMessage();
    }

    // 静态内部类定义
    public static class StaticNestedClass {
        private String message = "Hello from Static Nested Class";

        // 公共方法用于显示消息
        public void displayMessage() {
            System.out.println(message);
        }
    }
}

2. 静态内部类里面可以存在静态、非静态成员
3. 静态内部类与外部类的联系：

• 3-1 如果是静态内部类的静态成员，外部类可以直接通过“外部类名.内部类名.静态成员”来访问。

//调用内部类静态成员示例：
System.out.println(OuterClass.StaticNestedClass.staticField);
  
OuterClass.StaticNestedClass.静态成员

• 3-2 如果是静态内部类的非静态成员，外部类则需要先创建静态内部类的对象，再通过这个对象去访问。

//创建静态内部类对象示例：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
inner.非静态成员

• 3-3 外部类可以访问内部类的各种权限级别成员
• 3-4 静态内部类可以访问外部类的所有静态成员，包括私有（private）、默认（package-private）、受保护（protected）和公共（public）级别的成员变量和方法。但它不能直接访问外部类的实例成员（非静态字段或方法），因为静态内部类不与任何外部类的实例关联。

2.普通内部类：

1. 示例代码：

//外部类
public class OuterClass {
    private String outerMessage = "Hello from Outer Class";

    // 普通内部类定义
    public class InnerClass {
        public void displayOuterMessage() {
            System.out.println(outerMessage);  // 直接访问外部类的字段
        }
    }

    public void createAndUseInnerClass() {
        // 创建并使用普通内部类的实例
        InnerClass inner = new InnerClass();
        inner.displayOuterMessage();
    }

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

2. 非静态内部类里面不能存在静态成员
3. 普通内部类与外部类的联系：

• 3-1 普通内部类的所有成员（只有非静态），外部类都不能直接访问。必须先创建一个外部类的对象，然后通过这个外部类对象创建内部类的对象，最后通过这个内部类对象去访问其所有成员。

//创建非静态内部类对象示例：
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.非静态成员

• 3-2 外部类可以访问内部类的各种权限级别成员

• 3-3 非静态内部类可以访问外部类的所有静态、非静态成员，包括私有（private）、默认（package-private）、受保护（protected）和公共（public）级别的成员变量和方法。

3.局部内部类：几乎很少使用

1. 示例代码：

public class LocalInnerClassExample {
    public void someMethod() {
        // 局部内部类定义在方法内
        class LocalClass {
            String message = "Hello from Local Inner Class";

            void displayMessage() {
                System.out.println(message);
            }
        }

        // 创建并使用局部内部类的实例
        LocalClass local = new LocalClass();
        local.displayMessage();
    }

    public static void main(String[] args) {
        LocalInnerClassExample example = new LocalInnerClassExample();
        example.someMethod();  // 在外部类的方法中调用，创建并使用局部内部类
    }
}

4.匿名内部类：可以快速创建实现类

1. 示例代码：

import java.util.ArrayList;
import java.util.List;

public class AnonymousInnerClassExample {
    public static void main(String[] args) {
        // 使用匿名内部类实现Runnable接口
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Running in anonymous inner class");
            }
        });

        thread.start();

        // 或者使用匿名内部类继承自一个抽象类或具体类
        List<String> list = new ArrayList<String>() {{
            add("Item added by anonymous inner class");
        }};

        System.out.println(list.get(0));
    }
}

七·内部类应用的开发场景：

1. 封装实现细节：

• 当一个类的实现依赖于另一个类，且这个类只被外部类使用时，将该类设计为内部类可以隐藏实现细节，提高封装性。这有助于减少代码对外暴露的接口，降低耦合度。

2. 逻辑相关性：

• 当几个类之间有较强的逻辑关联，并且希望将它们组织在一起时，可以使用内部类来表达这种关系。这样不仅可以保持代码结构清晰，还能方便地访问外部类的私有属性和方法。

3. 匿名内部类与函数式编程：

• 在需要实现单次使用的、简洁的类实例时（例如事件监听器、回调函数等），可以使用匿名内部类或Lambda表达式简化代码编写。

4. 多重继承模拟：

• 在Java中，由于不支持多继承，但可以通过实现多个接口解决部分问题。若需从多个抽象类派生，则可以创建一个内部类并继承这些抽象类，然后让外部类持有这个内部类的引用，间接实现类似多重继承的效果。

5. 线程和并发：

• 内部类可用于实现线程类，尤其是当每个线程执行的任务与外部类的方法紧密相关时，通过定义Runnable或Callable的匿名内部类来启动新线程，使代码更紧凑。

6. 静态嵌套类（静态内部类）：

• 当某个类只是逻辑上属于另一个类，但实际上并不依赖于外部类的实例时，可将其设计为静态内部类。这样的类可以独立于外部类实例存在，并且可以包含静态成员，适合用来组织工具类或者枚举类等。

总之，选择使用内部类主要考虑的是代码组织、封装性以及逻辑关联性等因素，以提升代码质量和可维护性。