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)如果有必要,匿名内部类也可以重写父类中的普通方法