Java中的隐名内部类( Anonymous Classes)
什么是匿名内部类
匿名内部类可以使你的代码更加简洁,你可以在定义一个类的同时对其进行实例化。它与局部类很相似,不同的是它没有类名,如果某个局部类你只需要用一次,那么你就可以使用匿名内部类(Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.)
匿名类是不能有名字的类,它们不能被引用,只能在创建时用New语句来声明它们。匿名类的声明是在编译时进行的,实例化在运行时进行,这意味着for循环中的一个new语句会创建相同匿名类的几个实例,而不是创建几个不同匿名类的一个实例。
匿名类的目的是在某个地方需要特殊的实现,因此在该处编写其实现,并获取它的实例,调用它的方法。不要在匿名内部类编写其他的方法,是不可见的
语法格式
new <类或接口> <类的主体>
示例
public class HelloWorldAnonymousClasses {
/**
* 包含两个方法的HelloWorld接口
*/
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
// 1、局部类EnglishGreeting实现了HelloWorld接口
class EnglishGreeting implements HelloWorld {
String name = "world";
public void greet() {
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
// 2、匿名类实现HelloWorld接口
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
// 3、匿名类实现HelloWorld接口
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
public void greet() {
greetSomeone("mundo");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
public static void main(String... args) {
HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
运行结果为:
1 Hello world
2 Salut Fred
3 Hola, mundo
该例中用局部类来初始化变量englishGreeting,用匿类来初始化变量frenchGreeting和spanishGreeting,两种实现之间有明显的区别:
1)局部类EnglishGreetin继承HelloWorld接口,有自己的类名,定义完成之后需要再用new关键字实例化才可以使用;
2)frenchGreeting、spanishGreeting在定义的时候就实例化了,定义完了就可以直接使用;
3)匿名类是一个表达式,因此在定义的最后用分号";"结束。
为什么在Java中需要内部类
- 每个内部类都能独立的继承一个接口的实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多继承的解决方案变得完整,
- 方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏。
- 方便编写事件驱动程序
- 方便编写线程代码
内部类的作用
实现了更好的封装,我们知道,普通类(非内部类)的访问修饰符不能为private或protected,而内部类可以。当我们将内部类声明为private时,只有外部类可以访问内部类,很好地隐藏了内部类。
内部类可以继承(extends)或实现(implements)其他的类或接口,而不受外部类的影响。
内部类可以直接访问外部类的字段和方法,即使是用private修饰的,相反的,外部类不能直接访问内部类的成员。
匿名内部类的两种实现
实现接口的匿名类:
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
匿名子类(继承父类)
public class AnimalTest {
private final String ANIMAL = "动物";
public void accessTest() {
System.out.println("匿名内部类访问其外部类方法");
}
class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public void printAnimalName() {
System.out.println(bird.name);
}
}
// 鸟类,匿名子类,继承自Animal类,可以覆写父类方法
Animal bird = new Animal("布谷鸟") {
@Override
public void printAnimalName() {
accessTest(); // 访问外部类成员
System.out.println(ANIMAL); // 访问外部类final修饰的变量
super.printAnimalName();
}
};
public void print() {
bird.printAnimalName();
}
public static void main(String[] args) {
AnimalTest animalTest = new AnimalTest();
animalTest.print();
}
}
运行结果:
运行结果:
匿名内部类访问其外部类方法
动物
布谷鸟
从以上两个实例中可知,匿名类表达式包含以下内部分:
操作符:new;
一个要实现的接口或要继承的类,案例一中的匿名类实现了HellowWorld接口,案例二中的匿名内部类继承了Animal父类;
一对括号,如果是匿名子类,与实例化普通类的语法类似,如果有构造参数,要带上构造参数;如果是实现一个接口,只需要一对空括号即可;
一段被"{}"括起来类声明主体;
末尾的";"号(因为匿名类的声明是一个表达式,是语句的一部分,因此要以分号结尾)。
匿名内部类作用域内的局部变量的访问及成员变量的访问
匿名内部类与局部类对作用域内的变量拥有相同的的访问权限。
(1)、匿名内部类可以访问外部内的所有成员;
(2)、匿名内部类不能访问外部类未加final修饰的变量(注意:JDK1.8即使没有用final修饰也可以访问);
(3)、属性屏蔽,与内嵌类相同,匿名内部类定义的类型(如变量)会屏蔽其作用域范围内的其他同名类型(变量):
案例一,内嵌类的属性屏蔽:
public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
输出结果为:
x = 23
this.x = 1
ShadowTest.this.x = 0
这个实例中有三个变量x:1、ShadowTest类的成员变量;2、内部类FirstLevel的成员变量;3、内部类方法methodInFirstLevel的参数。
methodInFirstLevel的参数x屏蔽了内部类FirstLevel的成员变量,因此,在该方法内部使用x时实际上是使用的是参数x,可以使用this关键字来指定引用是成员变量x:
System.out.println("this.x = " + this.x);
利用类名来引用其成员变量拥有最高的优先级,不会被其他同名变量屏蔽,如:
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
案例二,匿名内部类的属性屏蔽:
public class ShadowTest {
public int x = 0;
interface FirstLevel {
void methodInFirstLevel(int x);
}
FirstLevel firstLevel = new FirstLevel() {
public int x = 1;
@Override
public void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
};
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.firstLevel;
fl.methodInFirstLevel(23);
}
}
输出结果为:
x = 23
this.x = 1
ShadowTest.this.x = 0
匿名内部类中不能定义静态属性、方法
public class ShadowTest {
public int x = 0;
interface FirstLevel {
void methodInFirstLevel(int x);
}
FirstLevel firstLevel = new FirstLevel() {
public int x = 1;
public static String str = "Hello World"; // 编译报错
public static void aa() { // 编译报错
}
public static final String finalStr = "Hello World"; // 正常
public void extraMethod() { // 正常
// do something
}
};
}
匿名内部类可以有常量属性(final修饰的属性);
匿名内部内中可以定义属性,如上面代码中的代码:private int x = 1;
匿名内部内中可以可以有额外的方法(父接口、类中没有的方法);
匿名内部内中可以定义内部类;
匿名内部内中可以对其他类进行实例化。
上一篇: 简单易懂的匿名内部类,一看就明