Java 面向对象 内部类

1、Java 内部类(成员内部类)

在Java中，也可以嵌套类（类中的一个类）。嵌套类的目的是对属于在一起的类进行区分，这使的代码更具可读性和可维护性。也可以称为成员内部类，是最普通的内部类。它的定义为位于另一个类的内部

要访问内部类，请创建外部类的对象，然后创建内部类的对象：

例如：

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}
class OuterClass {
  int x = 10;

  class InnerClass {
    int y = 5;
  }
}
// 输出 15 (5 + 10)

2、私有内部类

与一般的类不同，内部类可以是private或protected。如果不希望外部对象访问内部类，可以将该类声明为private。

例如：

如果尝试从外部类（MyMainClass）访问私有内部类，则会发生错误：

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);
  }
}
class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

3、静态内部类

静态内部类是用 static 修饰的，它与外部类的实例无关。静态内部类只能访问外部类的静态成员。

例如：

public class Main {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}
class OuterClass {
  int x = 10;

  static class InnerClass {
    int y = 5;
  }
}
// 输出 5

注意：就像static属性和方法一样，static内部类无法访问外部类的成员。

4、从内部类中访问外部类

内部类的优点之一是，它们可以访问外部类的属性和方法。

例如：

public class Main {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.myInnerMethod());
  }
}
class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}
// 输出 10

5、局部内部类

部内部类定义在方法内，通常在方法内部创建并使用。它只能在方法内部访问局部变量，但这些局部变量必须是 final 或者是“有效最终变量”（即在初始化后不会改变的变量）。

例如，

public class Man{
    public Man(){         
    }    
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}
class People{
    public People() {     
    }
} 

6、匿名内部类

匿名内部类没有类名，通常在实例化的时候直接定义，并且可以实现接口或继承类。它们通常用于需要短小、一次性的实现，比如事件监听，

class OuterClass {
    public void method() {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Inner Class");
            }
        };
        r.run();  // 输出：Anonymous Inner Class
    }
}

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

7、使用内部类的好处

1）每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整。

2）方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

3）方便编写事件驱动程序。

4）方便编写线程代码。