● 本质是类
● 内部类
● 该类没有名字
● 同时还是一个对象
说明: 匿名内部类是定义在外部类的局部位置,比如方法中,并且没有类名
基于接口的匿名内部类的使用
public class Anonymous {
public static void main(String[] args) {
}
}
class Outer04{ //外部类
public int n1 = 10; //属性
public void method() { //方法
}
}
interface IA { //接口
public void cry();
}
class Father{
public Father(String name) { //构造器
}
public void test() { //方法
}
}
需求: 想使用IA接口,并创建对象传统方式,写一个类,实现该接口,并创建对象
class Tiger implements IA{
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
public class Anonymous {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04{ //外部类
public int n1 = 10; //属性
//基于接口的匿名内部类
//1.需求: 想使用IA接口,并创建对象
//2.传统方式,写一个类,实现该接口,并创建对象
public void method() { //方法
IA tiger = new Tiger();
tiger.cry();
}
}
但是如果需求是Tiger类只使用一次,后面不再使用,可以使用匿名内部类简化开发
class Outer04 { //外部类
public int n1 = 10; //属性
public void method() { //方法
IA tiger = new IA() {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
};
tiger.cry();
}
}
可以达到一样的效果。
- 这里tiger的编译类型是
IA
,运行类型是匿名内部类 - 这个匿名内部类其实就是XXX => Outer04$01
- JDK底层在创建匿名内部类
Outer04$01
,立即马上创建了Outer04$01
实例,并且把地址返回给tiger
- 匿名内部类使用一次,就不能再使用
class XXX implements IA {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
基于类的匿名内部类的使用
//1.father的编译类型是Father
//2. father的运行类型是Outer04$02
//3.底层会创建匿名内部类
/*
* class XXX extends Father {
* @Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
* }
* */
Father father = new Father("jack"){
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father对象的运行类型=" + father.getClass());
father.test();
基于抽象类的匿名内部类
abstract class Animal{
abstract void eat();
}
//基于抽象类的匿名内部类
Animal animal = new Animal() {
@Override
void eat() {
System.out.println("小狗吃骨头...");
}
};
使用细节
public class AnonymousInnerClassDetail {
public static void main(String[] args) {
Outer05 outer05 = new Outer05();
outer05.f1();
}
}
class Outer05{
private int n1 = 99;
public void f1() {
//创建一个基于类的匿名内部类
Person person = new Person() {
@Override
public void hi() {
System.out.println("匿名内部类重写了hi方法");
}
};
person.hi(); //动态绑定,运行类型是Outer05$01其实输出重写的hi方法
}
}
class Person{ //类
public void hi(){
System.out.println("Person hi()");
}
}
也可以直接调用
//也可以直接调用 匿名内部类本身也是返回对象
new Person() {
@Override
public void hi() {
System.out.println("匿名内部类重写了hi方法");
}
}.hi();
可以直接访问外部类的所有成员,包括私有的
new Person() {
@Override
public void hi() {
System.out.println("匿名内部类重写了hi方法" + n1);
}
}.hi();
不能添加访问修饰符,因为它的地位就是一个局部变量
作用域:仅仅在定义它的方法或代码块中
匿名内部类—>访问----->外部类成员 直接访问
外部其他类------不能访问---->匿名内部类
如果外部类和匿名内部类的成员重名时,匿名内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问
最佳实践
public class InnerClassExercise01 {
public static void main(String[] args) {
//当做实参直接传递,简洁高效
f1(new IL() {
@Override
public void show() {
System.out.println("这是show方法");
}
});
//传统方法需要再定义一个类实现接口 再去调用
}
//静态方法,形参是接口类型
public static void f1(IL il) {
il.show();
}
}
//接口
interface IL{
void show();
}
有一个铃声Bell,里面有个ring方法 有一个手机类CellPhone,具有闹钟功能alarmClock,参数是Bell类型
测试手机类的闹钟功能,通过匿名内部类(对象)作为参数,打印:懒猪起床了 再传入另一个匿名内部类(对象),打印:小伙伴上课了
public interface Bell {
void ring();
}
public class Cellphone {
public void alarmClock(Bell bell) {
bell.ring();
}
}
public class TestRing {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床了");
}
});
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("小伙伴上课了...");
}
});
}
}