java基础系列之内部类<一>

内部类常见的几中形式:

1. 外部类中声明内部类,实现暴露给客户端的接口,这样可以达到影藏接口内部实现. 同时可以关闭对接口的实现的扩展.

public interface Selector<T> {

    /**
     * <P>返回<tt>true</tt>表示还有下一个.</P>
     * @return
     */
    boolean hasNext() ;

    /**
     * <P>返回下一个.</P>
     * @return
     */
    T next() ;
}


//SelectService
public class SelectService<E> {// as list

    private Object[] items ;

    private int next =0 ;

    private int count ; //实际字符串个数

    public SelectService() {
        //
        this.items = new Object[10] ;
        this.count = 0 ;
    }

    public SelectService(Collection<? extends E>[] items) {
        this.items = items ;
        this.count = items.length ;
        this.next = this.count;
    }

    public boolean add(E value) {
        if (this.next > this.count) {
            return false ;
        }

        this.items[next++] = value ;
        this.count ++ ;

        return true ;
    }

    public Selector<E> selector() {
        return new Selectes<E>() ;
    }


    private class Selectes<E> implements Selector<E> {

        private int index = 0 ;

        @Override
        public boolean hasNext() {
            return count !=0 && index < count;
        }

        @Override
        public E next() {

            if (index >= count) {
                return null ;
            }

            return (E)items[index++] ;
        }
    }
}


//test
SelectService selectService = new SelectService() ;

        selectService.add("hello") ;
        selectService.add("word") ;
        selectService.add("palm") ;
        selectService.add("123") ;
        selectService.add("345") ;

        Selector<String> stringSelector = selectService.selector() ;
        //

        while (stringSelector.hasNext()) {
            String str = stringSelector.next() ;
            System.out.println("str -- " + str);
        }

没有解决 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10 ;

以上代码类似与JDK 类集迭代器实现(Iterator). ArrayList,Set 等. 不过各个子类实现有部分区别.比如 ArrayList 的抽象父类 是在方法中实现接口Iterator.

2.方法内部声明内部类.例如:

public class InnerService {

    public Inter desc(String s) {
        class InnerTest implements Inter {
            @Override
            public String say() {
                return this.label ;
            }

            @Override
            public int value(int num) {
                return 0;
            }


            private String label ;

            public InnerTest(String str) {
                this.label = str ;
            }

            public String getLabel() {
                return this.label ;
            }
        }

        return new InnerTest(s) ;
    }

    public static void main(String[] args) {
        InnerService innerService = new InnerService() ;
        Inter inter = innerService.desc("hello") ;

        System.out.println(inter.say());
    }

在方法desc结束后仍然存在InnerTest 对象引用. 由于我经验太少,目前还不明白方法内实现内部类有那些特别的作用. 我只知道内部类的作用范围减小了.

3.匿名内部类.
在工作中,匿名内部类是我见到的第二多的情况的, 第一多的内部类是上面第一种, 外部类中直接声明内部类.

例如: 我们常常需要自己临时实现一下某一个接口,来应对一些特殊的场景. 这种临时使用,其实没有太大必要专门创建一个类来实现接口, 因为我们一旦创建了一个类,那么这个类我们有责任考虑别人访问后给他们和我们会带来什么样的后果.
下面我们来看一个简单的匿名内部类.

public class InName {

    public String say(final String s) {

        return new Inter() {

            @Override
            public String say() {
                return "hello," + s;
            }

            @Override
            public int value(int num) {
                return 0;
            }
        }.say() ;
    }

    public static void main(String[] args) {
        InName inName = new InName() ;
        System.out.println(inName.say("palm."));
    }
}

以上例子,有一点很重要,如果在内部类中访问外部类方法中的参数,则外部内方法中该参数必须声明为 final . 这点常常需要处理下.

匿名内部类,只能继承或者实现接口,二者不可兼得,因为他没有名字,所以也只能是某一种类型的子类, 要么是正规的继承,要么就是某一个接口的实现.