1、上代码：
//局部内部类、静态内部类、匿名类////接口仅仅解决了多继承的部分问题，内部类有效实现了多重继承
package ClassN1;
public final class InnerClass {
private int a=50;
private int out_i=1;
private static int out_j=100;
public InnerClass() {
}
public static void main(String[] args) {
InnerClass In=new InnerClass();
In.f(3);
InnerClass.Inner1 In1 = new InnerClass().new Inner1("bobo");//颠覆人身观价值观世界观的一行代码2018_04_03,外部类访问内部类
//外部内访问内部类一定得这样创建内部内的对象才行
In1.setName("nono");
In.ceshi(In1);
Inner2 In3=new Inner2();
In3.testGetData();
}
public static void testOutNoStatic() {
System.out.println("外部类非静态类方法被访问");
}
public void ceshi(Inner1 In) {//外部内函数使用内部类
System.out.println(In.name);
Inner1 In2=new Inner1("ceshi函数输出");
System.out.println(In2.getName());
In2.println1();
In2.testGetDate();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//内部类：
public final class Inner1 extends Inner1ceshi{// 内部类、定义于一个类中，做这个类的成员变量使用,内部内的继承完美的实现了多继承
private String name; //与局部内部类不同，它可以有访问控制类修饰符
//局部类中还可以再定义局部类，思维打开来
public final String getName() {
return name;
}
public final void setName(String name) {
this.name = name;
}
public Inner1(String name) {
super();
this.name = name;
}
@Override
public void println1() {
System.out.println("测试内部类继承成功");
}
public void testGetDate() {
System.out.println(name);//访问自己的成员变量
System.out.println(this.name);//访问自己的成员变量
System.out.println(InnerClass.this.a);//访问外部类的成员变量或成员方法
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//局部内部类：
public void f(final int b) {
final int s=200;
int i=1;
final int j=10;
//局部内部类:定义在方法中的类，做当前方法的一个局部变量使用，作用域仅限这个方法，局部内部类还可以再定义局部类，思维打开
class Inner{ //局部内部类,局部类不能用访问控制修饰符来修饰,局部内部类只能被final abstract修饰，相当于做了一个方法的变量
//但在局部内部内的内部，访问控制修饰符完全遵循所讲的各种规则
private int a=30;
private int inner_i=100;
public Inner(int b){
inner_f(b);
}
private void inner_f(int b) {
System.out.println(out_i); //访问外部类所有成员
System.out.println(j);//访问所在函数的final变量及参数
System.out.println(a);//访问局部内部类成员
System.out.println(this.a);//访问局部内部类成员
System.out.println(InnerClass.this.a);//访问外部类成员
}
}
new Inner(b);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//静态内部类：
public static class Inner2 {
private static String name;
public static final String getName() {
return name;
}
public static final void setName(String name) {
Inner2.name = name;
}
public void testGetData() {
System.out.println(name);//访问自己的类成员变量
System.out.println(out_j);//直接访问外部类静态成员变量
//System.out.println(out_i);//访问非静态成员均出错
//System.out.println(InnerClass.this.out_i);
testOutNoStatic();//直接访问外部类静态成员方法
InnerClass In1=new InnerClass();
System.out.println(In1.out_i);//只能通过创建外部类对象的方法访问外部类非静态成员
}
}
}
2、说明：
1、为什么使用内部类？
每个类能独立的继承一个类或实现一个接口，与外部类没有任何关系，一定程度上解决了单继承问题。
2、分类：
2、1成员内部类:
1.Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
2.Inner 类中定义的 show() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性age
3.定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，
即：内部类 对象名 = 外部类对象.new 内部类( );
4.编译上面的程序后，会发现产生了两个 .class 文件: Outer.class,Outer$Inner.class{}
5.成员内部类中不能存在任何 static 的变量和方法,可以定义常量:
(1).因为非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象的,仅与类相关,
简而言之:在加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过;
非静态内部类的作用域是实例级别
(2).常量是在编译器就确定的,放到所谓的常量池了
6.外部类是不能直接使用内部类的成员和方法的，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法;
7.如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，
可以使用 this 关键字,如:Outer.this.name
2、2静态内部类: 是 static 修饰的内部类
1.静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2.如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3.创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();
4、静态内部类能够声明静态成员方法和静态成员变量。
2、3方法内部类：其作用域仅限于方法内，方法外部无法访问该内部类
(1).局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的
(2).只能访问方法中定义的 final 类型的局部变量,因为:
当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在,
直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量;
==>使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.
局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，
自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;
防止被篡改数据,而导致内部类得到的值不一致
2、4匿名内部类：
为什么要使用匿名内部类？
比如我们定义了一个方法，有个参数是接口类型或抽象类，这样不使用匿名内部类，我们每次都需要先定义一个类实现该接口或抽象类，再创建该类的实例传递给该方法。当接口或抽象类中需要实现的方法数量比较少时（比如只有1个），这个先创建类，再使用就显的比较啰嗦了。而且这种场景下，往往创建的类就这一个地方使用。而通过匿名内部类，就可以让编写的代码简洁很多。 实际上,java本身提供的一些api（如多线程、io、集合框架等）就大量的使用了这个特性。
(1).匿名内部类是直接使用 new 来生成一个对象的引用;
(2).对于匿名内部类的使用它是存在一个缺陷的，就是它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，
该类的定义会立即消失，所以匿名内部类是不能够被重复使用;
(3).使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口;
(4).匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法;
(5).匿名内部类中不能存在任何的静态成员变量和静态方法,匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法
(6).匿名内部类初始化:使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果
(7).匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。