内部类（一）

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();
    }
}

• 内部类（一）https://www.jianshu.com/p/563a5c69a152
• 内部类（二）https://www.jianshu.com/p/5b32ada40b0d