黑马程序员-java-内部类

-------android培训、java培训、期待与您交流！ ----------

0.1.内部类

　　内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。　　(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。　　(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。　　(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

0.2.为什么需要内部类？

　　典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：

　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

1.成员内部类

public class Outer {
	class Inner {
	}
}

编译上述代码会产生两个文件：

Outer.class

Outer$Inner.class

2.方法内部类

class Outer {
	public void doSomething() {
		class Inner {
			public void seeOuter() {
			}
		}
	}
}

3.匿名内部类

3.1.继承式的匿名内部类

public class MainClass {
	public void print() {
		System.out.println("Outer MainClass");
	}

	public static void main(String[] args) {
		MainClass mainClass = new MainClass() {
			public void print() {
				System.out.println("Inner MainClass");
			}
		};
		mainClass.print();
	}
}

运行结果：Inner MainClass

3.2.接口式的匿名内部类

interface MainInterface {
	public void print();
}
public class MainClass {
	public static void main(String[] args) {
		MainInterface mainInterface = new MainInterface() {
			public void print() {
				System.out.println("MainInterface");
			}
		};
		mainInterface.print();
	}

}

运行结果：MainInterface

3.3.参数式的匿名内部类

class AidClass {
	void doPrint(MainInterface mi) {
		mi.print();
	}
}

interface MainInterface {
	public void print();
}

public class MainClass {
	public static void main(String[] args) {
		AidClass aidClass = new AidClass();
		aidClass.doPrint(new MainInterface() {
			public void print() {
				System.out.println("MainInterface");
			}
		});
	}
}

运行结果： MainInterface

4.静态嵌套类

class Outer {
	static class Inner {
	}
}

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

5.内部类连接到外部类

public class Outer {
	private String str = "Outer"; 
	public class Inner{
		void getStr(){
			System.out.println(str);
		}
	}
}

6.关键字.this与.new

public class Outer {
	private int num;

	public Outer() {

	}

	public Outer(int num) {
		this.num = num;
	}

	private class Inner {
		public Outer getOuter() {
			return Outer.this;
		}

		public Outer newOuter() {
			return new Outer();
		}
	}

	public static void main(String[] args) {
		Outer outer = new Outer(5);
		Outer.Inner inner = outer.new Inner();
		Outer outer2 = inner.getOuter();
		Outer outer3 = inner.newOuter();
		System.out.println(outer2.num);
		System.out.println(outer3.num);
	}
}

运行结果：

5
0

7.内部类与向上转型

public class Outer {
	private class InnerInterface implements OuterInterface{  
		public void print() {
			System.out.println("Outer InnerInterface print()");
		}  
	}
	
	public OuterInterface getOuterInterface(){  
	    return new InnerInterface();  
	}
	
	public static void main(String []args){  
		Outer outer = new Outer();  
		OuterInterface outerInterface = outer.getOuterInterface();  
		outerInterface.print();  
	}
}

interface OuterInterface {
	public void print();
}

运行结果：Outer InnerInterface print()