javaSE之各种内部类详解

在java中，内部类主要分为四种：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

成员内部类

成员内部类要注意：

1. 成员内部类中不能存在任何static的变量和方法
2. 成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类

举个例子：

public class Test{
	public Test(){
		System.out.println("这是一个类");
	}
	public static void main(String[] args) {
		new Test();
		new Test().new Test2().test();
	}
	class Test2{
		public void test(){
		System.out.println("这是一个成员内部类");
		}
	}
}

Test2在Test这个类里面，更像是Test的成员，所以Test2是成员内部类，而Test是外部类，成员内部类可以无条件的访问外部类的所有成员属性和成员方法。包括私有成员和静态成员。

运行结果如下：

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：

静态内部类

静态内部类就是用static修饰的内部类，它区别的其他内部类的地方在于，静态内部类不依赖于外围类，可以直接创建，当然静态内部类不可以使用任何外部类的非静态属性和方法，但内部类可以。

这一点其实也很容易想，一旦这个类被static所修饰，那么这个类就不依赖于外部类了，这样的话，可以直接访问这个类，一旦在静态内部类中引用了外部类的非静态属性和成员的话，就会与外部的非静态所矛盾，因此在静态内部类中不能使用任何外部类的非静态属性和方法。

外部类的创建语法：

外部类.内部类 内部类对象 = new 外部类.内部类();

还是看个例子吧：

class Outer{
	private static String msg = "Hello World" ;

	static class Inner{ //定义一个静态内部类
		public void print(){ //此时只能使用外部类中的static操作
			System.out.println(msg); //调用msg属性
		}
	}
	
//在外部类中定义一个方法
	public void fun(){
	Inner in = new Inner(); //内部类对象
	in.print(); // 内部类提供的print()方法
	}
}
public class Test{
	public static void main(String[] args) {
		Outer.Inner in = new Outer.Inner();//这条语句非常重要
		in.print();
	}
}

静态内部类的定义很简单，就是在内部类前加上static关键字，而需要掌握的是在外部类中如何使用静态内部类。

方法内部类

方法内部类，从名字上就大概知道了它的定义了，就是在外部方法里面定义的类
要注意的是方法内部类只能在方法中使用，出了这个方法就无法再继续使用
那么为什么会需要方法内部类呢？主要是为了方便我们去解决一些比较复杂的问题，起到一个辅助的作用，但同时又不想让别的类访问到这个类，就引入了局部内部类的概念。

需要注意以下几点：

1. 局部内类不允许使用访问权限修饰符 public private protected 均不允许
2. 局部内部类对外完全隐藏，除了创建这个类的方法可以访问它其他的地方是不允许访问的。
3. 局部内部类要想使用方法形参，该形参必须用final声明(JDK8形参变为隐式final声明).

还是看例子理解：

class Outter {
	private int num;
	public void display(int test) {//只作用于方法内部
	class Inner {//定义了一个方法内部类
		private void fun() {
			num++;
			System.out.println(num);
			System.out.println(test);
		}
	}
	new Inner().fun();//在这个方法里面使用方法内部类
	}
}
public class Test {
	public static void main(String[] args) {
		Outter out = new Outter();
		out.display(20);
	}
}

匿名内部类

匿名内部类其实就是一个没有名字的方法内部类，也是在外部类的方法里面的，符合方法内部类的所有约束，但同时应注意以下几点：

1. 匿名内部类是没有访问修饰符的。
2. 匿名内部类必须继承一个抽象类或者实现一个接口
3. 匿名内部类中不能存在任何静态成员或方法
4. 匿名内部类是没有构造方法的，因为它没有类名。
5. 与局部内部相同匿名内部类也可以引用方法形参。此形参也必须声明为 final

下面简单解释一下：

1.没有访问修饰符，这一点应该很容易理解，因为匿名内部类是在方法内部的，外部是无法访问的，所以无需访问修饰符
2.匿名内部类中不能存在任何静态成员，这一点与成员内部类是一样的，上面解释过，这里不多说
3.没有构造方法，这个我们想想构造方法的定义，构造方法名必须与类名相同，而匿名内部类根本就没有类名，自然也就没有构造方法了

例子：

interface MyInterface {
	void test();
}
class Outter {
	private int num;
	public void display(int para) {
// 匿名内部类，实现了MyInterface接口
		new MyInterface(){
			@Override
			public void test() {
				System.out.println("匿名内部类"+para);
			}
		}.test();
	}
}
public class Test {
	public static void main(String[] args) {
		Outter outter = new Outter();
		outter.display(20);
	}
}