1重写一个抽象方法的匿名内部类
abstract class C//被内部类继承的类
{
abstract void show();
}
class A//外部类
{
int num=3;
/*private class B extends C
{
void show(){...};
}之前的有名内部类
*/
public void method()
{
//new B().show();
//不想创建具体的子类型，还想创建C的子类对象，没有子类型，创建父类型就行了
//new C()
//但是抽象类C不能创建对象，因为抽象方法没有重写，直接重写抽象类C，这是一个带着内容的子类对象
new C()
//匿名的父类C的子类对象
{
void show()
//直接重写父类C抽象的show方法
{...}
}.show();
//重写后直接调用子类的show方法
}
}
class Demo
{
public static void main(String[] args)
{
A a=new A();
C c=a.getObject();
c.show();
}
}
（2）匿名内部类格式
new C()
{
void show()
{...}
}.show();
格式：new 父类/接口(){子类的内容}
结果是一个子类对象
匿名内部类前提：内部类必须继承或实现抽象类
2重写两个以上抽象方法的匿名内部类
interface C//外部被实现的接口
{
void show1()；
void show2();
}
class A//外部类
{
int num=4;
public void method()
{
/*new C()
{
public void show1(){}
public void show2(){}
}.show1();
这样只能调用一个方法*/
C in=new C()
{
public void show1(){}
public void show2(){}
}
in.show1();
in.show2();
//定义接口的引用变量，匿名内部类中的方法不宜过多
}
}
3直接返回外部接口的引用，在类外调用show方法
Interface C//外部接口
{public void show();}
class A//外部类
{
public static C method()
{
return new C()
{
public void show(){}
}
//直接将接口的引用返回，指向的是匿名的实现类对象
}
}
class Demo
{
public static void main(String[] args)
{
A.method().show();
//A.method返回值是接口C的实现类对象，根据多态性的原理，将调用子类的show方法
//method是A的静态方法，用类名调用
}
}
还原为非匿名内部类
class A//外部类
{
public static C Method()
{
return new B();
//B类必须是static的，才能被static的Method访问
}
static class B implements C//内部类
{
public void show(){}
}
}
4父类（类或接口）没有定义子类（内部类）的同名函数
class A
{
public void method()
{
new Object()
{public void show(){}}.show();
//object是万类鼻祖，现在定义的是任意一个子类对象
}
或者写：
Object obj=new Object()
{public void show(){}};
obj.show();
这样写是错误的，因为引用变量obj中没有show方法
匿名内部类是子类类型，当引用变量obj指向时，就自动类型提升为Object类型
|
|
收藏
淘帖
踩
