Java中内部类的分类及访问权限控制

java内部类分为四种类型及使用场景：1.成员内部类依赖外部类实例，可访问所有成员；2.静态内部类不依赖实例，只能访问静态成员；3.局部内部类定义在方法中，作用域受限；4.匿名内部类用于一次性的类实现。内部类会持有外部类引用，可能导致内存泄漏，解决方式包括使用静态内部类、控制生命周期或手动置空。内部类适合紧密耦合的封装场景，组合则适用于需要灵活解耦的设计。合理使用内部类不会显著影响性能，但过多使用可能增加类加载开销。

内部类是Java中一个挺有意思的特性，它允许你在一个类里面定义另一个类。这东西用好了，代码结构会更清晰，封装性也更强。但用不好，也容易把自己绕进去。

解决方案

Java中的内部类主要分为四种：成员内部类、静态内部类、局部内部类和匿名内部类。每种内部类都有其特定的用途和访问权限控制。

立即学习“Java免费学习笔记（深入）”；

• 成员内部类： 就像一个普通的成员变量一样，它依赖于外部类的实例而存在。这意味着，只有先创建了外部类的实例，才能创建成员内部类的实例。成员内部类可以直接访问外部类的所有成员，包括私有成员。

  class Outer {
      private int outerVar = 10;
  
      class Inner {
          public void printOuterVar() {
              System.out.println("Outer var: " + outerVar);
          }
      }
  
      public void createInner() {
          Inner inner = new Inner();
          inner.printOuterVar();
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Outer outer = new Outer();
          outer.createInner();
  
          // 另一种创建内部类的方式（需要先有外部类实例）
          Outer.Inner inner = outer.new Inner();
          inner.printOuterVar();
      }
  }

  登录后复制

  注意 outer.new Inner() 这种创建内部类实例的方式，必须先有外部类实例。

• 静态内部类： 顾名思义，它是用 static 关键字修饰的内部类。静态内部类不依赖于外部类的实例，可以直接通过外部类名访问。它只能访问外部类的静态成员。

  class Outer {
      private static int outerStaticVar = 20;
  
      static class Inner {
          public void printOuterVar() {
              System.out.println("Outer static var: " + outerStaticVar);
          }
      }
  
      public static void createInner() {
          Inner inner = new Inner();
          inner.printOuterVar();
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Outer.createInner(); // 不需要外部类实例
          Outer.Inner inner = new Outer.Inner(); // 直接通过外部类名访问
          inner.printOuterVar();
      }
  }

  登录后复制

  静态内部类有点像外部类的一个静态成员，但它仍然是一个类，可以拥有自己的成员变量和方法。

• 局部内部类： 定义在方法或代码块中的类。它的作用范围仅限于该方法或代码块。局部内部类不能使用访问修饰符（如 public、private、protected），因为它不是外部类的成员。

  class Outer {
      public void doSomething() {
          class Inner {
              public void printMessage() {
                  System.out.println("Message from local inner class");
              }
          }
  
          Inner inner = new Inner();
          inner.printMessage();
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Outer outer = new Outer();
          outer.doSomething();
      }
  }

  登录后复制

  局部内部类主要用于封装一些只在特定方法中使用的逻辑。

• 匿名内部类： 没有名字的内部类。通常用于创建只需要使用一次的类。匿名内部类必须继承一个类或实现一个接口。

  interface MyInterface {
      void doSomething();
  }
  
  public class Main {
      public static void main(String[] args) {
          MyInterface myInterface = new MyInterface() {
              @Override
              public void doSomething() {
                  System.out.println("Doing something from anonymous inner class");
              }
          };
  
          myInterface.doSomething();
      }
  }

  登录后复制

  匿名内部类经常与 Lambda 表达式一起使用，可以简化代码。

内部类如何影响Java程序的性能？

内部类本身并不会直接导致性能问题，关键在于如何使用。过多的内部类可能会增加类的数量，从而增加类加载的开销。另外，成员内部类会持有外部类的引用，如果内部类的生命周期比外部类长，可能会导致内存泄漏。匿名内部类如果使用不当，可能会生成大量的类文件，也会影响性能。所以，需要根据实际情况权衡使用内部类的好处和潜在的性能影响。

内部类和组合有什么区别？什么时候应该使用哪种方式？

内部类和组合都是实现代码重用和封装的方式。内部类更侧重于封装，它允许内部类直接访问外部类的成员，可以实现更紧密的耦合。组合更侧重于解耦，通过接口或抽象类定义组件之间的关系，可以实现更灵活的扩展和维护。

什么时候应该使用内部类呢？当一个类只会被另一个类使用，并且需要访问外部类的私有成员时，可以考虑使用内部类。例如，GUI编程中的事件监听器，或者数据结构中的迭代器。什么时候应该使用组合呢？当需要实现更灵活的组件组合，并且组件之间不需要紧密的耦合时，应该使用组合。例如，设计一个图形编辑器，可以使用组合的方式将不同的图形组件组合在一起。

如何避免内部类导致的内存泄漏？

内存泄漏通常发生在成员内部类中，因为成员内部类会持有外部类的引用。如果内部类的生命周期比外部类长，可能会导致外部类无法被垃圾回收。避免内存泄漏的方法有以下几种：

1. 尽量使用静态内部类，因为静态内部类不持有外部类的引用。
2. 如果必须使用成员内部类，确保内部类的生命周期不会超过外部类。
3. 在不再需要内部类时，手动将其设置为 null，以便垃圾回收器可以回收它。
4. 使用弱引用（WeakReference）来持有外部类的引用，这样即使内部类持有外部类的引用，外部类也可以被垃圾回收。

以上就是Java中内部类的分类及访问权限控制的详细内容，更多请关注php中文网其它相关文章！