Java的匿名内部类

1、适用场合：只需要使用一次的类。最常见的使用方式是需要创建某一个接口类型的对象

2、规则：

（1）创建匿名内部类时会立刻创建一个该类的实例，然后这个类立刻消失，不可重复使用

（2）匿名内部类必须继承一个父类、或实现一个接口，但最多也只能是一个父类、一个借口

（3）匿名内部类不能是抽象类，因为需要创建这个类的对象

（4）匿名内部类不能定义构造器，因为它没有类名

3、注意点

（1）匿名内部类不能是抽象类，因此它必须实现Phone接口中的所有抽象方法

（2）创建方法：new 接口名（） | 父类名（实参列表）{ 类体部分 }

（3）如果实现是一个接口，那么（）内不能有任何参数；如果继承的是一个父类，那么（）中的参数应与父类构造器的参数相同

//实现接口
interface Phone{
	//接口中的两个抽象方法
	public double getPrice();
	public String getName();
}
public class test{
	//test类的实例方法info()，该方法传入的参数是一个接口实例
	public void info(Phone p) {
		System.out.println("购买了一个："+p.getName()+"，花了："+p.getPrice()+"元钱");
	}
	public static void main(String[] args) {
		test t=new test();
        //使用匿名内部类来创建一个Phone实例，作为info方法的方法参数
		t.info(new Phone() {
            //由于匿名内部类不能是抽象类，因此它必须实现Phone接口中的所有抽象方法
			public double getPrice() {
				return 2999.9;
			}
			public String getName() {
				return "华为手机";
			}
		});
	}
}
/*输出结果：购买了一个：华为手机，花了：2999.9元钱
上述匿名内部类的代码可以改写为：
class A implements Phone{
    public double getPrice() {
        return 2999.9;
    }
    public String getName() {
        return "华为手机";
    }
}
A aa=new A();
t.info(aa);
*/

//定义一个抽象类
abstract class Device{
	private String name;
	public abstract double getPrice();  //抽象方法
	public Device() {}   //无参构造器
	//有参构造器
	public Device(String name) {
		this.setName(name);
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return this.name;
	}
}
public class test{
	//test类的实例方法info()，该方法传入的参数是一个接口实例
	public void info(Device d) {
		System.out.println("购买了一个："+d.getName()+"，花了："+d.getPrice()+"元钱");
	}
	public static void main(String[] args) {
		test t=new test();
		//调用有参构造器创建Device匿名实现类对象
		t.info(new Device("手表") {
			//实现抽象类中唯一的一个抽象方法
			public double getPrice() {
				return 289.7;
			}
		});
		//调用无参构造器创建Device匿名实现类对象
		Device d=new Device() {
			//实现抽象类中唯一的抽象方法
			public double getPrice() {
				return 289.7;
			} 
			//重写父类的实例方法
			public String getName() {
				return "鼠标";
			}
		};
		t.info(d);
	}
}

在第二个例子中，由于Device抽象类有两种构造器，一个有无参的，一个是有一参的，因此在创建匿名内部类的时候可以传入参数，也可以不传入参数。

总结：（1）匿名内部类一定要实现接口、父类中所有的抽象方法

（2）如果有必要，匿名内部类也可以重写父类中的普通方法