java编程思想 -- 内部类

内部类的使用

内部类拥有外围类所以成员的访问权

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 object){
        if(next < items.length){
            items[next++] = object;
        }
    }

    /*
     * 内部类拥有外围类所有的访问权
     */
    private class SequenceSelector implements Selector{
        private int i = 0;

        @Override
        public boolean end() {
            return items.length == i;
        }

        @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) {
        final int n = 10;
        Sequence sequence = new Sequence(n);
        for(int i = 0; i < n; 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

在内部类中，通过’外部类类名.this’获取外部类对象的应用

package 内部类.点this的使用;

public class DotThis {
    private String s = "";

    public DotThis(String s) {
        super();
        this.s = s;
    }

    void f(){
        System.out.println(s);
    }

    public Inner inner(){
        /*
         * 产生的内部类对象自动与外部类对象发生关联。
         */
        return new Inner();
    }

    public class Inner{
        public DotThis outer(){
            /*
             * 返回与内部类对象关联的外部类的对象
             */
            return DotThis.this;
        }
    }

    public static void main(String[] args) {
        DotThis dt = new DotThis("chuqin");
        Inner inner = dt.inner();
        inner.outer().f();
    }
}

结果

chuqin

通过‘外部类对象.new’创建内部类对象

public class DotNew {
    public class Inner{
        public void helloworld(){
            System.out.println("hello world");
        }
    }

    /*
     * 想要直接创建内部类的对象，不能直接 new DotNew.Inner（）
     * 而必须是通过外部类的对象来创建内部类的对象，与此同时，内部类对象与外部类对象发生了关联
     * 静态的内部类则可以直接创建对象，不需要与外部类对象发生关联
     */
    public static void main(String[] args) {
        DotNew dn = new DotNew();
        DotNew.Inner dni = dn.new Inner();
        dni.helloworld();
    }
}

结果

hello world

内部类向上转型隐藏实现的细节

package 内部类.内部类与向上转型;

public class Car {
    private class MoveImpl implements Move{

        @Override
        public void moveForward() {
            System.out.println("move formard");
        }

        @Override
        public void moveBack() {
            System.out.println("move back");    
        }

    }

    protected class TrumpetImpl implements Trumpet{

        @Override
        public void call() {
            System.out.println("call");
        }

    }

    /*
     * 返回一个private类的对象，隐藏实现的细节
     */
    public Move move(){
        return new MoveImpl();
    }

    /*
     * 返回一个protected类的对象，隐藏实现的细节
     */
    public Trumpet trumpet(){
        return new TrumpetImpl();
    }
}

interface Move{
    void moveForward();
    void moveBack();
}

/**
 * 喇叭
 */
interface Trumpet{
    void call();
}

匿名内部类

静态内部类