JAVA中的四个内部类-成员内部类，静态内部类，方法内部类，匿名内部类

77 阅读 0 评论 51 点赞

我是靠谱客的博主畅快蓝天，这篇文章主要介绍JAVA中的四个内部类-成员内部类，静态内部类，方法内部类，匿名内部类，现在分享给大家，希望可以做个参考。

总结下，JAVA类中的四个内部类

一.成员内部类

1.Inner类定义在Outer类的内部，类似于Outer类的一个成员变量，Inner类可以有任意访问控制符(public ,protected, private)。

2.Inner类中的方法可以直接使用Outer类中成员和方法(包括私有)，但Outer类是不能直接使用Inner类中成员和方法。

3.声明Inner类的对象必须先声明Outer类的对象： Outer ot = new Outer(); Inner inr = ot.new Inner();

4.Outer类与Inner类有同名的成员或方法，内部类默认返回自己的成员和方法，如使用外部类成员或方法时，需使用this: Outer.this.成员或方法名。

复制代码

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
// OuterClass1为外部类
public class OuterClass1 {
private int count = 10;
private int num = 30;
private void printString() {
System.out.println("外部类");
}
private void printStr() {
System.out.println("外部类2");
}
// InnerClass1为成员内部类
public class InnerClass1 {
private int count = 20;
private void printString() {
// 默认使用内部类的同名成员变量
System.out.println("成员内部类中count值：" + count);
// 使用外部类同名成员变量
System.out.println("外部类中count值：" + OuterClass1.this.count);
// 直接使用外部类成员变量
System.out.println("外部类中num值：" + num);
// 直接使用外部类方法
printStr();
// 使用外部类同名方法printString()
OuterClass1.this.printString();
}
}
public static void main(String[] args) {
OuterClass1 otc1 = new OuterClass1();
InnerClass1 ic1 = otc1.new InnerClass1();
ic1.printString();
}
}

输出结果：

成员内部类中count值：20

外部类中count值：10

外部类中num值：30

外部类2

外部类

二.静态内部类

1.静态内部类不能直接访问外部类的非静态成员

2.外部类静态成员与内部类静态成员重名时，可通过外部类名.静态成员访问

3.创建内部类实例：内部类对象名 = new 内部类();

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class OuterClass2{
public static int num = 10;
public int account = 100;
public static class InnerClass2{
public static int num = 20;
public void print(){
System.out.println("外部类静态成员num: " + OuterClass2.num);
System.out.println("内部类静态成员num: " + num);
System.out.println("外部类非静态成员account: " + new OuterClass2().account);
}
}
public static void main(String[] args){
InnerClass2 inc2 = new InnerClass2();
inc2.print();
}
}

输出结果：
外部类静态成员num: 10
内部类静态成员num: 20
外部类非静态成员account: 100

三.方法内部类

1.方法内部类就是定义在外部类的方法中，方法内部类只在该方法中可见（只能在该方法中使用）

2.方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class OuterClass3{
int a = 40;
public void show(){
final int b = 50;
int e = 60;
class InnerClass3{
int c = 30;
public void print(){
System.out.println("外部类成员变量a: " + a);
//方法内部类，无法访问方法中的局部变量e
System.out.println("外部类的方法中的常量b: " + b);
System.out.println("内部类成员变量c: " + c);
}
}
InnerClass3 inc = new InnerClass3();
inc.print();
}
public static void main(String[] args){
OuterClass3 otc = new OuterClass3();
otc.show();
}

方法内部类只能使用外部方法final常量：拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。

四.匿名内部类

1.使用匿名内部类时，必须是继承一个类或者实现一个接口
2.匿名内部类中是不能定义构造函数的
3.匿名内部类中不能存在任何的静态成员变量和静态方法
4.匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效
5.匿名内部类不能是抽象的，必须要实现继承的类或实现的接口中所有抽象方法

定义如下：

复制代码

1
2
3
4
new 父类构造器（参数列表）| 实现接口(){
//匿名内部类的类体部分

}

实例：根据value值排序Map

复制代码

public class SortValueMap {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<String, Double>();
map.put("包", 280.0);
map.put("手表", 1000.0);
map.put("计算机", 10000.0);
System.out.println("原始map: ");
List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(map.entrySet());
for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
Map.Entry<String, Double> mery = ite.next();
System.out.println(mery.getKey() + " -> " + mery.getValue());
}
// 匿名内部类，实现了Comparator接口
Collections.sort(list, new Comparator<Map.Entry<String, Double>>(){
@Override
public int compare(Entry<String, Double> o1,
Entry<String, Double> o2) {
// TODO Auto-generated method stub
return o1.getValue().compareTo(o2.getValue());
}
});
System.out.println("sort value map: ");
for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
Map.Entry<String, Double> mery = ite.next();
System.out.println(mery.getKey() + " -> " + mery.getValue());
}
}
}

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 SortValueMap {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<String, Double>();
map.put("包", 280.0);
map.put("手表", 1000.0);
map.put("计算机", 10000.0);
System.out.println("原始map: ");
List<Map.Entry<String, Double>> list = new ArrayList<Map.Entry<String, Double>>(map.entrySet());
for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
Map.Entry<String, Double> mery = ite.next();
System.out.println(mery.getKey() + " -> " + mery.getValue());
}
// 匿名内部类，实现了Comparator接口
Collections.sort(list, new Comparator<Map.Entry<String, Double>>(){
@Override
public int compare(Entry<String, Double> o1,
Entry<String, Double> o2) {
// TODO Auto-generated method stub
return o1.getValue().compareTo(o2.getValue());
}
});
System.out.println("sort value map: ");
for(Iterator<Map.Entry<String, Double>> ite = list.iterator(); ite.hasNext(); ){
Map.Entry<String, Double> mery = ite.next();
System.out.println(mery.getKey() + " -> " + mery.getValue());
}
}
}