前言：

由于写内部类代码中运用了很多static的知识，所以在代码中书写了大量通俗易懂的关于static使用方法，以及为什么会报错，该怎么调整。耐心看完不仅能熟悉内部类，还会对static有不一样的收获。

一、什么是内部类

内部类 就是 写在外部类内的类。

比如：下列代码中，OutClass是外部类，InnerClass是内部类。

public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类public class InnerClass1{}
// 成员位置定义：被static修饰 ---> 静态内部类static class InnerClass2{}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用class InnerClass5{}
}
}

1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类 

二、实例内部类

 定义：未被static修饰的成员内部类。

package demo;class OutClass{public int data1=1;private int data2=2;public static int data3=3;class InnerClass{public int data1=100;public int data4=4;private int data5=5;public static int data6=6;public void test(){System.out.println("InnerClass.test()");/*同个类（OutClass）里面，static修饰的变量可以使用，同时private修饰的也可以使用。*//*若外部类与内部类有同名的，则优先访问内部（就近原则）如果非要访问外部类，则添加-》外部类名.this.*/System.out.println("外部类data1："+OutClass.this.data1);System.out.println(data2);System.out.println(data3);System.out.println(data4);System.out.println(data5);System.out.println(data6);}}
}public class Test {public static void main(String[] args) {OutClass out=new OutClass();/* InnerClass可以理解为OutClass里面的一个成员属性，和data1同一个级别，需要通过外部类类型调用内部类类型这是实例内部类，所以需要通过外部类对象out来new一个内部类对象*/OutClass.InnerClass innerClass= out.new InnerClass();innerClass.test();/* Test和OutClass（InnerClass）是不同的类，而且main方法也是由static修饰的，所以非static和private类权限修饰的变量或方法不能访问。*/System.out.println(out.data1);System.out.println(out.data2);//报错System.out.println(out.data3);System.out.println(innerClass.data4);System.out.println(innerClass.data5);//报错System.out.println(innerClass.data6);}
}

 【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

三、静态内部类

被static修饰的内部成员类称为静态内部类。 

package demo2;class OutClass{public int data1=1;private int data2=2;public static int data3=3;static class InnerClass{public int data4=4;private int data5=5;public static int data6=6;public void test(){System.out.println("InnerClass.test()");/*由于InnerClass是static修饰的，所以data1不能被访问若要访问，在main方法里面访问*///System.out.println(data1);/* static修饰的类不能访问非static修饰的，因为内部类是静态的，外部类是非静态的，两者不能访问，所以不能访问data2 */System.out.println(data2);//报错System.out.println(data3);System.out.println(data4);System.out.println(data5);System.out.println(data6);}}
}
public class Test {public static void main(String[] args) {OutClass.InnerClass innerClass=new OutClass.InnerClass();innerClass.test();//在main方法访问data1,实例化外部类OutClassOutClass outClass=new OutClass();System.out.println(outClass.data1);}
}

 【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员

如果确实想访问，我们该如何做？

答：在main方法书写，详细看上述代码，

2. 创建静态内部类对象时，不需要先创建外部类对象（所以用的比实例代码块多）

四、局部内部类

public class OutClass {int a = 10;
public void method(){int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){System.out.println(a);System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用InnerClass innerClass = new InnerClass();innerClass.methodInnerClass();
}
public static void main(String[] args) {// OutClass.InnerClass innerClass = null; 编译失败
}
}

 【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

4. 几乎不会使用

五、 匿名内部类

不需要接收new出来的对象的内部类

package demo3;import java.util.Objects;class OutClass{public int data1=1;private int data2=2;public static int data3=3;public void test(){System.out.println("OutClass.test()");}}public class Test {public static void main(String[] args) {OutClass outClass=new OutClass();System.out.println(outClass.data1);outClass.test();/* 匿名内部类：没有对象来接收，只能只用一次，相当于一次性 */System.out.println(new OutClass().data1);new OutClass().test();}}

同时：局部内部类也可以运用在接口上面

package demo3;interface ITestable{void test();
}public class Test {public static void main(String[] args) {/*相当于一个类实现了这个接口，并重写了test方法这里没有对象接收，并不算实例化，接口不能实例化*/new ITestable() {@Overridepublic void test() {System.out.println("匿名内部类test()");}}.test();}
}

 又或者可以这样写：（test（）运用了动态绑定）

package demo3;interface ITestable{void test();
}public class Test {public static void main(String[] args) {ITestable it=new ITestable() {@Overridepublic void test() {System.out.println("test()..");}};it.test();}
}

若想要根据原理也可以：（test（）用到了动态绑定）

package demo3;interface ITestable{void test();
}class ITE implements ITestable{@Overridepublic void test() {System.out.println("test()..");}
}
public class Test2 {public static void main(String[] args) {ITestable it=new ITE();it.test();}
}