浅谈Java内部类

Java的内部类可以获得其外围类的所有成员访问权限，可以很方便的对外围类进行操作。非static内部类都含有一个隐藏的外围类引用，这个引用可以通过 OuterClass.this 来获得使用。通常如果我们的一组操作需要遵循某些规范(例如接口，抽象类)，就可以把这一组操作封装成一个内部类来供外部使用，而又不会脱离外围类。参见如下代码：

public interface Selector<E> {

    boolean hasNext();

    E next();

}



public class Sequence {

    private int[] seq;

    private Selector<Integer> obverseSelector;    // 正序遍历器

    private Selector<Integer> reverseSelector;    // 逆序遍历器



    public Sequence(int[] seq) {

        this.seq = seq;

        obverseSelector = new Selector<Integer>() {

            int counter = -1;

            

            @Override

            public Integer next() {

                return Sequence.this.seq[counter];

            }

            

            @Override

            public boolean hasNext() {

                return (++counter < Sequence.this.seq.length);

            }

        };

        

        reverseSelector = new Selector<Integer>() {

            int counter = Sequence.this.seq.length;

            

            @Override

            public Integer next() {

                return Sequence.this.seq[counter];

            }

            

            @Override

            public boolean hasNext() {

                return (--counter >= 0);

            }

        };

    }

    

    public Selector<Integer> getObverseSelector() {

        return obverseSelector;

    }

    

    public Selector<Integer> getReverseSelector() {

        return reverseSelector;

    }

}



public class Test {

    public static void main(String args[]) {

        int[] a = {1, 2, 3, 4, 5};

        

        Sequence sequence = new Sequence(a);

        Selector<Integer> obSelector = sequence.getObverseSelector();

        Selector<Integer> reSelector = sequence.getReverseSelector();

        while (obSelector.hasNext()) {

            System.out.print(obSelector.next() + " ");

        }

        System.out.println();

        while (reSelector.hasNext()) {

            System.out.print(reSelector.next() + " ");

        }

    }

}

这个例子通过内部类实现Selector接口,让Sequence类拥有属于自己的正序遍历器和逆序遍历器。注意匿名内部类如果需要访问外围类的成员，需要使用 Outer.this 前缀来访问。

可以想象如果不用内部类来实现遍历器会有什么不同，如果我们不用内部类来实现，就必须定义个Selector的具体类，并且将Sequence类的seq数组作为参数传进去。如果说需要将Selector作为一个共用的遍历器，可以这么做，但如果遍历器是针对Sequence类来实现的，则用内部类更为方便。

下面的代码是使用非匿名内部类实现的Selector

public class Sequence2 {

    private int[] seq;

    

    public Sequence2(int[] seq) {

        this.seq = seq;

    }

    

    public class ObverseSelecter implements Selector<Integer> {

        int counter = -1;

        

        @Override

        public Integer next() {

            return seq[counter];

        }

        

        @Override

        public boolean hasNext() {

            return (++counter < seq.length);

        }

    }

    

    public class ReverseSelecter implements Selector<Integer> {

        int counter = seq.length;

        

        @Override

        public Integer next() {

            return seq[counter];

        }

        

        @Override

        public boolean hasNext() {

            return (--counter >= 0);

        }

    }

}



public class Test {

    public static void main(String args[]) {

        int[] a = {1, 2, 3, 4, 5};

        

        Sequence2 sequence2 = new Sequence2(a);

        Selector<Integer> obSelector2 = sequence2.new ObverseSelecter();

        Selector<Integer> reSelector2 = sequence2.new ReverseSelecter();

        while (obSelector2.hasNext()) {

            System.out.print(obSelector2.next() + " ");

        }

        System.out.println();

        while (reSelector2.hasNext()) {

            System.out.print(reSelector2.next() + " ");

        }

    }

}

此处仅需要注意一下生成遍历的时候的new语法 sequence2.new ，容易看出内部类的实例其实是和外围类的实例紧密相关的，正如匿名内部类的 Outer.this 语法一样

 

值得一提的是局部内部类如果要使用局部变量，那么局部变量必须为final，否则编译会不通过，参见如下代码

public interface Flyable {

    void fly();

}



public class FinalTest {

    public static Flyable getFlyable(int speed) {

        final int finalSpeed = speed * 2;

        return new Flyable() {

            @Override

            public void fly() {

                System.out.println("I can fly with speed " + finalSpeed + " km/h");

            }

        };

    }

    

    public static void main(String[] args) {

        Flyable flyable = getFlyable(50);

        flyable.fly();

    }

}

可见finalSpeed为final变量，为什么有这种要求呢？

是因为局部变量的生命周期仅仅在方法执行作用域内，当方法执行完毕，局部变量自然就被销毁。但是内部类却作为一个实例被返回来了，如果说这个内部类实例以后还需要访问这个已销毁的局部变量，显然是不可以的。所以在内部类里需要访问的局部变量都会定义成常量，一起被编译进内部类里。