读Java编程思想随笔の内部类

　　可以将一个类的定义放在另一个类的定义内部，这就是内部类。

　　内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性。然而必须要了解，内部类与组合是完全不同的两种概念。

　　创建一个内部类

public class Parcel1 {
    class Contents{
        private int i = 11;
        public int value(){
            return i;
        }
    }
    class Destination{
        private String label;
        Destination(String whereTo){
            label = whereTo;
        }
        String readLabel(){return label;}
    }
    public void ship(String dest){
        Contents c = new Contents();
        Destination d = new Destination(dest);
        System.out.println(d.readLabel());
    }
    public static void main(String[] args) {
        Parcel1 p = new Parcel1();
        p.ship("Tasmania");
    }
}

　　链接到外部类

　　到目前为止，内部类似乎还是一种名字隐藏和组织代码的模式。这些很有用，但还不是最引人注目的，它还有其他用途。当生成一个内部类的对象时，此对象与制造它的外围对象就有了某种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊条件。此外，内部类还拥有其外围类所有元素的访问权。

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 o){
        if (next<items.length)
            items[next++] = o;
    }
    private class SequenceSelector implements Selector{
        private int i = 0;
        public boolean end(){
            return i == items.length;
        }
        public Object current(){
            return items[i];
        }
        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(Integer.toString(i));
        }
        Selector selector = sequence.selector();
        while (!selector.end()){
            System.out.println(selector.current()+" ");
            selector.next();
        }
    }
}

　　所以内部类自动拥有其外围类所有成员的访问权。这是如何做到的？当某个外围类对象创建一个内部类对象时，此内部类对象必定会秘密的捕获那个指向外围类的对象引用。然后，在你访问外围类成员时，就是用那个引用来选择外围类成员。幸运的是，编译器会帮你处理所有细节，但你现在可以看到：内部类的对象只能在与其外围类对象关联的情况下才能被创建。构建内部类时，需要一个指向外围类对象的引用，如果编译器访问不到这个引用就会报错。

　　使用.this与.new

　   如果你需要生成对外部类对象的引用，可以使用外部类的名字后面紧跟圆点和this。这样产生的引用自动的具有正确的类型，这一点在编译器就被知晓并接受检查，因此没有任何运行时开销。

public class DoThis {
    void f(){
        System.out.println("DoThis.f()");
    }
    public class Inner{
        public DoThis outer(){
            return DoThis.this;
        }
    }
    public Inner inner(){
        return new Inner();
    }

    public static void main(String[] args) {
        DoThis dt = new DoThis();
        DoThis.Inner dti = dt.inner();
        dti.outer();
    }
}

　　有时你可能想要告知某些其他对象，去创建其某个内部类的对象。要实现此目的，你必须在new表达式中提供对其他外部类对象的引用，这是需要使用.new()语法，就像下面这样：

public class DotNew {
    public class Inner{}
    public static void main(String[] args) {
        DotNew dn = new DotNew();
        DotNew.Inner dni = dn.new Inner();
    }
}

　　要想直接创建内部类的对象，你不能按照你想象的方式，去引用外部类的名字DotNew，而是必须使用外部类的对象来创建该内部类的对象，就像在上面的程序中看到的那样。这也解决了内部类名字作用域的问题。因此你不必声明dn.new DotNew.Inner()。

　　在拥有其外部类对象之前是不可能创建其内部类对象的。这是因为内部类会暗暗的连接到创建它的外部类对象上的。但是，如果你创建的嵌套类（静态内部类），那么它就不需要对外部类对象的引用。

public class Parcel3 {
    class Content{
        private int i =11;
        public int value(){
            return i;
        }
    }
    class Destination{
        private String label;
        Destination(String whereTo){
            label = whereTo;
        }
        String readLabel(){
            return label;
        }
    }
    public static void main(String[] args) {
        Parcel3 p = new Parcel3();
        Parcel3.Content c = p.new Content();
        Parcel3.Destination d = p.new Destination("Tasmania");
    }
}

　　当将某个内部类向上转型为其基类，尤其是转型为一个接口的时候，内部类就有了用武之地。（从实现了某个接口的对象，得到对此接口的引用，与向上转型为这个对象的基类，实质上效果是一样的）这是因为此内部类----某个接口的实现----能够完全不可见，并且不可用。所以，得到的是指向基类或接口的引用，所以能够很方便的隐藏其实现细节。

 public interface Contents { 2 int value(); 3 } 

 public interface Destination { 2 String readLabel(); 3 } 

public class TestParcel {
    public static void main(String[] args) {
        Parcel4 p = new Parcel4();
        Contents c = p.contents();
        Destination d = p.destination("Tasmania");

    }
}
class Parcel4{
    private class PContents implements Contents{
        private int i = 11;
        public int value(){
            return i;
        }
    }
    protected class PDestination implements Destination{
        private String label;
        private PDestination(String whereTo){
            label = whereTo;
        }
        public String readLabel(){
            return label;
        }
    }
    public Destination destination(String s){
        return new PDestination(s);
    }
    public Contents contents(){
        return new PContents();
    }
}

　　private内部类给类的设计者提供了一种途径，通过这种方式可以完全地阻止任何依赖于类型的编码，并且完全隐藏了实现的细节。此外，从客户端程序员的角度来看，由于不能访问任何新增加的，原本不属于公共接口的方法，所以扩展接口是没有价值的。这也是给Java编译器提供了生成更高效代码的机会。

　　在方法和作用域内的内部内

　　在方法的作用域内创建一个完整的类

public class Parcel5 {
    public Destination destination(String s){
        class PDestionation implements Destination{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){return  label;}
        }
        return new PDestionation(s);
    }

    public static void main(String[] args) {
        Parcel5 p = new Parcel5();
        Destination d = p.destination("Tasmania");
    }

}

　　值得注意的是，在上述示例中，destination()中定义了内部类PDestination，并不意味着一旦dest()方法执行完毕PDestination就不可用了。

　　在任意的作用域内嵌套一个内部类

　　

public class Parcel6 {
    private void internalTracking(boolean b){
        if (b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s){
                    this.id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("");
            ts.getSlip();
        }
        //在定义TrackingSlip之外会编译错误
        //TrackingSlip ts = new TrackingSlip("");
        //ts.getSlip();
    }
    public void track(){
        internalTracking(true);
    }
    public static void main(String[] args) {
        Parcel6 p = new Parcel6();
        p.track();
    }
}

　　匿名内部类

public class Parcel7 {
    public Contents contents(){
        return new Contents(){
            private int i = 11;
            public int value(){return i;}
        };//semicolon requeried in this case
    }
    public static void main(String[] args) {
        Parcel7 p = new Parcel7();
        Contents c = p.contents();
    }
}

　　创建一个继承自Contents的 匿名类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。

　　上述匿名内部类的语法是下述形式的简化形式

 

public class Parcel7b {
    class MyContents implements Contents{
        private  int i = 11;
        public int value(){
            return i;
        }
    }
    public Contents contents(){return new MyContents();}

    public static void main(String[] args) {
        Parcel7b p = new Parcel7b();
        p.contents();
    }
}

 

　　在这个匿名内部类中，使用了默认构造器来生成Contents。下面代码展示的是，如果你的基类需要一个有参数的构造器，怎么办？

public class Parcel8 {
    public Wrapping wrapping(int x){
        return new Wrapping(x){//pass constructor argument
            public int value(){
                return super.value()*47;
            }
        };
    }
}

　　如果定义了一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用时final的，就像你在destination()参数中看到的那样。如果你忘记了，将会得到一个编译时错误消息。

public class Parcel9 {
    //argument must be final to use inside
    //anonymous inner class;
    public Destination destination(final String dest){
        return new Destination(){
            private String label = dest;
            public String readLabel(){return label;}
        };
    }

    public static void main(String[] args) {
        Parcel9 p = new Parcel9();
        Destination d = p.destination("Tasmania");
    }
}

　　如果只是简单的给一个字段赋值，那么此例中的方法是很好的。但是，如果想做一些类似构造器的行为，该怎么办？在匿名类中不可能有匿名构造器，但通过实例初始化，就能够达到为匿名内部类创建一个构造器的效果。

public class AnonymouseConstructor {
        public static Base getBase(int i){
                return new Base(i){
                        {
                                System.out.println("inside instance initlizer");
                        }
                        public void f(){
                                System.out.println("in Anonymouse f()");
                        }
                };
        }

        public static void main(String[] args) {
                Base base = getBase(47);
                base.f();
        }
}
abstract class Base{
        public Base(int i){
                System.out.println("Base Constructor.i="+i);
        }
        public abstract void f();
}

　　在实例初始化操作内部，可以看到有一段代码，它们不能作为字段初始化动作的一部分来执行。所以对于匿名类而言，实例初始化的实际效果就是构造器。当然，它受到了限制----你不能重载实例初始化方法，所以你仅有一个这样的构造器。

　　匿名内部类与正规的继承相比有些受限，因为匿名内部类既可以扩展类，也可以实现接口，但是不能两者兼备。而如果是实现接口，也只能实现一个接口。

public class Parcel10 {
    //argument must be final to use inside
    //anonymous inner class;
    public Destination destination(final String dest,final float price){
        return new Destination(){
            private int cost;
            {
                cost = Math.round(price);
                if (cost>100){
                    System.out.println("over budget");
                }
            }
            private String label = dest;
            public String readLabel(){return label;}
        };
    }

    public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Tasmania",101.395F);
    }
}

　　嵌套类

　　如果不需要内部类对象与其外围类对象有联系，那么可以将内部类声明为static。这通常称为嵌套类。想要理解static应用于内部类时的含义，就必须记住，普通的内部类对象隐式的保存了一个引用，指向创建它的外围类对象。然而内部类时static时，就不是这样了。嵌套类意味着：

　　1、要创建嵌套类的对象，并不需要其外围类对象；

　　2、不能从嵌套类的对象中访问非静态的外围类对象

　　嵌套类与普通的内部类还有一个区别。普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能包含static数据和static字段，也不能有嵌套类。但是嵌套类可以包含有这些东西。

public class Parcel11 {
    private static class ParcelContents implements Contents{
        private int i = 11;
        @Override
        public int value() {
            return i;
        }
    }
    protected static class ParcelDestination implements Destination{
        private String label;
        private ParcelDestination(String whereTo){
            this.label = whereTo;
        }
        @Override
        public String readLabel() {
            return label;
        }
        public static void f(){

        }
        static int x = 10;
        static class AnotherLevel{
            public static void f(){

            }
            static int x = 10;
        }
    }
    public static Destination destination(String s){
        return new ParcelDestination(s);
    }
    public static Contents contents(){
        return new ParcelContents();
    }

    public static void main(String[] args) {
        Contents pc = contents();
        Destination pd = destination("");
    }
}

 　　接口内部的类

　　 正常情况下，不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，你放在接口中任何类都自动转为public和static，因为类是static的，只是将嵌套类置于接口的命名空间内，这并不违反接口的规则，你甚至可以在内部类中实现其外围的接口。

public interface ClassInInterface {
        void showhy();
        class Test implements ClassInInterface{
                @Override
                public void showhy() {
                        System.out.println("showhy");
                }
                public static void main(String[] args) {
                        new Test().showhy();
                }
        }
}

　　如果你想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所共用，那么使用接口内部的嵌套类会显得很方便。

　　从多层嵌套类中访问外部类的成员

　　一个内部类被嵌套多少层并不重要，它能透明的访问所有它所嵌入的外围类的所有成员。

public class MultiNestingAccess {
        public static void main(String[] args) {
                MNA mna = new MNA();
                MNA.A mnaa = mna.new A();
                MNA.A.B mnaab = mnaa.new B();
                mnaab.h();
        }
}
class MNA{
        private void f(){}
        class A{
                private void g(){}
                public class B{
                        void h(){
                                g();
                                f();
                        }
                }
        }
}

　　为什么需要内部类

　　一般来说，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口。

　　内部类必须回答的一个问题是：如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？答案是："如果这能满足需求，那就应该这么做"。那么内部类实现这个接口与外围类实现这个接口有什么区别？答案是：后者不能总能享用接口所带来的方便，有时需要用到接口的实现。所以，使用内部类最吸引人的原因的是：

　　每个内部类都能独立地继承自一个实现，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响。

　　如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计和编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了多重继承。也就是说，内部类允许继承多个非接口类型。

　　为了看到更多的细节，让我们考虑这样一种情形：即必须在一个类中以某种方式实现两个接口。由于接口的灵活性，你有两种选择：使用单一类，或者使用内部类：

public class MultiInterface {
        static void takeA(A a){}
        static void takeB(B b){}
        public static void main(String[] args) {
                X x = new X();
                Y y = new Y();
                takeA(x);
                takeA(y);
                takeB(x);
                takeB(y.makeB());

        }
}
interface A{}
interface B{}
class X implements A,B{}
class Y implements A{
        B makeB(){
                return new B(){};
        }
}

　　如果没有任何其他限制，从实现的观点来看，上面的示例并没有什么区别，它们都能正常运作。

　　如果拥有的是抽象的类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承。

public class MultiImplemention {
        static  void tasksD(D d){}
        static  void tasksE(E e){}
        public static void main(String[] args) {
                Z z = new Z();
                tasksD(z);
                tasksE(z.makeE());
        }
}
class D{}
abstract class E{}
class Z extends D{
        E makeE(){return new E(){};}
}