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

匿名内部类

实例内部类

静态实例内部类

匿名内部类

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

代码演示：

<code>//匿名内部类

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 方法，并且在最后调用了该方法。

运行截图：

实例内部类

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

代码演示：

<code>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 修饰的成员。

这时就不报错了！

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

<code>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.重名成员 就可以在内部类中访问外部类的重名成员。

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

代码演示：

<code>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 修饰，因为静态内部类的实例化不依靠外部类的实例。

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