java匿名内部类详解-java匿名内部类定义

Java内部类有四种类型：成员内部类、局部内部类、静态内部类和匿名内部类。

1、成员内部类：作为外部类的成员存在，与外部类的属性和方法并列。

注意：成员内部类中不能定义静态变量，但外部类的所有成员都可以访问。

public class Outer{
	private static int i = 1;
	private int j=10;
	private int k=20;
	public static void outer_f1(){
	//do more something
	}
	public void out_f2(){
	//do more something
	}
	//成员内部类
	class Inner{
		//static int inner_i =100; //内部类中不允许定义静态变量
		int j=100;//内部类中外部类的实例变量可以共存
		int inner_i=1;
		void inner_f1(){
			System.out.println(i);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
			System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名
			System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量
			//访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。
			System.out.println(k);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
			outer_f1();
			out_f2();
		}
	}
	//外部类的非静态方法访问成员内部类
	public void outer_f3(){
		Inner inner = new Inner();
		inner.inner_f1();
	}
	//外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样

	public static void outer_f4(){
	//step1 建立外部类对象
	Outer out = new Outer();
	//***step2 根据外部类对象建立内部类对象***
	Inner inner=out.new Inner();
	//step3 访问内部类的方法
	inner.inner_f1();
	}
		public static void main(String[] args){
		outer_f4();
	}
}

成员内部类的优点：

⑴ 作为外部类的成员，内部类可以访问外部类的私有成员或属性。 （即使外部类被声明为PRIVATE，它仍然对它里面的内部类可见。）

(2) 使用内部类定义在外部类中不可访问的属性。 这样就在外部类中实现了比外部类的private更小的访问权限。

注意：内部类是一个编译期的概念，一旦编译成功，就会变成两个完全不同的类。 对于名为 outer 的外部类和在其内部定义的名为 inner 的内部类。 编译完成后，有outer.class和outer$inner.class两种。

2.局部内部类：方法中定义的内部类类似于一个局部变量。 局部内部类之前没有修饰符public或private，它的作用域是定义它的代码块。

注意：局部内部类中不能定义静态变量，可以访问外部类的局部变量（即方法中的变量），但变量必须是final的。

public class Outer {
	private int s = 100;
	private int out_i = 1;
	public void f(final int k){
		final int s = 200;
		int i = 1;
		final int j = 10;
		class Inner{ //定义在方法内部
			int s = 300;//可以定义与外部类同名的变量
			//static int m = 20;//不可以定义静态变量
			Inner(int k){
			inner_f(k);
			}
			int inner_i = 100;
			void inner_f(int k){
				System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量

				System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****
				// System.out.println(i);
				System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
				System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量
				System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量
			}
		}
		new Inner(k);
	}
	public static void main(String[] args) {
		//访问局部内部类必须先有外部类对象
		Outer out = new Outer();
		out.f(3);
	}
}

注意：

局部内部类不能在类外直接生成（保证局部内部类对外界不可见）。 当要使用局部内部类时，需要生成一个对象，对象调用一个方法，它的局部内部类只能在方法中调用。 通过内部类和接口实现强制弱耦合，使用本地内部类实现接口，在方法中返回接口类型，使本地内部类不可见，屏蔽了实现类的可见性.

3.静态内部类：静态内部类定义在类中java匿名内部类详解，任何方法都用static定义。

注意：可以在静态内部类中定义静态或非静态成员

public class Outer {
	private static int i = 1;
	private int j = 10;
	public static void outer_f1(){
	}
	public void outer_f2(){
	}
	// 静态内部类可以用public,protected,private修饰
	// 静态内部类中可以定义静态或者非静态的成员
	static class Inner{
		static int inner_i = 100;
		int inner_j = 200;
		static void inner_f1(){
			System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
			outer_f1();//包括静态变量和静态方法

		}
		void inner_f2(){
			// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
			// outer_f2();//包括非静态变量和非静态方法
		}
	}
	public void outer_f3(){
		// 外部类访问内部类的静态成员：内部类.静态成员
		System.out.println(Inner.inner_i);
		Inner.inner_f1();
		// 外部类访问内部类的非静态成员:实例化内部类即可
		Inner inner = new Inner();
		inner.inner_f2();
	}
	public static void main(String[] args) {
		new Outer().outer_f3();
	}
}

注意：*****生成（新建）静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。 静态内部类的对象可以直接生成：

Outer.Inner in = new Outer.Inner();

不需要通过生成外部类对象来生成。 这有效地使静态内部类成为顶级类。 静态内部类不能用private定义。 *****

例子：

对于这两个类，具有相同的方法：

class People{
	run();
}
class Machine{
	run();
}

此时有一个机器人类：

类 Robot 扩展 People 实现 Machine。

这个时候run()是不能直接实现的。

注意：当类与接口（或接口与接口）之间发生方法命名冲突时，必须使用内部类来实现。 多重继承不能完全用接口来实现，真正的多重继承只能用接口和内部类来实现。

4.匿名内部类

匿名内部类是一种特殊的局部内部类，它通过匿名类实现接口。

IA被定义为一个接口。

IA I=新 IA(){};

匿名内部类的特点：

1、一个类用于继承其他类或实现接口。 它不需要添加额外的方法，但它只是继承方法的优先或覆盖。

2. 只是获取一个对象实例，不需要知道它的实际类型。

3、类名无意义，即不需要使用。

public class Outer {
	private static int i = 1;
	private int j = 10;
	public static void outer_f1(){
	
	}
	public void outer_f2(){
	
	}
	// 静态内部类可以用public,protected,private修饰
	// 静态内部类中可以定义静态或者非静态的成员
	static class Inner{
		static int inner_i = 100;
		int inner_j = 200;
		static void inner_f1(){
			System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
			outer_f1();//包括静态变量和静态方法
		}
		void inner_f2(){
			// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
			// outer_f2();//包括非静态变量和非静态方法
		}
	}
	
	public void outer_f3(){
		// 外部类访问内部类的静态成员：内部类.静态成员
		System.out.println(Inner.inner_i);

		Inner.inner_f1();
		// 外部类访问内部类的非静态成员:实例化内部类即可
		Inner inner = new Inner();
		inner.inner_f2();
	
	}
	public static void main(String[] args) {
		new Outer().outer_f3();
	}
}

注意：匿名内部类必须在new后面，它隐式实现了一个接口或者实现了一个类。 没有类名。 根据多态性，我们使用它的父类名。 因为是局部内部类java匿名内部类详解，所以局部内部类的所有限制都对它生效。 匿名内部类是唯一没有构造函数的类。 大多数匿名内部类用于接口回调。 匿名内部类在编译时被系统自动命名为Out$1.class。 如果一个对象的编译时类型是一个接口，那么它的运行时类型就是实现该接口的类。 因为匿名内部类没有构造函数，所以它的使用范围非常有限。 局部内部类是在需要多个对象的时候使用的，所以局部内部类的应用相对比较多。 构造函数不能在匿名内部类中定义。 如果一个对象的编译时类型是一个接口，那么它的运行时类型就是实现该接口的类。

____________________________________________________________________________

内部类总结：

1.首先把内部类当作外部类的一个特殊成员，所以它有类成员的封闭级别：private、protected、default(friendly)、public

它具有类成员的修饰符：static、final、abstract

2、非静态内部类嵌套内部类，内部类隐含了一个外部类的指针this，所以可以访问外部类的所有资源（当然也包括private）

外部类访问内部类的成员时，必须先获取内部类的对象，这取决于内部类成员的封装程度。

非静态内部类不能包含任何静态成员。

3.静态内部类：静态内部类，不再包含外部类的this指针，在加载外部类时进行初始化。

静态内部类可以包含静态或非静态成员。

静态内部类只能访问外部类的静态成员。

外部类按照一般类规则访问静态内部类的成员。对于静态成员，使用类名。 成员可以访问，对于非静态成员，仅

使用 object.member 访问

4. 对于方法中的内部类或块中的内部类，只能访问块中或方法中的final变量。

类成员有静态和非静态两种，内部类也有两种

非静态内部类的实例必须在外部类的方法中或者通过外部类的实例（OuterClassInstanceName.new innerClassName(ConstructorParameter)）创建，并且可以直接访问外部类的信息，而外部类对象可以传递 OuterClassName。 这个要引用

静态内部类的实例可以直接创建，不需要引用外部类实例。

内部类，无论是静态的还是非静态的，都有对外部类的引用

非静态内部类不允许有静态成员

方法中的内部类只允许访问方法中final的局部变量和方法的final参数列表，所以方法中的内部类和内部类没有区别。但是方法中的内部类方法外不能访问方法，方法中不能有静态内部类

如果一个匿名内部类继承了一个接口，它必须不带参数地实现指定接口的方法

如果匿名内部类继承自该类，则必须根据父类的构造函数的参数传递参数

以上来自学习期间访问的网站：website