class Outer {
      private int age = 20;
      
      class Inner {
          public void show() {
              System.out.println(age);
          }
      }
}


class Test {
      public static void main(String[] ages) {
      Outer.Inner oi = new Outer().new Inner();
          oi.show();
      }
  }

private修饰内部类

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用

class Outer {
      private class Inner {
          public void show() {
              System.out.println(“密码备份文件”);
          }
      }
      //使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
      public Inner getInner() {
          return new Inner();
      }
     }

  public static void main(String[] args) {
         Outer outer = new Outer();
         Outer.Inner inner = outer.getInner();              inner.show();
   }

静态内部类

这种被static坐修饰的内部类,按位置分,属于成员内部类,但也可以称为静态内部类,也常叫嵌套内部类.不能使用外部类的非static成员变量和成员方法

public class Outter {
      int age = 10;
      static int  age2 = 20;
      public Outter() {        
      }
       
      static class Inner {
          public void method() {
              System.out.println(age);//错误
              System.out.println(age2);//正确
          }
      }
  }


  public class Test {
      public static void main(String[] args)  {
          Outter.Inner inner = new Outter.Inner();
          inner.method();
      }
  }

局部内部类

局部内部类–就是定义在一个方法或者一个作用域里面的类

特点:主要是作用域发生了变化，只能在自身所在方法和属性中被使用

class Outer {
      private int age = 20;
      public void method() {
          final int age2 = 30;
          class Inner {
              public void show() {     
          System.out.println(age);
                  //从内部类中访问方法内变量age2，需要将变量声明为最终类型。
                  System.out.println(age2);
              }
          }
                    Inner i = new Inner();//在method()方法中创建局部内部类对象
                              i.show();
      }
  }

匿名内部类

匿名内部类
一个没有名字的类，是内部类的简化写法

interface Inner {
      public abstract void show();
}  
 
  class Outer {
      public void method(){
          new Inner() {
              public void show() {
                  System.out.println("HelloWorld");
              }
          }.show();
      }
  }



 class Test {
      public static void main(String[] args)  {
          Outer o = new Outer();
                   o.method();
      }
  }

内部类的特点

内部类仍然是一个独立的类,在编译之后内部类会编译成独立的.class文件,但是前面冠以外部类的类名和$符号。
内部类不能用普通的方式访问,内部类是外部类的一个成员,因此内部类可以自由访问外部类的成员变量，无论是否为 private 的。
内部类声明成静态,就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量

内部类的意义

封装性,内部类只服务于所在的外部类.
实现多继承

儿子类爸爸类妈妈类
儿子内部1 继承爸爸类
儿子内部2 继承妈妈类

用匿名内部类实现回调功能

我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中，然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能

public interface Demo {
      void demoMethod();
  }
  
  public class MyDemo{
      public test(Demo demo){
          System.out.println("test method");
      }
}

-------------------------------------------------
 public static void main(String[] args) {
          MyDemo md = new MyDemo();
           md.test(new Demo){
              public void demoMethod(){
                  System.out.println("具体实现接口")
              }
          }
      }
  }

解决继承及实现接口出现同名方法的问题

编写一个接口 Demo  public interface Demo {
      void test();
  }
编写一个类 MyDemo  public class MyDemo {
      public void test() {
          System.out.println("父类的test方法");
      } 
  }
--------------------------------------------------

public class DemoTest extends MyDemo  {

      private class inner implements Demo {
          public void test() {
              System.out.println("接口的test方法");
          }
      }

     public Demo getIn() {
          return new inner();
      }
}