Java内部类(4)：静态内部类&接口内部类

使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

1、 它的创建是不需要依赖于外围类的。

2、 它不能使用任何外围类的非static成员变量和方法。

interface Contents {
    int value();
}

interface Destination {
    String readLabel();
}

class Test005Sub {

    private static class ParcelContents implements Contents {
        private int i = 11;

        public int value() {
            return i;
        }
    }

    static class ParcelDestination implements Destination {
        private String s;

        private ParcelDestination(String s) {
            this.s = s;
        }

        public String readLabel() {
            return s;
        }

        public static void f() {
        }

        static int x = 10;

        static class AnotherLevel {
            {
                x = 111;
                System.out.println(x);
            }
        }
    }

    public static Contents contents() {
        return new ParcelContents();
    }

    public static Destination destination() {
        return new ParcelDestination("Hello World!");
    }
}

public class Test005 {
    public static void main(String[] args) {
        Contents c = Test005Sub.contents();
        Destination d = Test005Sub.destination();
        new Test005Sub.ParcelDestination.AnotherLevel(); // 111
        System.out.println(c.value()); // 11
        System.out.println(d.readLabel()); // Hello World!
    }
}

还有一种放在接口内的接口内部类

放到接口中的任何类都自动地是public和static的，所以将嵌套类放在接口的命名空间内并不违反接口的规则。

interface Test006Sub {

    void howdy();

    class Test implements Test006Sub {
        public void howdy() {
            System.out.println("howdy!");
        }
    }
}

public interface Test006 {
    public static void main(String[] args) {
        new Test006Sub.Test().howdy(); // howdy!
    }
}