Java编程思想-内部类

.this:生成对外部类对象的引用，格式：外部类名字后面跟着圆点和this

package thinking.java.chapter10;

public class DoThis {
void f() {
	System.out.println("DoThis.f()");
}
public class Inner{
	public DoThis outer() {
		return DoThis.this;//产生对外部类对象的引用
	}
}
public Inner inner() {
	return new Inner();
}
	public static void main(String[] args) {
		DoThis dt = new DoThis();
		DoThis.Inner dti = dt.inner();
		dti.outer().f();
	}

}

.new:告知某些对象去创建其内部类的对象

注意：在拥有外部类对象之前是不能创建内部类对象的，即内部类对象的创建要依赖于外部类的对象。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。但是如果创建的是嵌套类（静态内部类），那么它就不需要对外部类对象的引用，因为静态是属于外部类类而不是外部类的对象的。类似于静态变量。

练习6：

package thinking.java.chapter091;

public interface InterfaceChapter10 {
public String say();
}

package thinking.java.chapter09;

import thinking.java.chapter091.InterfaceChapter10;

public class ExeBase {
protected class ExeInner implements InterfaceChapter10{
	public ExeInner(){}
	@Override
	public String say() {
		// TODO Auto-generated method stub
		return "hello";
	}
	
}
}

package thinking.java.chapter10;

import thinking.java.chapter091.InterfaceChapter10;

public class Exe6 extends thinking.java.chapter09.ExeBase {
	public InterfaceChapter10 getExeBase() {
	return this.new ExeInner();
}
	public static void main(String[] args) {
		Exe6 e = new Exe6();
		System.out.println(e.getExeBase().say());
	}

}

package thinking.java.chapter10;

public class Outer7 {
private String s = "hello";
private void hello() {System.out.println("String outer");}
class Inner7{
	public void modify7(){
		s = "hi";
		hello();
	}
}
public void testInner() {
	Inner7 i = new Inner7();
	i.modify7();
}
	public static void main(String[] args) {
		Outer7 o7 = new Outer7();
		o7.testInner();
	}

}

package thinking.java.chapter10;

public class Outer8 {
class Inner8{
	private int ii1 = 1;
	private int ii2 = 2;
	private void showIi2() { System.out.println(ii2); }
	private void hi() { System.out.println("Inner hi"); }
}
int oi = new Inner8().ii1;
public void showOi() {
	System.out.println(oi);
}
public void showIi2() {
	new Inner8().showIi2();
}
public void showhi() {
	new Inner8().hi();
}
	public static void main(String[] args) {
		Outer8 o8 = new Outer8();
		o8.showOi();
		o8.showIi2();
		o8.showhi();
	}

}

package thinking.java.chapter10;
interface Ex9Interface{
	public void f(String s);
}
public class Outer9 {
	Ex9Interface fi() {
		class Inner9 implements Ex9Interface{
			public void f(String s) {
				System.out.println(s);
			}
		}
		return new Inner9();
	}
	public static void main(String[] args) {
		Outer9 o9 = new Outer9();
		o9.fi().f("tiffany");;
	}

}

package thinking.java.chapter10;
interface ExInterface10{
	public void f(String s);
}
public class Outer10 {
	ExInterface10 fi(boolean b) {
		if(b) {
			class Inner10 implements ExInterface10{
				public void f(String s) {
					System.out.println(s);
				}
			}
			return new Inner10();
		}
		return null;
	}
	public static void main(String[] args) {
		Outer10 o10 = new Outer10();
		o10.fi(true).f("tiffany");
	}

}

package thinking.java.chapter10;
class Test11{
	private class Inner11 implements ExeInterface11{

		@Override
		public void f(String s) {
			System.out.println(s);
		}
		
	}
	ExeInterface11 fi() {
		return new Inner11();
	}
}
public class Outer11 {
	public static void main(String[] args) {
		Test11 t = new Test11();
		t.fi().f("tiffany");;
		((Inner11)t.fi()).f("tiffany");//无法进行向下转型，因为内部类被隐藏了
	}

}

匿名内部类：在创建一个对象时，却插入了一个类的定义