Java 中的内部类

Java 中的内部类

参考资料：

《Java SE 6.0 编程指南》 作者：吴亚峰 纪超    出版社：人民邮电出版社

《Thinking in Java Fourth Edition》 作者：Bruce Eckel

1、非静态内部类

1.1、语法规则

public class Outer {
    
    /**
     * 非静态内部类
     */
    class Inner {
        //内部类的成员
        int i = 1;
    }

    //外部类的普通成员
    int count = 2;

}

package innerclasses;

// Creating inner classes.

public class Parcel1 {
	
	class Contents {
	    private int i = 11;
	    public int value() { 
	    	return i; 
	    }
	}
	
	class Destination {
		private String label;
		Destination(String whereTo) {
			label = whereTo;
		}
		String readLabel() { 
			return label; 
		}
	}	
	
	// Using inner classes looks just like
	// using any other class, within Parcel1:
	public void ship(String dest) {
	    Contents c = new Contents();
	    Destination d = new Destination(dest);
	    System.out.println(d.readLabel());
	}
	
	public static void main(String[] args) {
		Parcel1 p = new Parcel1();
		p.ship("Tasmania");
	}
} /* Output:
Tasmania
*///:~

□ 内部类和外部类中的其他成员是一个级别的，其也是外部类的一个成员。

□ 在内部类也是一个单独的类，也有自己的成员变量和方法。
□ 内部类可以加上访问限制修饰符，包括 private、protected 和 public。

1.2、外部类之内创建内部类对象

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 内部类
	 */
	class Inner {
		
		/**
		 * 打印输出
		 */
		public void show() {
			System.out.println("调用内部类的show方法");
		}
		
	}
	
	/**
	 * 外部类的方法，创建内部类对象
	 */
	public void createInner() {
		//外部类中创建内部类对象
		Inner inner = new Inner();
		//调用内部类的方法
		inner.show();
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建外部类对象
		Outer outer = new Outer();
		//调用创建内部类对象的方法
		outer.createInner();
	}

}

□ 外部类中创建内部类对象的语法与普通创建对象的方法相同，使用 new 操作符调用构造器。

□ 对内部类而言，在其类体中也可以拥有类所能拥有的一切成员。

1.3、外部类之外创建内部类对象

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 内部类
	 */
	class Inner {
		/**
		 * 打印输出
		 */
		public void show() {
			System.out.println("调用内部类的show方法");
		}
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建外部类对象
		Outer outer = new Outer();
		//创建内部类对象
		Outer.Inner inner = outer.new Inner();
		Outer.Inner inner2 = new Outer().new Inner();
		//调用内部类中的方法
		inner.show();
		inner2.show();
	}

}

□ 在外部类之外声明内部类引用时，需用外部类名加以标识，不能直接使用内部类类名，而创建内部类对象时，需先创建外部类对象，再创建内部类对象。

1.4、内部类与外部类之间的成员互访

1.4.1、内部类中访问外部类成员

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/** 外部类的私有成员变量 */
	private int o = 1;
	
	/**
	 * 内部类
	 */
	class Inner {
		/**
		 * 打印输出外部类的私有成员
		 */
		public void show() {
			System.out.println("外部类的私有成员变量o = " + o);
		}
	}

	public int getO() {
		return o;
	}

	public void setO(int o) {
		this.o = o;
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建内部类对象
		Outer.Inner inner = new Outer().new Inner();
		//调用内部类中的方法
		inner.show();
	}

}

1.4.2、外部类中访问内部类成员

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 内部类
	 */
	class Inner {
		/**
		 * 打印输出
		 */
		private void show() {
			System.out.println("成功访问内部类的私有方法");
		}
	}
	
	/**
	 * 创建内部类对象并调用其方法
	 */
	public void getInner() {
		//创建内部类对象
		Inner inner = new Inner();
		//访问内部类私有方法
		inner.show();
	}

}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建外部类对象，并调用创建内部类方法
		Outer outer = new Outer();
		outer.getInner();
	}

}

1.5、内部类与外部类的预定义对象引用 this

□ 内部类中需要使用外部类对象的 this，语法如下：<外部类名>.this.<外部类中需要被访问的成员名>。

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/** 外部类成员变量 */
	int i = 1;
	
	/**
	 * 内部类
	 */
	class Inner {
		
		/** 内部类与外部类同名成员变量 */
		int i = 10;
		
		/**
		 * 输出外部类和内部类的成员变量
		 */
		public void show() {
			//访问外部类的成员变量
			System.out.println("外部类的成员变量 i = " + Outer.this.i);
			//访问内部类的成员变量
			System.out.println("内部类的成员变量 i = " + this.i);
		}
		
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建内部类对象
		Outer.Inner innerr = new Outer().new Inner();
		//调用内部类方法
		innerr.show();
	}

}

package innerclasses;

// Qualifying access to the outer-class object.

public class DotThis {
	void f() { 
		System.out.println("DotThis.f()"); 
	}
	
	public class Inner {
		public DotThis outer() {
			return DotThis.this;	// A plain "this" would be Inner's "this"
		}
	}
	
	public Inner inner() { 
		return new Inner(); 
	}
	
	public static void main(String[] args) {
	    DotThis dt = new DotThis();
	    DotThis.Inner dti = dt.inner();
	    dti.outer().f();
	}
} /* Output:
DotThis.f()
*///:~

1.6、内部类的继承

package innerclasses;

// Inheriting an inner class.

class WithInner {
	class Inner {}
}

public class InheritInner extends WithInner.Inner {
	public InheritInner(WithInner inner) {
		inner.super();	//若跳过外部类直接继承内部类，必须使用此语法才能编译通过
	}
	
	public static void main(String[] args) {
		WithInner wi = new WithInner();
		InheritInner ii = new InheritInner(wi);
	}
}

2、局部内部类

2.1、局部内部类的定义及创建

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 声明并创建内部类对象
	 */
	public void getInner() {
		
		/**
		 * 内部类
		 */
		class Inner {
			/**
			 * 输出
			 */
			public void show() {
				System.out.println("内部类的show()方法");
			}
		}
		
		//创建内部类对象并调用其方法
		Inner inner = new Inner();
		inner.show();
		
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建外部类对象
		Outer outer = new Outer();
		//调用外部类方法
		outer.getInner();
	}

}

2.2、局部变量与局部内部类

package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 声明并创建内部类对象
	 */
	public void getInner() {
		
		/** 定义局部变量 */
		final int i = 2;
		
		/**
		 * 内部类
		 */
		class Inner {
			/**
			 * 输出
			 */
			public void show() {
				System.out.println("方法中的局部变量 i = " + i);
			}
		}
		
		//创建内部类对象并调用其方法
		Inner inner = new Inner();
		inner.show();
		
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建外部类对象
		Outer outer = new Outer();
		//调用外部类方法
		outer.getInner();
	}

}

□ 局部变量与局部内部类。普通局部变量随着语句块的结束而消亡，而创建的局部类对象则不会。如果在语句块结束后，调用了局部内部类对象中访问普通局部变量的方法，就会出现问题，因为要访问的局部变量已经不存在了。
□ final 的局部变量不会因为语句块的结束而消失，因此可以被局部内部类访问。

2.3、静态方法中的局部内部类

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/** 外部类的静态成员变量 */
	static int i = 7;
	
	/**
	 * 声明并创建内部类对象
	 */
	public static void getInner() {
		/**
		 * 内部类
		 */
		class Inner {
			/**
			 * 输出
			 */
			public void show() {
				System.out.println("方法中的局部变量 i = " + i);
			}
		}
		//创建内部类对象并调用其方法
		Inner inner = new Inner();
		inner.show();
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//调用外部类静态方法
		Outer.getInner();
	}

}

□ 若局部类位于静态方法中，则只能访问外部类的静态成员，这与静态方法访问成员的规则是一致的。

3、静态内部类

3.1、创建静态内部类的对象

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 静态内部类
	 */
	static class Inner {
		/**
		 * 输出
		 */
		public void show() {
			System.out.println("静态内部类的show()方法");
		}
	}
	
	/**
	 * 声明并创建内部类对象
	 */
	public void getInner() {
		//创建内部类对象并调用其方法
		Inner inner = new Inner();
		inner.show();
	}
	
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//外部类之外创建静态内部类对象
		Outer.Inner inner = new Outer.Inner();
		inner.show();
		//外部类中使用静态内部类对象
		new Outer().getInner();
	}

}

□ 外部类之外创建静态内部类对象的语法如下：<外部类类名>.<内部类类名> 引用变量 = new <外部类类名>.<内部类构造器>;
□ 静态内部类也可以称为静态嵌套类，或顶级嵌套类。由于创建静态内部类的对象已不需要外部类对象的存在，静态内部类其实只是一个在别的类中的一个普通类而已。static 关键字只是说明其创建对象时不依赖于外部类对象，并不表示这个类是静态的。

4、匿名内部类

□ 匿名内部类没有类名，因此匿名内部类在声明的同时也创建了对象。
□ 匿名内部类的声明要么是基于继承的，要么是基于接口实现的。

4.1、基于继承的匿名内部类

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 父类
 */
class Father {
	public void show() {
		System.out.println("父类中的show()方法");
	}
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//定义匿名内部类并创建其对象，并重写父类中的方法
		Father father = new Father() {
			public void show() {
				System.out.println("重写父类的show()方法");
			}
		};
		//访问匿名内部类中重写的方法
		father.show();
	}

}

□ 访问匿名内部类成员均是通过多态完成的，因为匿名内部类无法创建自身类型的引用。

4.2、基于接口实现的匿名内部类

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 定义接口
 */
interface MyInterface {
	void show();
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//定义匿名内部类并创建其对象，并实现接口中的方法
		MyInterface mi = new MyInterface() {
			@Override
			public void show() {
				System.out.println("实现接口的show()方法");
			}
		};
		//访问匿名内部类中实现的方法
		mi.show();
	}

}

□ 匿名内部类要么实现一个接口，要么继承一个类，不能同时既实现接口又进行继承。

4.3、匿名内部类的初始化

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 定义抽象类
 */
abstract class Father {
	int i;
	abstract void show();
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//定义匿名内部类并创建其对象
		Father mi = new Father() {
			
			//使用非静态块初始化成员
			{
				i = (int) (Math.random() * 100);
			}
			
			//重写抽象类中的方法
			@Override
			public void show() {
				System.out.println("初始化的成员i = " + i);
			}
		};
		
		//访问匿名内部类中实现的方法
		mi.show();
	}

}

□ 匿名内部类对象的初始化代码写在非静态语句块中。

package innerclasses;

// An anonymous inner class that performs initialization. 

interface Destination {
	String readLabel();
} 

public class Parcel9 {
 	// Argument must be final to use inside anonymous inner class:
	public Destination destination(final String dest) {
		return new Destination() {
			private String label = dest;
			
			@Override
			public String readLabel() { 
				return label; 
			}
		};
	}
	
	public static void main(String[] args) {
		Parcel9 p = new Parcel9();
		Destination d = p.destination("Tasmania");
	}
} 

□ 从外部传递给匿名内部类的参数，必须是 final 的。

5、内部接口

5.1、定义在类中的内部接口

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 外部类
 */
class Outer {
	
	/**
	 * 非静态内部接口
	 */
	public interface InnerInterface {
		void show();
	}
	
	/**
	 * 实现内部接口的内部类
	 */
	public class Inner implements InnerInterface {
		@Override
		public void show() {
			System.out.println("内部类实现内部接口的show()方法");
		}
	}
	
	/**
	 * 获取内部类对象的方法
	 * @return
	 */
	public InnerInterface getInner() {
		return new Inner();
	}
	
}

/**
 * 实现内部接口的普通类
 */
class Normal implements Outer.InnerInterface {
	@Override
	public void show() {
		System.out.println("普通类实现了内部接口的show()方法");
	}
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		Outer outer = new Outer();	//创建外部类对象
		Outer.InnerInterface oic = outer.getInner();	//获取内部类对象
		oic.show();	//访问内部类的show()方法
		oic = new Normal();		//获取普通类的对象
		oic.show();	//访问普通类的show()方法
	}

}

□ 内部接口无论是否使用 static 修饰，扮演的都是静态成员。

5.2、定义在接口中的内部接口

/**
 * 
 */
package com.aimartt.innerclass;

/**
 * 外部接口
 */
interface OuterInterface {
	
	/**
	 * 内部接口
	 */
	public interface InnerInterface {
		void inShow();
	}
	
	/**
	 * 外部接口的方法
	 */
	void outShow();
	
}

/**
 * 实现外部接口的类
 */
class OuterInterfaceImpl implements OuterInterface {
	@Override
	public void outShow() {
		System.out.println("实现外部接口的outShow()方法");
	}
}

/**
 * 实现内部接口的类
 */
class InnerInterfaceImpl implements OuterInterface.InnerInterface {
	@Override
	public void inShow() {
		System.out.println("实现内部接口的inShow()方法");
	}
}

/**
 * 主类
 */
public class Demo {

	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		//创建实现内部接口和外部接口的类的对象
		OuterInterface.InnerInterface inner = new InnerInterfaceImpl();
		OuterInterface outer = new OuterInterfaceImpl();
		//调用两个对象的方法
		inner.inShow();
		outer.outShow();
	}

}

□ 内部接口只是把普通接口放到了一个接口内部，在使用上没有很大的不一样，实现内部接口与普通接口的具体方法完全一样。