认识内部类：Java中内部类分如下三种

匿名内部类

实例内部类

静态实例内部类

匿名内部类

匿名内部类顾名思义就是在创建的时候不用赋予名字。

代码演示：

//匿名内部类 interface IA{     void test(); } public class Main{     public static void main(String[] args) {         new IA(){             @Override             public void test() {                 System.out.println("hallo World");             }         }.test();     } }

我们定义了一个接口 IA 接着我们在 Main 方法中实例化了该接口，但没有用引用来接收该接口，这就表示内部类，接着我们在内部类中重写了 test 方法，并且在最后调用了该方法。

运行截图：

实例内部类

我们在一个类中定义的变量和方法都叫做实例成员和实例方法，顾名思义定义在一个类中的类就被称作为实例内部类。

代码演示：

class OutClass{     public int data1 = 1;     private int data2 = 2;     public static int data3 = 3;     class InnerClass{         public int data4 = 4;         private int data5 = 5;          public void test(){             System.out.println("内部类的test方法");         }     }      public void test(){         System.out.println("外部类的test方法");     } }  public class Main{     public static void main(String[] args) {         //获取实例内部类时，要依赖外部类         OutClass outclass = new OutClass();         OutClass.InnerClass innerclass = outclass.new InnerClass();         OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();         innerclass2.test();         innerclass.test();     } }

我们在 OutClass 类中定义了另外一个类 InnerClass ，在内部类中同样也可以拥有成员权限修饰符修饰的变量和方法。

既然定义了一个类，那么必然就可以实例化，这里我们实例化内部类有两种方法：

//获取实例内部类时，要依赖外部类 //第一种 OutClass outclass = new OutClass(); OutClass.InnerClass innerclass = outclass.new InnerClass(); //第二种 OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();

我们在实例化内部类的时候必须要依靠外部类，也就是说我们先要实例化外部类，再实例化内部类。

上述代码的运行截图：

我们可以看出两种实例化都可行。

在内部类中我们能否有 static 修饰的成员？我们在编译器中试试看

我们发现报错了，为什么呢？我们知道被 static 修饰的成员就会变得不依靠实例，但是我们在实例化内部类的时候必须要依靠外部类的实例，很明显冲突了！

但是我们可以有 final 修饰的成员。

这时就不报错了！

如果在外部类和内部类中有同名的成员，那么如何在内部类中访问外部类的成员。

class OutClass{     public int data1 = 1;     private int data2 = 2;     public static int data3 = 3;     class InnerClass{         public int data4 = 4;         private int data5 = 5;         public int data1 = 6;          public void test(){             System.out.println(OutClass.this.data1);         }     }      public void test(){      } }  public class Main{     public static void main(String[] args) {         OutClass.InnerClass innerclass2 = new OutClass().new InnerClass();        innerclass2.test();     } }

运行截图：

使用 外部类类名.this.重名成员 就可以在内部类中访问外部类的重名成员。

在外部类中是不能直接访问内部类中的成员，如果要访问就必须要实例化内部类。

代码演示：

class OutClass{     public int data1 = 1;     private int data2 = 2;     public static int data3 = 3;     class InnerClass{         public int data4 = 4;         private int data5 = 5;         public int data1 = 6;          public void test(){             System.out.println(OutClass.this.data1);         }     }      public void test(){         InnerClass innerclass = new InnerClass();         System.out.println(innerclass.data4);     } }  public class Main{     public static void main(String[] args) {         OutClass outclass = new OutClass();         outclass.test();     } }

静态实例内部类

代码示例：

class OutClass{     private int data1 = 1;     public int data2 = 2;     public static int data3 = 3;      static class InnerClass{         private int data4 = 4;         public int data5 = 5;         public static int data6 = 6;     } } public class Main{     public static void main(String[] args) {         OutClass.InnerClass innerclass = new OutClass.InnerClass();         System.out.println(innerclass.data5);     } }

运行结果：

我们在实例化静态内部类的时候就不需要依靠外部内部类的实例了，就变得方便了许多。

我们可以看到在静态内部类中定义成员变量用了 static 修饰，是的静态内部类可以用 static 修饰，因为静态内部类的实例化不依靠外部类的实例。

在静态内部类中是无法直接访问外部类的成员，并且外部类也无法直接访问静态内部类的成员，都必须借助实例化才能访问。