java内部类

  将一个类的定义放在另一个类的内部，这就是内部类

  内部类是一种非常有用的特性，因为他允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。内部类能了解外围类，并且与之通信！！！

创建内部类：

创建内部类就如同你想的一样，把类的定义置于外围类的里面：

代码如下：

package inner;

/**
* Created by panther.dongdong on 2016/1/12.
*/
public class Parcel1 {
class Content {
private int i = 11;

public int value() {
return i;
}
}

class Destination {
private String label;

Destination(String whereTo) {
this.label = whereTo;
}

String readLabel() {
return label;
}
}

public void ship(String dest) {
Content content = new Content();
Destination destination = new Destination(dest);
System.out.println(destination.readLabel());
}

public static void main(String[] args) {
Parcel1 parcel1 = new Parcel1();
parcel1.ship("panther");
}
}

当我们在ship方法里使用内部类的时候，与使用其他类没有什么区别！！

更典型的方法是，外部类将有一个方法，该方法返回一个指向内部类的引用，就像在to()和contents()方法中看到的

package inner;

/**
* Created by panther.dongdong on 2016/1/12.
*/
public class Parce2 {
class Content {
private int i = 11;

public int value() {
return i;
}
}

class Destination {
private String label;

Destination(String whereTo) {
this.label = whereTo;
}

String readLabel() {
return label;
}
}

//指向内部类的引用
public Destination to(String s) {
return new Destination(s);
}

//指向内部类的引用
public Content content() {
return new Content();
}

public void ship(String dest) {
Content content = content();
Destination destination = to(dest);
System.out.println(destination.readLabel());
}

public static void main(String[] args) {
Parce2 parce2 = new Parce2(); //new 一个外围类
parce2.ship("panther");
Parce2 parce21 = new Parce2();
Parce2.Content content = parce21.content(); //new 一个内部类
Parce2.Destination destination = parce21.to("pan"); //new 一个内部类
}
}

如果想从外部的非静态方法之外的任意位置创建某个内部类的对象，那么必须像在main()方法里那样，具体的指明这个对象的类型：外围类.内部类

链接到外部类

当生成一个内部类对象时，此对象与制造它的外围对象之间有一种联系，所以它能访问其外围对象的所有成员，而不需要任何特许条件，此外内部类拥有其外围类的所有元素的访问权，如下所示：

package inner;

/**
* Created by panther.dongdong on 2016/1/12.
*/
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.println(selector.current());
selector.next();
}
}
}


Sequence类是一个固定大小的Object的数组，以类的形式包装了起来。可以调用add增加新对象，要获得Sequence中的每一个对象，可以使用Selector接口。这是迭代器模式设计的一个例子。Selector可以检测序列是否到了末尾了(end),访问当前对象（current）以及移到序列的下一个对象（next）,因为selector是一个接口，所以别的类可以按照他们自己的方式来实现这个接口，并且别的方法以此接口为参数，来生成更加通用的代码

    内部类自动拥有对外围类多有成员的访问权。这是如何做到的呢？

    当某个外围类对象创建了一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后当你访问外围类的成员时，就是用那个引用来选择外围类的成员，幸运的是，这些细节都是编译器帮你处理的！！！