内部类

1.成员内部类

public class OuterClass {
	class innerClass implements OutInterface1{
		innerClass(){
			//内部类构造方法
		}
		public void inf(){
			//内部类成员方法
		}
		int y = 0;
	}
	innerClass in = new innerClass();//在外部类实例化内部类对象
	public void ouf(){
		in.inf();//在外部类方法中调用内部类方法
	}
	public innerClass doit(){  //外部类方法，返回值为内部类引用
		//y=4;   //外部类不可以直接访问内部类的成员变量
		in.y=4;  
		return new innerClass(); //返回内部类引用
	}
	public static void main(String args[]){
		OuterClass out = new OuterClass();
		//内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
		OuterClass.innerClass in = out.doit();
		OuterClass.innerClass in2 = out.new innerClass();
	}
}

2.内部类向上转型为接口

interface OutInterface{  //定义一个接口
	public void f();
}
interface OutInterface2{  //定义一个接口
}
class OuterClass2{//内部类实现OutInterface接口
	private class InnerClass implements OutInterface{
		InnerClass(String s){//内部类构造方法
			System.out.println(s);
		}
		public void f(){  //实现接口中的f()方法
			System.out.println("访问内部类中的f()方法");
		}
		public void inf(){
			//内部类成员方法
			System.out.println("内部类成员方法");
		}
	}
	public OutInterface doit(){  //定义一个方法，返回值类型为OutInterface接口
		return new InnerClass("访问内部类构造方法");
	}
}
class OuterClass3{//局部内部类
	public OutInterface2 doit(final String x){//doit()方法参数类型为final类型
		//在doit（）方法中定义一个内部类
		class InnerClass2 implements OutInterface2{
			InnerClass2(String s){
				s = x;
				System.out.println(s);
			}
		}
		return new InnerClass2("doit");
	}
}
class OuterClass4{//匿名内部类
	public OutInterface2 doit(){//定义doit()方法
		return new OutInterface2(){//声明匿名内部类
			private int i = 0;
			public int getValue(){
				return i;
			}
		};
	}
}
public class InterfaceInner {
	public static void main(String args[]){
		OuterClass2 out = new OuterClass2();//实例化一个OuterClass2对象
		OutInterface outinter= out.doit();//调用doit()方法，返回一个OutInterface接口
		outinter.f();//调用f()方法
	}
}

3.静态内部类

可以不依赖于外部实例而被实例化，只能访问外部类中的静态成员和静态方法。