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

什么是内部类？

在类中定义类java匿名内部类详解，在类内部定义一个完整的类称为内部类

例如：

public class TestInner {
	public static void main(String[] args) {
		Outer o = new Outer();
		Outer.Inner inner = o.new Inner();
		inner.inner_method();
	}
}
class Outer{
	int a = 20;	//Outer类的成员变量
	//类中定义类
	class Inner{  //成员内部类
		int a = 10;
//		static int b;  成员内部类中不能定义静态成员（静态方法 和 静态变量）
		public void inner_method(){
			int a = 30;
			System.out.println(a);  //局部变量   30
			System.out.println(this.a);  //内部类的成员变量  10
			System.out.println(Outer.this.a);  //外部类的成员变量   20
			
		}
	}
	
}

从上面的程序可以看出：

Inner称为Outer的内部类，也是两个完全独立的类

内部类编译后会生成对应的.class文件，文件名为Outer$Inner.class

可以在不破坏外部类封装的情况下访问外部类的私有属性

成员内部类：

类内部的类称为成员内部类

它可以与定义在类内和方法外的成员变量进行比较。

同样在上述程序的帮助下java匿名内部类详解，

创建成员内部类对象，首先要创建外部类对象，然后通过外部类对象构造内部类对象。new

	Outer outer = new Outer();
	Outer.Inner inner = outer.new Inner();

外类名.this指向外类的当前对象：System.out.println(Outer.this.a); //外部类的成员变量20

成员内部类不能有静态成员

public class TestMemberClass {
	public static void main(String[] args) {
	
		Outer o1 = new Outer(120);
		Outer o2 = new Outer(200);
		Outer.Inner in = o1.new Inner();
		in.print();  
	}
}
class Outer{
	private int a ;
	
	//Inner就叫做Outer 的 内部类，也是两个完全独立的类
	//在类里面的类就叫成员内部类
	/*
	 * 1,内部类可以 访问外部类的私有成员，而不破坏封装
	 */
	
	public Outer() {
	}
	public Outer(int a) {

		this.a = a;
	}
	public class Inner{
		//成员内部类中不能有静态成员
		//private int s = 20;
		int a = 123;
		public void print(){
			
			//外部类类名.this指向外部类的当前对象
			System.out.println(a);//123
			System.out.println("---"+Outer.this.a);//120
		} 
	}	
}

outer.this 表示外部类对象

外.这。 外部类属性名访问外部类属性

外.这。 外部类方法名(实参) 访问外部类方法

静态内部类：

可以类比为静态变量，成员内部类加上static就是静态内部类。 也是定义在类内，方法外，用static修饰。

class Outer{
   static class Inner{
		
	}
}

创建时需要依赖类来创建对象：

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

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

局部内部类：

它也类似于局部变量，必须在方法内部定义！

class Outer{
	public void method(){
			//类写在方法的内部，就叫做局部内部类
			class inner{
				
			}
		}
}

局部内部类创建对象时，只能在定义它的方法内部创建；

class Outer{
	private int a = 10;
	public void m1(){
		final int b = 20;
		class Inner{
			public void inner_method(){
				System.out.println(a); 	//10
				System.out.println(b); 
				System.out.println("局部内部类方法");
				
			}
		}
		Inner inner = new Inner();
		inner.inner_method();
	}
}

并且本地内部类可以访问外部类的私有属性

局部内部类也可以访问其方法的局部变量，但要求局部变量必须是final修饰的

从jdk 8.0开始，final默认加入局部变量

匿名内部类：

特殊的局部内部类。具有局部内部类的特点

匿名内部类

使用的三个条件

匿名内部类怎么写

new interface(){实现方法}；

匿名内部类不能定义构造函数

定义匿名内部类的写法：定义类、实现接口、新建对象三步

IA ia = new IA(){		//IA 接口名  匿名内部类想要实现的接口
				public void m1() {
					System.out.println("匿名内部类");
				}
			};
			//ia引用 可以直接操作内部类中方法
			ia.m1();

下面展示了匿名内部类的具体用法：

package test;
public class TestNiMingClass {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 Teacher t = School.getTeacher(0);
		 t.teach();
	
	}
}
class School{
	public static Teacher getTeacher(int i){
		//两个局部内部类
		class Teacher1 implements Teacher{
			public void teach(){
				System.out.println("胡老师讲课");

			}
		}
		class Teacher2 implements Teacher{
			public void teach(){
				System.out.println("刘老师讲课");
			}
		}
		
		if (i%2 == 0) {
			//return new Teacher1();
			
			//定义匿名内部类的写法
			//定义类、实现接口、new对象 三步合一  
			
			//局部内部类用法
			//return new Teacher1(); 
			
			//匿名内部类用法
			return new Teacher(){
				public void teach(){ 
					System.out.println("胡老师讲课");
				}
			}; 
		}else{
			return new Teacher2();
		}
	}
}
interface Teacher{
	void teach();
}

匿名内部类的好处：

接口是public的，接口的实现类隐藏为内部类，强行弱耦合

缺点是匿名内部类的写法实在是难受，可读性太差