什么是嵌套类及内部类
可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种:
其一、在一个类(外部类)中直接定义的内部类;
其二、在一个方法(外部类的方法)中定义的内部类;
其三、匿名内部类。
内部类生成的.class文件名为:Outer$Inner.class
内部类的优点是“可以方便的访问外部类中的私有成员
一个内部类如果使用static关键字声明的话,则此内部类就将成为外部类,可以直接通过外部类.内部类的形式访问
在方法中定义的内部类,可以直接访问外部类中的各个成员,但是如果要访问方法中的参数,则需要在参数上加上final关键字声明;
如果要在外部直接使用内部类的实例化对象:
外部类.内部类 内部类对象 = 外部类实例.new 内部类实例();1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32public class InnerClassDemo {
public static void main(String[] args) {
new Outer().fun();
}
}
class Outer {
private String name = "Hello 内部类";
public void fun() {
new Inner(this).print();
}
public String getName() {
return this.name;
}
};
class Inner {
private Outer02 out;
public Inner02(Outer02 out) {
this.out = out;
}
public void print() {
System.out.println("name = " + this.out.getName());
}
};
下面,我将说明这几种嵌套类的使用及注意事项。
静态嵌套类
如下所示代码为定义一个静态嵌套类,1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class StaticTest {
private static String name = "javaJohn";
private String id = "X001";
static class Person{
private String address = "swjtu,chenDu,China";
public String mail = "josserchai@yahoo.com";//内部类公有成员
public void display(){
//System.out.println(id);//不能直接访问外部类的非静态成员
System.out.println(name);//只能直接访问外部类的静态成员
System.out.println("Inner "+address);//访问本内部类成员。
}
}
public void printInfo(){
Person person = new Person();
person.display();
//System.out.println(mail);//不可访问
//System.out.println(address);//不可访问
System.out.println(person.address);//可以访问内部类的私有成员
System.out.println(person.mail);//可以访问内部类的公有成员
}
public static void main(String[] args) {
StaticTest staticTest = new StaticTest();
staticTest.printInfo();
}
}
在静态嵌套类内部,不能访问外部类的非静态成员,这是由Java语法中“静态方法不能直接访问非静态成员”所限定。若想访问外部类的变量,必须通过其它方法解决,由于这个原因,静态嵌套类使用很少。注意,外部类访问内部类的的成员有些特别,不能直接访问,但可以通过内部类来访问,这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意,内部静态类Person只在类StaticTest 范围内可见,若在其它类中引用或初始化,均是错误的。
在外部类中定义内部类
如下所示代码为在外部类中定义两个内部类及它们的调用关系:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class Outer {
int outer_x = 100;
class Inner{
public int y = 10;
private int z = 9;
int m = 5;
public void display(){
System.out.println("display outer_x:"+ outer_x);
}
private void display2(){
System.out.println("display outer_x:"+ outer_x);
}
}
void test(){
Inner inner = new Inner();
inner.display();
inner.display2();
//System.out.println("Inner y:" + y);//不能访问内部内变量
System.out.println("Inner y:" + inner.y);//可以访问
System.out.println("Inner z:" + inner.z);//可以访问
System.out.println("Inner m:" + inner.m);//可以访问
InnerTwo innerTwo = new InnerTwo();
innerTwo.show();
}
class InnerTwo{
Inner innerx = new Inner();
public void show(){
//System.out.println(y);//不可访问Innter的y成员
//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
innerx.display();//可以访问
innerx.display2();//可以访问
System.out.println(innerx.y);//可以访问
System.out.println(innerx.z);//可以访问
System.out.println(innerx.m);//可以访问
}
}
public static void main(String args[]){
Outer outer = new Outer();
outer.test();
}
}
以上代码需要说明有,对于内部类,通常在定义类的class关键字前不加public 或 private等限制符,若加了没有任何影响,同时好像这些限定符对内部类的变量和方法也没有影响(?)。另外,就是要注意,内部类Inner及InnterTwo只在类Outer的作用域内是可知的,如果类Outer外的任何代码尝试初始化类Inner或使用它,编译就不会通过。同时,内部类的变量成员只在内部内内部可见,若外部类或同层次的内部类需要访问,需采用示例程序中的方法,不可直接访问内部类的变量。
匿名类
1、new <类或接口><类的主体>,匿名类的声明是在编译时进行的,实例化是在运行时进行的,所以在for循环中一个new语句会创建相同匿名类的几个实例,而不是创建几个不同匿名类的一个实例。
2、如果要执行的对象需要一个对象,但却不值得创建全新的对象(可能是因为该对象只在一个方法内部使用),在这个时候使用匿名类就会非常合适,所以说,匿名类一般会在swing程序中快速创建事件处理程序。
3、从技术上说,匿名类可以被看作非静态的内部类,所以他们具有方法内部声明的非静态内部类相同的权限和限制。1
2
3
4
5
6
7
firstButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
getTxtValue().setText("第一个按钮触发的事件!");
}
});
Java内部类引用外部类中的局部变量必须是final问题分析
编写程序时,如果内部类调用了外部类方法中的变量,那么该变量必须申明为final类型,该内部类出现在一个方法的内部,编译时,内部类编译为Outer$1TimerPrint.class,外部类的这个方法和内部类是处于同一级别的,说明与类生命周期无关.实际原因是若定义为final,则java编译器则会在内部类TimerPrint内生成一个外部变量的拷贝,而且可以既可以保证内部类可以引用外部属性,又能保证值的唯一性。若不定义为final,则无法通过编译!(jdk1.6测试过)。因为编译器不会给非final变量进行拷贝,那么内部类引用的变量就是非法的!
下面看经过编译以后的字节码:
外部类编译后的字节码:
内部类编译后的字节码:
如果外部类中的变量d没有被内部类引用,则final为可选的,而且java编译器将不做特殊处理!!
加一个参数d 并且把它定义为非final类型,编译以后文件如下:
编译后的外部类class:
编译后的内部类class:
由上可以看出,在方法内部定义内部类时,内部类如果调用了方法内的变量,则该变量必须被final修饰,否则就会因为在调用内部类时因为找不到所用的变量而报错!