JAVA 内部类
一、什么是内部类?
一个类的定义放在另一个类的内部,这个类就叫做内部类
二、内部类有那些特性?
1、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。
2、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。
3、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 。
三、内部类有哪几种?
1.成员内部类
如:
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
44
45
46
47
48
49
50
|
package
com.test01;
public
class
A {
// 内部类 B 继承 TestPojo 和实现 TestInterface 接口
class
B
extends
TestPojo
implements
TestInterface{
//内部类 B 自己的方法
public
void
run(){
System.out.println(
"我正在跑!"
);
}
//重写的接口方法
public
void
testf() {
System.out.println(
"实现接口!"
);
}
}
// 方法里面调用内部类
public
void
test(){
B b =
new
B() ;
b.testf() ;
// 掉用重写接口方法
b.run() ;
// 调用自己的方法
b.testpojo() ;
// 调用继承父类的方法
}
// main 方法测试
public
static
void
main(String[] args) {
A a =
new
A() ;
a.test() ;
}
}
// 定义了一个接口 ,方法为testf()
interface
TestInterface{
public
void
testf() ;
}
// 定义了一个普通类 方法testpojo()
class
TestPojo{
public
void
testpojo(){
System.out.println(
"我是简单的pojo类"
);
}
}
// 实现 调用内部类里面的方法
class
Textone{
public
static
void
main(String[] args) {
A.B b =
new
A().
new
B() ;
//调用类A里面的内部类B
/** 等同于 下面代码
* A a = new A() ;
* A.B b = a.new B() ;
* */
b.testf() ;
// 掉用重写接口方法
b.run() ;
// 调用自己的方法
b.testpojo() ;
// 调用继承父类的方法
}
}
|
2、方法内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package
com.test01;
public
class
PerTest {
public
void
test(){
// 定义一个方法
class
Ne{
// 定义一个方法内部类
public
void
fle(){
// 定义方法内部类的方法
System.out.println(
"我正在飞翔!"
);
}
} ;
new
Ne().fle() ;
//调用内部类的方法
}
public
static
void
main(String[] args) {
new
PerTest().test() ;
//测试
}
}
|
注意: (1)、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,
局部变量成为历史。但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!
例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。正因为不能保证局部变
量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。 (该理解来源于百度百科)
3、匿名内部类
1)、抽象匿名内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package
com.anonymous;
public
class
AbstractClass {
public
void
test(){
//方法为test
TestA a =
new
TestA(){
//实现抽象类
@Override
public
void
run() {
//实现抽象类的方法
System.out.println(
"我正在使用抽象匿名内部类"
);
}
} ;
a.run() ;
//调用内部类的方法
}
public
static
void
main(String[] args) {
new
AbstractClass().test() ;
//测试
}
}
//定义一个抽象类 TestA 抽象方法为run()
abstract
class
TestA{
public
abstract
void
run() ;
}
|
2)、接口匿名内部类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package
com.anonymous;
public
class
TestAnonymous {
MyInterface m =
new
MyInterface(){
//实现接口
public
void
eat() {
//重写MyInterface 接口方法
System.out.println(
"我正在吃饭!"
);
}
} ;
public
void
ss(){
//方法ss
m.eat() ;
//调用重写的方法
}
public
static
void
main(String[] args) {
new
TestAnonymous().ss() ;
//测试
}
}
//定义一个接口 方法为 eat
interface
MyInterface{
public
void
eat() ;
}
|
注意:匿名内部 类 可以定义在方法内也可以定义在类的成员中,不管是那种匿名内部类都不能被外部类直接调用
四、内部类的作用?
每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角度看,内部类使得多重继承的解决方案变得完整。
接口解决了部分问题,而内部类有效地实现了“多重继承”。
感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!