JAVA语法之----内部类

一、内部类的定义
放在一个类的内部的类我们就叫内部类.

二、作用与特点
1、内部了可以很好的实现隐藏
一般的非内部类，是不允许有private与protected权限的，但内部类可以
2、可以实现多重继承
3、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。
B、内部类用户其宿主的所有元素的访问权限

以下我们会对如下几个问题进行分析，另贴出相应的代码
1、分析内部类是否可以直接被创建（实例化）？
2、内部类外部类成员的访问权限？
3、匿名内部类

[color=red]通过这个例子我们来熟悉内部类，并说明内部类无法直接被创建，必须通过其宿主来进行实例化。
[/color]

/**
 * 宿主类
 */
public class OuterClass {
	public InnerClass innerClass = new InnerClass();

	/**
	 * 内部类
	 */
	public class InnerClass {
		public String name;

		public InnerClass(){
			name = "InnerClass's name....";
		}
	}

	public static void main(String[] args) {
		/**
		 * 错误！！！ 编译器会报错
		 * 不能通过new的方式直接实例化内部类
		 */
		// InnerClass innerClass = new InnerClass();  

		/**
		 * 正确，只能通过宿主来创建内部类
		 */
		InnerClass innerClass = new OuterClass().innerClass;

		//或者
		innerClass = new OuterClass().new InnerClass()

		System.out.println(innerClass.name);
	}
}

2、内部类对外部类成员的访问权限

/**
 * 外部类
 */
public class OuterClass {

	private String privateName = "";   //外部类private成员
	protected String protectedName = "";   //外部类protected成员
	public String publicName = "";   //外部类public成员

	public OuterClass (){
		privateName = "private ";
		protectedName = "protected ";
		publicName = "public ";
	}

	/**
	 * 内部类
	 */
	public class InnerClass {
		public String publicName = "InnerClass publicName...";   //内部类public成员
		protected String protectedName = "InnerClass ProtectedName...";//内部类protected成员
		private String privateName = "InnerClass privateName...";//内部类private成员

		public InnerClass(){
			InnerClass.this.publicName += OuterClass.this.privateName;     //访问外部类私有成员
			InnerClass.this.publicName += OuterClass.this.protectedName;	 //访问保护成员
			InnerClass.this.publicName += OuterClass.this.publicName;		 //访问外部类共有成员
			print(); //引用外部类私有方法
		}
	}
	//内部类可以直接访问外部类的所有权限的方法
	private void print(){
		System.out.println("---OuterClass print...");
	}

	//外部类的非静态方法访问内部类
	public void not_static_method(){
		InnerClass innerClass = new InnerClass();
		System.out.println(innerClass.publicName + " " + innerClass.privateName);  //可以看到
	}

	//外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
	public static void static_method(){
		System.out.println(new OuterClass().new InnerClass().publicName);
	}

	public InnerClass getInnerClass() {
		return new InnerClass();
	}

	public static void main(String[] args) {
		OuterClass out = new OuterClass();
		InnerClass innerClass = out.new InnerClass(); //.getInnerClass();
		System.out.println(innerClass.publicName);
		out.not_static_method();

	}
}

[color=red]通过该例子可以看到
内部类拥有外部类成员,以及外部类的所有方法的访问权限。
外部类的静态方法与其他外部访问内部类的权限一样，非静态方法拥有内部类成员的所有访问权限[/color]

3、匿名内部类，引用自http://topic.csdn.net/u/20080728/20/d60f719a-c103-44b8-8d0c-bc1c818b768a.html
匿名内部类没有名字，所以我们无从给它指定构造方法（构造方法必须和类名同名）但是匿名内部类可以通过直接调用父类的构造方法实现初始化
例子说明一切

public class Main {

    public static void main(String[] args) {
        InnerTest inner = new InnerTest();
        Test t = inner.get(3);
        System.out.println(t.getI());
    }
}

class Test {  //超类
    private int i;
    public Test(int i) {
        this.i = i;
    }
    public int getI() {
        return i;
    }
}

class InnerTest {  //用于内部类的测试
    public Test get(int x) {
        return new Test(x) {  //创建匿名内部类，调用父类的构造方法
            @Override
            public int getI() {
                return super.getI() * 10;
            }
        };
    }
}