Java内部类

Java内部类基础学习

定义：

将一个类的定义放在另一个类的定义内部。

为什么需要内部类？

一般来说，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象，所以可以认为内部类提供了某种进入其外围类的窗口。
每个内部类都能独立地继承自一个实现，所有无论外围类是否已经继承了某个实现，对于内部类都没有影响。
内部类具有继承多个具体或者抽象的类的能力，是多继承解决方案变得完整，解决了一些设计与编程问题。
使用内部类可获得一些特性：

• 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
• 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。
• 创建内部类对象的时刻并不依赖于外围类对象的创建。
• 内部类并没有令人疑惑的“is-a”关系，它就是一个独立的实体。

访问特点：

• 内部类可以直接访问外部类中的成员，包括私有成员。
• 之所以可以访问，是因为内部类中持有了一个外部类的引用：外部类名.this
• 外部来要访问内部类中的成员就必须建立内部类的对象。

//示例代码:-
public class Parcel1 {
	class Destination{
		private String label;
		Destination(String whereTo){
			label = whereTo;
		}
		String realLabel() {
			return label;
		}
	}
	//Using inner class looks just like using any other class , within Parcel1;
	public void ship(String dest) {
		Destination d = new Destination(dest);
		System.out.println(d.realLabel());
	}
	public static void main(String[] args) {
		Parcel1 p = new Parcel1();
		p.ship("Tasmania");
	}
}
//Tasmania

创建内部类对象

在外部类的非静态方法创建中内部类对象
如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，
那么必须具体地指明这个对象的类型：OuterClassName.InnerClassName.

//示例
OuterClassName.InnerClassName inn = new OuterClassName.InnerClassName();

当生成一个内部类的对象时，此对象与制造它的外围对象之间就产生了一种联系，它不需要任何特殊条件就能访问其外围对象的所有成员，内部类还拥有其外围类的所有元素的访问权。

//代码示例：
//:innerclass/Squence.java
//Holds a sequence of Objects.
interface Selector{
	boolean end();
	Object current();
	void next();
}
public class Sequence {
	private Object[] items;
	private int next = 0;
	public Sequence(int size) {
		items = new Object[size];
	}
	public void add(Object x) {
		if(next<items.length) {
			items[next++] = x;
		}
	}
	private class SequenceSelector implements Selector{
		private int i = 0;
		public boolean end() {
			return i == items.length;
		}
		public Object current() {
			return items[i];
		}
		public void next() {
			if(i<items.length) i++;
		}
	}
	public Selector selector() {
		return new SequenceSelector();
	}
	public static void main(String[] args) {
		Sequence sequence = new Sequence(10);
		for(int i = 0;i<10;i++)
			sequence.add(Integer.toString(i));
		Selector selector = sequence.selector();
		while(!selector.end()) {
			System.out.print(selector.current()+" ");
			selector.next();
		}
	}
}
//0 1 2 3 4 5 6 7 8 9

.this与.new

.this:生成对外部类对象的引用，可以使用外部类的名字后面紧跟点和this。

//示例代码：
//:innerclasses/DotThis.java
// 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();
	}
}
//DotThis.f()

.new:通过某些其他对象去创建其某个内部类的对象，你必须在new表达式中提供对其他外部类对象的引用

//:innerclass/DotNew.java
//Creating an inner class directly using the .new syntax.
public class DotNew {
	public class Inner{}
	public static void main(String[] args) {
		DotNew dn = new DotNew();
		DotNew.Inner dni = dn.new Inner();
	}
}

内部类对象会连接到创建它的外部类对象上，在拥有外部类之前是不可能创建内部类对象的。嵌套类（静态内部类）除外。

内部类向上转型

将内部类向上转型为其基类（包括接口），private内部类隐藏了实现细节，并且不可用，所得到的只是指向基类或者接口的引用。

//示例代码：
//:innerclasses/TestParcel.java
interface Destination{
	String readLabel();
}
interface Contents{
	int value();
}
class Parcel4{
	private class PContents implements Contents{
		private int i = 11;
		public int value() {
			return i;
		}
	}
	protected class PDestination implements Destination{
		private String label;
		private PDestination(String whereTo) {
			label = whereTo;
		}
		public String readLabel() {
			return label;
		}
	}
	public Destination destination(String s) {
		return new PDestination(s);
	}
	public Contents contents() {
		return new PContents();
	}
}

public class TestParcel{
	public static void main(String[] args) {
		Parcel4 p = new Parcel4();
		Contents c = p.contents();
		Destination d = p.destination("Tasmania");
	}
}

定义在方法和作用域中的内部类

创建一个类来辅助解决复杂的问题，又不希望这个类是公共可用的。
局部内部类不能有访问说明符，因为它不是外围类的一部分；当时它可以访问当前代码块内的常量，以及此外围类的所有成员。
内部类定义在局部时：
1.不可以被成员修饰符修饰，例如static
2.可以直接访问外部类中的成员，因为还持有外部类的引用，但是不可以访问它所在的局部的变量。只能访问被final修饰的局部变量。如下代码：

class Outer
{
	int x = 3;
	void method(){
		final int y = 4 ; //y必须是final的
		class Inner{
			void function(){
				System.out.println(y);
			}
		}
	}
}

匿名内部类

//示例代码
//Returning an instance of an anonynous inner class.
public class Parcel7 {
	public Contents contents() {
		return new Contents() {
			private int i = 11;
			public int value() {
				return i;
			}
		};//semicolon required in this case 本例中需要分号.
	}
	public static void main(String[] args) {
		Parcel7 p = new Parcel7();
		Contents c = p.contents();
	}
}

本例中，contents()方法将返回值的生成与表示这个返回值的类的定义结合在一起，这个类是匿名的。
注意，分号“;”不能漏写。
创建一个继承自Contents的匿名类的对象，通过new表达式返回的引用被自动向上转型为对Contents的引用。

//上述代码未简化形式
public class Parcel7b {
	class MyContents implements Contents{
		private int i = 11;
		public int value() {
			return i;
		}
	}
	public Contents contents() {
		return new MyContents();
	}
	public static void main(String[] args) {
		Parcel7b p = new Parcel7b();
		Contents c = p.contents();
	}
}

如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用时final的，否则会产生编译时错误消息。

//示例代码：
public class Parcel9 {
	/*
	 * *
	 * 定义匿名内部类，参数引用类型为final
	 */
	public Destination destination(final String dest) {
		return new Destination() {
			private String label = dest;
			public String readLabel() {
				return label;
			}
		};
	}
	public static void main(String[] args) {
		Parcel9 p = new Parcel9();
		Destination d  = p.destination("Tasmania");
	}
}

匿名内部类没有命名构造器，因为它根本没名字，但是通过示例初始化就能够达到为匿名内部类创建一个构造器的效果：

//示例代码：
//anonymous匿名 美 /ə'nɑnəməs/      constructor构造器
//instance实例     initializer初始化器 美 /ɪ'nɪʃəlaɪz/
abstract class Base{
	public Base(int i) {
		System.out.println("Base constructor,i="+i);
	}
	public abstract void f();
}
public class AnonymousConstrctor {
	public static Base getBase(int i) {
		return new Base(i) {
			{System.out.println("Inside instance initializer");}
			public void f() {
				System.out.println("In anonymous");
			}
		};
		
	}
	public static void main(String[] args) {
		Base base = getBase(47);
		base.f();
	}
}
/*
Base constructor,i=47
Inside instance initializer
In anonymous
*/

在此例中，变量i不是final的，因为i被传递给匿名类的基类的构造器，它并不会在匿名内部类中被直接使用。
对于匿名类而言，示例初始化的实际效果就是构造器，但是你不能重载实例初始化方法也就是说你仅有这样一个构造器。
匿名内部类相对常规继承而言有些受限，因为匿名内部类既可以扩展类也可以实现接口但是不能两者兼备，如果是实现接口，也只能实现一个接口。

嵌套类（静态内部类）

当内部类被static修饰后，就只能直接访问外部类中的static成员，出现访问局限。
嵌套类意味着：
1)要创建嵌套类的对象，并不需要其外围类的对象。
2）不能从嵌套类的对象中访问非静态的外围类对象。

• 在外部其它类中直接访问static内部类的非静态成员：
  new Outer.Inner().function();
• 在外部其它类中直接访问static内部类的静态成员：
  Outer.Inner.function();
  注意：
• 当内部类中定义了静态成员，该内部类必须是static的。
• 当外部类中的静态方法访问内部类是，内部类也必须是static的才能访问。

public class Parcel11 {
	private static class ParcelContents implements Contents{
		private int i = 11;
		public int value() {
			return i;
		}
	}
	protected static class ParcelDestination implements Destination{
		private String label;
		private ParcelDestination(String whereTo) {
			label = whereTo;
		}
		public String readLael() {
			return label;
		}
		public static void f() {};
		static int x = 10;
		static class AnotherLevel{
			public static void f() {}
			static int x = 10;
		}
	}
	public static Destination destination(String s) {
		return new ParcelDestination(s);
	}
	public static Contents contents() {
		return new ParcelContents();
	}
	public static void main(String[] args) {
		Contents c = contents();
		Destination d = destination("Tasmanis");
	}
}

接口内部的类

正常情况下，不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分。放在接口中的任何类都自动的是public和static的，甚至可以在内部类中实现其外围接口：

//示例代码：
import ClassInInterface.Test;

public interface ClassInInterface{
	void howdy();
	class Test implements ClassInInterface{
		public void howdy() {
			System.out.println("Howdy");
		}
		public static void main(String[] args) {
			new Test().howdy();
		}
	}
}
//
//Howdy

多层嵌套类

一个内部类无论被嵌套多少层，它都能透明地访问所有它所嵌入的外围类的所有成员。

闭包与回调

闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为它不仅包含外围类对象（创建内部类的作用域）的信息，还自动拥有一个指向此外围类对象的引用，在此作用域内，内部类有权限操作所有成员，包括private成员。

内部类的继承

…

内部类标识符

每个类都会产生一个.class文件，其中包含了如何创建该类型的对象的全部信息（此信息产生一个“meta-class”，叫Class对象），内部类也必须生成一个.class文件以包含他们的Class对象信息。
这些类文件有严格的命名规则：外围类的名字，加上“$”，再加上内部类的名字。
如果内部类是匿名的，编译器你会简单地产生一个数字作为其标识符。
如果内部类是嵌套在其他的内部类之中，只需直接将他们的名字加在其外围类标识符与“$”的后面。