转载自:java内部类有什么作用?
概述
把类定义在另一个类的内部,该类就被称为内部类。
举例:把类Inner定义在类Outer中,类Inner就被称为内部类。
1
2
3
4
|
class Outer {
class Inner {
}
}
|
内部类的访问规则
-
可以直接访问外部类的成员,包括私有
-
外部类要想访问内部类成员,必须创建内部类对象
内部类的分类
成员内部类
成员内部类:就是位于外部类成员位置的类
特点:可以使用外部类中所有的成员变量和成员方法(包括private的)
格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.eh.ftd.inner;
public class InnerDemo {
public static void main(String[] args) {
// 成员内部类是非静态的演示
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
class Outer {
private int age = 20;
// 成员位置
class Inner {
public void show() {
System.out.println(age);
}
}
}
|
对象创建
1
2
3
4
5
|
//成员内部类不是静态的:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
//成员内部类是静态的:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
|
内部类常见修饰符
private
如果我们的内部类不想轻易被任何人访问,可以选择使用private修饰内部类,这样我们就无法通过创建对象的方法来访问,想要访问只需要在外部类中定义一个public修饰的方法,间接调用。这样做的好处就是,我们可以在这个public方法中增加一些判断语句,起到数据安全的作用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Outer {
private class Inner {
public void show() {
System.out.println(“密码备份文件”);
}
}
//使用getXxx()获取成员内部类,可以增加校验语句(文中省略)
public Inner getInner() {
return new Inner();
}
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.show();
}
}
|
static
这种被 static 所修饰的内部类,按位置分,属于成员内部类,但也可以称作静态内部类,也常叫做嵌套内部类。具体内容我们在下面详细讲解。
成员内部类经典题
请在三个println 后括号中填空使得输出25,20,18
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class Outer {
public int age = 18;
class Inner {
public int age = 20;
public viod showAge() {
int age = 25;
System.out.println(age);//空1
System.out.println(this.age);//空2
// 当和外部类属性名重叠时,可通过外部类名.this.属性名
System.out.println(Outer.this.age);//空3
}
}
}
|
小结
- 可以是任何的访问修饰符。
- 内部类的内部不能有静态信息。
- 内部类也是类,该继承继承,该重写重写,该重载重载,this和super随便用。
- 外部类如何访问内部类信息,必须new之后打点访问。
- 内部类可以直接使用外部类的任何信息,如果属性或者方法发生冲突,调用外部类.this.属性或者方法。
- 其它类如何访问内部类:
1
2
3
4
|
Outer outer=new Outer();
//创造内部类对象
Outer.Inner inner=outer.new Inner();
inner.inner_show();
|
静态内部类
我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类.
特点:不能使用外部类的非static成员变量和成员方法
非静态内部类编译后会默认的保存一个指向外部类的引用,而静态类却没有。
即使没有外部类对象,也可以创建静态内部类对象,而外部类的非static成员必须依赖于对象的调用,静态成员则可以直接使用类调用,不必依赖于外部类的对象,所以静态内部类只能访问静态的外部属性和方法。
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
/**
* 外部类、内部类定义
*/
public class Outer {
private int outerVariable = 1;
/**
* 外部类定义的属性(重名)
*/
private int commonVariable = 2;
private static int outerStaticVariable = 3;
static {
System.out.println("Outer的静态块被执行了……");
}
/**
* 成员方法
*/
public void outerMothod() {
System.out.println("我是外部类的outerMethod方法");
}
/*
* 静态方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 静态内部类
*/
public static class Inner {
/**
* 成员信息
*/
private int innerVariable = 10;
private int commonVariable = 20;
static {
System.out.println("Outer.Inner的静态块执行了……");
}
private static int innerStaticVariable = 30;
/**
* 成员方法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("outerStaticVariable:"+outerStaticVariable);
outerStaticMethod();
}
/**
* 静态方法
*/
public static void innerStaticShow() {
//被调用时会先加载Outer类
outerStaticMethod();
System.out.println("outerStaticVariable"+outerStaticVariable);
}
}
/**
* 外部类的内部如何和内部类打交道
*/
public static void callInner() {
System.out.println(Inner.innerStaticVariable);
Inner.innerStaticShow();
}
}
|
访问
1
2
3
4
5
6
7
8
9
10
|
public class Other {
public static void main(String[] args) {
//访问静态内部类的静态方法,Inner类被加载,此时外部类未被加载,独立存在,不依赖于外围类。
Outer.Inner.innerStaticShow();
//访问静态内部类的成员方法
Outer.Inner oi = new Outer.Inner();
oi.innerShow();
}
}
|
加载
静态内部类的变量被调用时,我们可以看出外部类进行了加载(注:外部类中的静态代码块中的代码执行了),但是并没有被初始化(注:外部类的构造方法并没有执行,没有new对象肯定不会执行构造方法),且静态内部类也完成了加载。
因为调用静态内部类的变量,很有可能在静态内部内初始化时会调用外部静态变量,所以之前需要将外部内进行加载。
静态内部类和非静态内部类一样,都不会因为外部内的加载而加载,同时静态内部类的加载不需要依附外部类,在使用时才加载,不过在加载静态内部类的过程中也会加载外部类
小结
和成员内部类对比理解(区别异同)
- 内部可以包含任意的信息。
- 静态内部类的方法只能访问外部类的static关联的信息。
- 利用 外部类.内部类 引用=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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
/**
* 外部类、内部类
*/
public class Outer {
/**
* 属性和方法
*/
private int outerVariable = 1;
/**
* 外部类定义的属性
*/
private int commonVariable = 2;
/**
* 静态的信息
*/
private static int outerStaticVariable = 3;
/**
* 成员外部方法
*/
public void outerMethod() {
System.out.println("我是外部类的outerMethod方法");
}
/**
* 静态外部方法
*/
public static void outerStaticMethod() {
System.out.println("我是外部类的outerStaticMethod静态方法");
}
/**
* 程序的入口
*/
public static void main(String[] args) {
Outer outer = new Outer();
outer.outerCreatMethod(100);
}
/**
* 成员方法,内部定义局部内部类
*/
public void outerCreatMethod(int value) {
/**
* 女性
*/
boolean sex = false;
/**
* 局部内部类,类前不能有访问修饰符
*/
class Inner {
private int innerVariable = 10;
private int commonVariable = 20;
/**
* 局部内部类方法
*/
public void innerShow() {
System.out.println("innerVariable:" + innerVariable);
//局部变量
System.out.println("是否男性:" + sex);
System.out.println("参数value:" + value);
//调用外部类的信息
System.out.println("outerVariable:" + outerVariable);
System.out.println("内部的commonVariable:" + commonVariable);
System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
System.out.println("outerStaticVariable:" + outerStaticVariable);
outerMethod();
outerStaticMethod();
}
}
//局部内部类只能在方法内使用
Inner inner = new Inner();
inner.innerShow();
}
}
|
小结
局部内有很多局限,应注意作用域
- 类前不能有访问修饰符。
- 仅在此方法内使用。
- 无法创造静态信息。
- 可以直接访问方法内的局部变量和参数(只能是final类型的,不能更改)
- 可以随意的访问外部类的任何信息。
匿名内部类
一个没有名字的类,是内部类的简化写法
格式
1
2
3
|
new 类名或者接口名() {
重写方法();
}
|
本质:其实是继承该类或者实现接口的子类匿名对象,这也就是下例中,可以直接使用 new Inner() {}.show(); 的原因 == 子类对象.show();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
interface Inner {
public abstract void show();
}
class Outer {
public void method(){
new Inner() {
public void show() {
System.out.println("HelloWorld");
}
}.show();
}
}
class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
|
如果匿名内部类中有多个方法又该如何调用呢?
1
2
3
4
5
|
Inter i = new Inner() { //多态,因为new Inner(){}代表的是接口的子类对象
public void show() {
System.out.println("HelloWorld");
}
};
|
我们在开发的时候,会看到抽象类,或者接口作为参数。而这个时候,实际需要的是一个子类对象。如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式简化。
又比如常见的HashMap初始化写法
1
2
3
4
5
6
|
Map<String, Object> map = new HashMap<String, Object>() {
{
put("name", "June");
put("age", 12);
}
};
|
第一个花括号表示一个匿名类继承了HashMap,第二个花括号是构造块的意思
然后将这个匿名内部类对象赋值给map。
小结
- 匿名内部类是没有访问修饰符的。
- 使用匿名内部类时,这个new之后的类首先是要存在的,其次我们要重写new后的类的某个或某些方法。
- 匿名内部类访问方法参数时也有和局部内部类同样的限制(在封闭范围中定义的局部变量必须是final的)。
- 匿名内部类没有构造方法。
- 匿名内部类的好处就在于不仅节省了定义实现类的过程,还能够自动向上转型。
使用内部类的原因
封装性
作为一个类的编写者,我们很显然需要对这个类的使用访问者的访问权限做出一定的限制,我们需要将一些我们不愿意让别人看到的操作隐藏起来,
如果我们的内部类不想轻易被任何人访问,可以选择使用private修饰内部类,这样我们就无法通过创建对象的方法来访问,想要访问只需要在外部类中定义一个public修饰的方法,间接调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public interface Demo {
void show();
}
class Outer {
private class test implements Demo {
public void show() {
System.out.println("密码备份文件");
}
}
public Demo getInner() {
return new test();
}
}
|
我们来看其测试
1
2
3
4
5
6
7
8
|
public static void main(String[] args) {
Outer outer = new Outer();
Demo d = outer.getInner();
i.show();
}
//运行结果
密码备份文件
|
这样做的好处之一就是,我们可以在这个public方法中增加一些判断语句,起到数据安全的作用。
其次呢,我们的对外可见的只是getInner()这个方法,它返回了一个Demo接口的一个实例,而我们真正的内部类的名称就被隐藏起来了
实现多继承
我们之前的学习知道,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
33
34
35
36
37
38
39
40
|
public class Demo1 {
public String name() {
return "BWH_Steven";
}
}
public class Demo2 {
public String email() {
return "xxx.@163.com";
}
}
public class MyDemo {
private class test1 extends Demo1 {
public String name() {
return super.name();
}
}
private class test2 extends Demo2 {
public String email() {
return super.email();
}
}
public String name() {
return new test1().name();
}
public String email() {
return new test2().email();
}
public static void main(String args[]) {
MyDemo md = new MyDemo();
System.out.println("我的姓名:" + md.name());
System.out.println("我的邮箱:" + md.email());
}
}
|
我们编写了两个待继承的类Demo1和Demo2,在MyDemo类中书写了两个内部类,test1和test2 两者分别继承了Demo1和Demo2类,这样MyDemo中就间接的实现了多继承
使用匿名内部类实现回调功能
我们用通俗讲解就是说在Java中,通常就是编写一个接口,然后你来实现这个接口,然后把这个接口的一个对象作以参数的形式传到另一个程序方法中, 然后通过接口调用你的方法,匿名内部类就可以很好的展现了这一种回调功能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public interface Demo {
void demoMethod();
}
public class MyDemo{
public test(Demo demo){
System.out.println("test method");
}
public static void main(String[] args) {
MyDemo md = new MyDemo();
//这里我们使用匿名内部类的方式将接口对象作为参数传递到test方法中去了
md.test(new Demo){
public void demoMethod(){
System.out.println("具体实现接口")
}
}
}
}
|
解决继承及实现接口出现同名方法的问题
编写一个接口 Demo
1
2
3
|
public interface Demo {
void test();
}
|
编写一个类 MyDemo
1
2
3
4
5
6
7
|
public class MyDemo {
public void test() {
System.out.println("父类的test方法");
}
}
|
编写一个测试类
1
2
3
4
|
public class DemoTest extends MyDemo implements Demo {
public void test() {
}
}
|
这样的话我就有点懵了,这样如何区分这个方法是接口的还是继承的,所以我们使用内部类解决这个问题
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
|
public class DemoTest extends MyDemo {
private class inner implements Demo {
public void test() {
System.out.println("接口的test方法");
}
}
public Demo getIn() {
return new inner();
}
public static void main(String[] args) {
//调用接口而来的test()方法
DemoTest dt = new DemoTest();
Demo d = dt.getIn();
d.test();
//调用继承而来的test()方法
dt.test();
}
}
//运行结果
接口的test方法
父类的test方法
|