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

本文主要是介绍总结：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 {//特殊情况，否则不允许存在静态变量private static final String name = "inner";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. 非静态内部类里面不能存在静态成员，除非特static final连着一起修饰某个变量

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() {@Overridepublic 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));}
}

七·内部类与外部类的类加载联系：jvm遵循“懒加载”原则，能不加载就不加载

1. 单纯加载外部类，并不会触发内部类加载
2. 若是触发内部类加载，会先去加载外部类

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

1. 封装实现细节：

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

2. 逻辑相关性：

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

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

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

4. 多重继承模拟：

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

5. 线程和并发：

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

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

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

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

这篇关于总结：Java各种内部类与外部类的关系的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---