4种Java内部类

发表于 更新于 分类于 阅读次数： 本文字数： 3.3k 阅读时长 ≈ 3 分钟

By Long Luo

一个类的定义放在另一个类的定义内部，这就是**内部类*。

先来段代码，对内部类有个直观认识：

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
public class OuterClass {
    private String name ;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    class InnerClass{
        public InnerClass(){
            name = "chenssy";
            age = 23;
        }
    }
}

在这里InnerClass就是内部类。

Java中有4种不同类型的Java内部类，下面我们将一一用实例来介绍：

1. 静态内部类(static nested classes)

关键字static可以修饰成员变量、方法、代码块，还可以修饰内部类，而使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。

静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

  1. 它的创建是不需要依赖于外围类的。
  2. 它不能使用任何外围类的非static成员变量和方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Outer {
	static class Inner {
		void go() {
			System.out.println(" Inner class reference is: " + this);
		}
	}
}

public class Test {
	public static void main(String[] args) {
		Outer.Inner n = new Outer.Inner();
		n.go();
	}
}

Output:

1
Inner class reference is: com.longluo.java.interview.innerclass.Outer$Inner@15db9742

2. 成员内部类(member inner class)

成员内部类是外围类的一个成员，所以是可以无限制的访问外围类的所有成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点：

  1. 成员内部类中不能存在任何static的变量和方法；
  2. 成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MemberInnerClass {
	private int x = 100;

	public void makeInner() {
		Inner in = new Inner();
		in.seeOuter();
	}

	class Inner {
		public void seeOuter() {
			System.out.println("MemberInnerClass x is " + x);
			System.out.println("Inner class reference is " + this);
			System.out.println("Outer class reference is "
					+ MemberInnerClass.this);
		}
	}

	public static void main(String[] args) {
		MemberInnerClass o = new MemberInnerClass();
		Inner i = o.new Inner();
		i.seeOuter();
	}
}

输出为：

1
2
3
MemberInnerClass x is 100
Inner class reference is com.longluo.java.interview.innerclass.MemberInnerClass$Inner@15db9742
Outer class reference is com.longluo.java.interview.innerclass.MemberInnerClass@6d06d69c

3. 局部内部类(method-local inner classes)

有这样一种内部类，它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Outer {
	private String x = "outer";

	public void doStuff() {
		class MyInner {
			public void seeOuter() {
				System.out.println(" x is " + x);
			}
		}
		MyInner i = new MyInner();
		i.seeOuter();
	}

	public static void main(String[] args) {
		Outer o = new Outer();
		o.doStuff();
	}
}
1
x is outer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MethodOuter {

	private static String x = "static outer";

	public static void doStuff() {
		class MyInner {
			public void seeOuter() {
				System.out.println(" x is " + x);
			}
		}
		MyInner i = new MyInner();
		i.seeOuter();
	}

	public static void main(String[] args) {
		MethodOuter.doStuff();
	}
}
1
x is static outer

4. 匿名内部类(anonymous inner classes)

在Swing或者Android编程中，经常被用来添加一个动作监听器，如下所示：

1
2
3
4
5
6
button.addActionListener(new ActionListener() {
	@Override
	public void actionPerformed(ActionEvent e) {
		comp.setText("Button has been clicked");
	}
});

需要注意的几个地方：

  1. 匿名内部类是没有访问修饰符的。
  2. new匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。
  3. 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。
  4. 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。