1.1 链接到外部类
内部类拥有其外部类的所有元素的访问权
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;
@Override
public boolean end() {
return i == items.length;
}
@Override
public Object current() {
return items[i];
}
@Override
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(i);
Selector selector = sequence.selector();
while (!selector.end()) {
System.out.println(selector.current());
selector.next();
}
}
}
运行结果：
0
1
2
3
4
5
6
7
8
9
1.2 使用.this和.new
如果我们在内部类中需要生成对外部类对象的引用时，可以使用外部类的名字跟.this。如果我们在外部类中需要创建内部类的对象，可以使用外部类的引用.new。如下所示：
public class DotThis {
void f(){
System.out.println("DotThis.f()");
}
public class Inner{
public DotThis outer(){
return DotThis.this;
}
}
public static void main(String[] args) {
DotThis dt = new DotThis();
DotThis.Inner dti = dt.new Inner();
dti.outer().f();
}
}
运行结果：
DotThis.f()
1.3 在方法和作用域内的内部类
1.3.1 局部内部类
public interface Flower {
String flowerName();
}
/**
* 定义在方法中的类（局部内部类）
*/
public class Rose {
private Flower name(String s) {
class FName implements Flower {
private String flower;
private FName(String s) {
flower = s;
}
@Override
public String flowerName() {
return flower;
}
}
return new FName(s);
}
public static void main(String[] args) {
Rose r = new Rose();
r.name("rose");
}
}
1.3.2 匿名内部类
public class CherryBlossoms {
public Flower flower(){
return new Flower() {
private String fName = "CherryBlossoms";
@Override
public String flowerName() {
return fName;
}
};
}
public static void main(String[] args) {
CherryBlossoms c = new CherryBlossoms();
Flower flower = c.flower();
}
}
在匿名类中不可能有命名构造器，但通过实例初始化，可以达到为匿名内部类创建一个构造器的效果。
public abstract class FlowerName {
public FlowerName(String name) {
System.out.println("flower name: " + name);
}
public abstract void flowerName();
}
public class Sunflower {
public FlowerName getFlowerName(String name){
return new FlowerName(name) {
@Override
public void flowerName() {
System.out.println("flowerName()");
}
};
}
public static void main(String[] args) {
Sunflower s = new Sunflower();
FlowerName fn = s.getFlowerName("sunflower");
fn.flowerName();
}
}
匿名内部类与正规的继承相比有些限制，因为匿名内部类既可以扩展类，也可以实现接口，但不能两者兼备。而且如果实现接口，也只可以实现一个接口。
在上个例子中不要求变量name一定是finnal的。因为name被传递给匿名类的基类的构造器，它并不会在匿名类的你内部被直接使用。
下面的例子，flower()的参数必须是final的，因为它们是在匿名类内部使用的。具体原因
public class Gypsophila {
public Flower flower(final String name,final float price){
return new Flower() {
private int cost;
{
cost = Math.round(price);
if (cost > 100){
System.out.println("Over budget!");
}
}
private String fName = name;
@Override
public String flowerName() {
return name;
}
};
}
public static void main(String[] args) {
Gypsophila g = new Gypsophila();
Flower f = g.flower("Gypsophila",101.44f);
f.flowerName();
}
}
