本文实例讲述了java内部类原理与用法。分享给大家供大家参考,具体如下:
一、非静态内部类
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
|
public class outclass {
private string name = "outclass" ;
public void show() {
system.out.println( this .name);
}
public void innershow() {
innerclass inner = new innerclass();
inner.show();
inner.outshow();
}
// 非静态内部类
class innerclass {
// 2.0非静态内部类不能有静态变量的声明
// public static int age=0;
private string name = "innerclass" ;
public void show() {
system.out.println( this .name);
}
public void outshow() {
// 3.0内部类做为外部类的实例成员,可以随意访问其他外部类成员
system.out.println(outclass. this .name);
}
}
public static void main(string[] args) {
outclass out = new outclass();
out.show();
out.innershow();
// 1.0下面一行编译报错,静态方法无法访问this指针
// 因为等同于this.innerclass inner=new this.innerclass();
// innerclass inner=new innerclass();
}
}
|
运行结果:
outclass
innerclass
outclass
1.外部类不能直接访问非静态内部类,必须在外部类中保存内部类的引用间接访问。
2.非静态内部类中不能有静态属性。
个人理解:非静态内部类是外部类的实例成员,它属于外部类的实例对象所拥有,若内部类有静态属性,那么属性必定属于内部类所有,即所有的内部类实例对象都共享这个属性。但是这个内部类已经属于外部类的实例对象所拥有了,貌似是1:1的关系,除非外部类的对象保存了n多份内部类实例的引用,那这样内部类的静态属性才有存在的必要,可这么做就没有什么意义了。
3.非静态内部类可以随意访问外部类的成员,因为它们都是外部类的成员,等级一样。
4.若要得到内部类的实例,可以
1
|
outclass.innerclass inner= new outclass(). new innerclass();
|
二、静态内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class outclass {
private string name = "outclass" ;
private static int age = 10 ;
// 静态内部类
static class innerclass {
public void show() {
// 1.0
system.out.println( new outclass().name);
}
public void outshow() {
// 2.0
system.out.println(age);
}
}
public static void main(string[] args) {
// 3.0
outclass.innerclass inner = new outclass.innerclass();
inner.outshow();
inner.show();
}
}
|
运行结果:
10
outclass
1.静态内部类不能随意访问外部类的实例成员,必须引用外部类的对象。
2.静态内部类可以随意访问外部类的类成员。
3.若要获取静态内部类的实例,则形式如
1
|
outclass.innerclass inner= new outclass.innerclass();
|
注意与非静态内部类获取实例的区别:
1
|
outclass.innerclass inner= new outclass(). new innerclass();
|
三、局部类
1.匿名内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
interface idraw {
void draw();
}
public class outclass {
public void createcircle(idraw obj) {
obj.draw();
}
public static void main(string[] args) {
outclass out = new outclass();
out.createcircle( new idraw() {
public void draw() {
system.out.println( "i'm drawing..." );
}
});
}
}
|
运行结果:
i'm drawing...
在调用多态形式的方法createcircle(idraw obj)
时,参数用到了new idraw(){ }
,做为接口来说是不能直接实例化的,这里的new idraw()
并不是直接实例化,而是创建了匿名内部类。
2.闭包与回调
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
interface idraw {
void draw();
}
public class outclass {
private string name = "private name" ;
public closure getclosure() {
return new closure();
}
class closure implements idraw {
public void draw() {
system.out.println(outclass. this .name); // name
}
}
public static void main(string[] args) {
outclass out = new outclass();
out.getclosure().draw();
}
}
|
运行结果:
private name
内部类可以像其他类一样灵活的实现各种接口和继承,并且可以将外部类的属性和方法绑定到自身中,形成闭包。而在外部类中提供了方法供外界获取内部类的引用,因为内部类的方法灵活的访问了外部类的许多信息,甚至是私有信息,获得了这个对象后可以反过来调用外部类的方法和函数形成回调。
其实上面只是有闭包的形式,并不算是真正的闭包,闭包的定义里主要是绑定方法里的变量,但是java是无法实现方法里的内部类还能访问方法变量的,因为无法实现真正的闭包。
java内部类有许多用处,比如利用内部类实现多个接口可以模拟多继承;比如让内部类成为辅助外部类的工具类,来帮助外部类实现更好的逻辑与扩展。
希望本文所述对大家java程序设计有所帮助。
原文链接:https://blog.csdn.net/kkkkkxiaofei/article/details/17957669