Java匿名内部类深究

匿名内部类深究    

       接着刚才的内部类总结，我们一起来讨论匿名内部类这个小怪兽。

      首先，我们要知道，匿名内部类适合创建那种只需要一次使用的类，创建匿名内部类时会立即创建一个该类的实例，这个类定义立即消失，匿名内部类不能重复使用。

       定义匿名内部类的格式如下:

       new 实现接口()||父类构造器(实参列表)

       {

    //匿名内部类的类体部分

}；//注意这里有一个分号

        匿名内部类的两条规则:

       1.匿名内部类不能是抽象类,因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。因此不允许将匿名内部类定义为抽象类；

       2.匿名内部类不能定义构造器。（注意：其他内部类可用有自己的构造器！！）由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可用定义初始化块，可以通过实例初始化块来完成构造器需要完成的事情。

        问：匿名内部类这么复杂，那么它有什么作用呢？

        答：最常用的创建匿名内部类的方式是需要创建某个接口类型的对象。

        说到这里，可能还是不太明白，我们先通过一个例子来使用匿名内部类，再来介绍它的作用:

        

interface Product{
	public double getPrice();
	public String getName();
}

public class Test1{
    
	public void test(Product p)
	{
		System.out.println("购买了一个"+p.getName()+",花掉了"+p.getPrice());
	}
	public static void main(String[] args){
		Test1 tt = new Test1();
		//此处调用test方法时，需要传入一个Productt参数
		//此处传入其匿名实现类的实例
		tt.test(new Product(){
			<strong>public double getPrice()
			{
				return 567.8;
			}
			public String getName()
			{
				return "AGP显卡";
			}</strong>
		});
	}
}

        上面的这个程序中的Test1类定义了一个test()方法，该方法需要一个Product对象来作为参数，但Product只是一个接口，无法直接创建对象，因此此处 考虑创建一个Product接口实现类的对象传入该方法---如果这个Product接口实现类只需要一次使用，则可采用上面程序中的方式,定义一个匿名内部类。

       正如上述中的程序，定义匿名内部类时无须class关键字，而是在定义匿名类时直接生成该类的匿名内部类的对象。上面代码中的粗体部分就是匿名内部类的类体部分。

       由于匿名内部类不能是抽象类，所以匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法。

       对于刚才创建Product实现类对象的代码，也可以拆分成如下代码:

       

class Test1 implements Product{
	public double getPrice()
	{
		return 567.8;
	}
	public String getName(){
		return "AGP显卡";
	}
}
ta.test(new Test1()); 

        对比上述代码和前面的匿名内部类的类体，我们可以发现，它们完全一样，但显然，采用匿名内部类的写法更为简洁！！

       当通过实现接口来创建匿名内部类时，匿名内部类也不能显式创建构造器，因此匿名内部类只有一个隐式的构造器，故new 接口名后的括号里不能传入参数值。

       但如果通过继承父类来创建匿名内部类时，匿名内部类将拥有和父类相似的构造器，此处的相似指的是拥有相同的形参列表。

       

abstract class Device
{
	private String name;
	public abstract double getPrice();
	public Device(){}
	public Device(String name)
	{
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
public class Test1{
    
	public void test(Device d)
	{
		System.out.println("购买了一个"+d.getName()+",花掉了"+d.getPrice());
	}
	public static void main(String[] args){
		Test1 tt = new Test1();
		//调用有参数的构造器创建Device匿名实现类的对象
		tt.test(<strong>new Device("电子示波器"){
			public double getPrice()
			{
				return 67.8;
			}
		}</strong>);
		//调用无参数的构造器创建Device匿名实现类的对象
		Device d = new Device()
		{
			//初始化块
			{
				System.out.println("匿名内部类的初始化块...");
			}
			//实现抽象方法
			<strong>public double getPrice()
			{
				return 56.2;
			}
			//重写父类的实例方法
			public String getName()
			{
				return "键盘";
			}
		};</strong>
		tt.test(d);
	}
}

上述程序中创建了一个抽象父类Device类,这个抽象父类里包含了两个构造器：一个无参数的和一个有参数的。当创建以Device为父类的匿名内部类时，既可以传入参数(第一块粗体部分),也可以不传入参数(第二块粗体部分),代表调用父类的无参数的构造器。

      当创建匿名内部类时，必须实现接口或者抽象父类里的所有抽象方法。如果有需要，也可以重写父类中的普通方法，如上面程序中的第二段粗体代码部分，匿名内部类重写了抽象父类Device类的getName()方法，其中getName()方法并不是抽象方法。。

      如果局部变量被匿名内部类访问，则该局部变量相当于自动使用了final修饰。

      

interface A
{
	void test();
}
public class ATest {
	
	public static void main(String[] args) {
		final int age = 8;
		A a = new A()
		{
			public void test()
			{
				System.out.println(age);
			}
		};
		a.test();
	}
}

注：由于楼主的jdk版本还是8以前的，所以仍然需要使用final修饰哈！

            欢迎大家拍砖~