前言

和我一起讀書書，一起喵喵喵喵喵~
在讀 《Java程式設計思想 Thinking in Java》 這本書的時候，會有很多示例程式碼。為了鞏固和實踐，所以將書上的程式碼都寫上一遍（其實是逼自己寫程式碼）。目前我已經讀到第十章：內部類 了，程式碼也會從這裡開始寫。前面的程式碼就算了，不補了，Just do it!

10.5 在方法和作用域內的內部類

先寫個介面Destination：

package com.innerClass;

public interface Destination {
    String readLabel();
}

接下來就寫，在方法的作用域中建立一個完整的類。這被叫做區域性內部類

package com.innerClass;

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

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

下面展示，如何在任意作用域內嵌入一個內部類：

package com.innerClass;

public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s){
                    id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("slip");
            String s = ts.getSlip();
        }
        //試想一下上面這兩句話，寫到這裡可不可以呢？
    }
    public void track(){
        internalTracking(true);
    }
    public static void main(String[] args) {
        Parcel6 p = new Parcel6();
        p.track();;
    }
}
 

回答程式碼中的問題，答案是不可以哦，因為那裡是 if的作用域外，超出了TrackingSlip的作用域了！

10.6 匿名內部類

先寫個介面，做鋪墊啊

package com.innerClass;

public interface Contents {
    int value();
}

馬上寫一個匿名內部類啊

package com.innerClass;

public class Parcel7 {
    public Contents contents(){
        return new Contents() {
            private int i = 11;
            @Override
            public int value() {
                return i;
            }
        };
    }

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

在contents方法中，return的那個類，沒有名字，看吧，是不是很奇怪。
在return一個new的Contents的時候，彷彿聽見一個聲音，說：“等等，我想在這裡插入一個內的定義”。結果就成這個樣子了。
這就是匿名內部類啊！！！
對這個奇怪的語法正兒八經的總結一下就是：“建立一個繼承自Contents的匿名內部類的物件。通過new表示式返回的引用被自動向上轉型為對Contents的引用。”

上述匿名內部類的語法是下述形式的簡化形式：

package com.innerClass;

public class Parcel7b {
    class MyContents implements Contents{
        private int i = 11;
        @Override
        public int value() {
            return i;
        }
    }
    public Contents contents(){
        return new MyContents();
    }
    public static void main(String[] args) {
        Parcel7b p = new Parcel7b();
        Contents c = p.contents();
    }
}

有沒有覺得第一種書寫方式更裝逼一點呢！

咦？咦咦咦？
我發現上面那個匿名內部類使用了預設構造器來生成Contents，但是如果基類需要一個有引數的構造器，就像下面這樣，改怎麼辦呢？

package com.innerClass;

public class Parcel8 {
    public Wrapping wrapping(int x){
        return new Wrapping(x){
            @Override
            public int value() {
                return super.value() * 47;
            }
        };
    }
    public static void main(String[] args) {
        Parcel8 p = new Parcel8();
        Wrapping w = p.wrapping(10);
    }
}

Wrapping這個類我該怎樣寫，才能正確的被Parcel8使用呢？
很簡單！只需要傳遞合適的引數給基類的構造器即可，就像這樣：

package com.innerClass;

public class Wrapping {
    private int i;
    public Wrapping(int x){
        i = x;
    }
    public int value(){
        return i;
    }
}

雖然Wrapping只是一個具有具體實現的普通類，但還是被其匯出類當作公共“介面”來使用！

如果在匿名類中定義欄位時，還要對其執行初始化操作，該咋寫呢？就該像下面這樣寫呀：

package com.innerClass;

public class Parcel9 {
    public Destination destination(final String dest){
        return new Destination() {
            private String label = dest;
            @Override
            public String readLabel() {
                return label;
            }
        };
    }
    public static void main(String[] args) {
        Parcel9 p = new Parcel9();
        Destination d = p.destination("Tasmania");
    }
}

注意到了嗎？用到了關鍵字final哦，如果定義一個匿名內部類，並且希望它使用一個在其外部定義的物件時，那麼編譯器就會要求其引數是final的。

實現一個為匿名內部類建立一個構造器的效果:

package com.innerClass;

public abstract class Base {
    public Base(int i){
        System.out.println("Base constructor, i = "+i);
    }
    public abstract void f();
}

package com.innerClass;

import com.sun.org.apache.xpath.internal.SourceTree;

public class AnonymousConstructor {
    public static Base getBase(int i){
        return new Base(i) {
            @Override
            public void f() {}
        };
    }
    public static void main(String[] args) {
        Base base = getBase(47);
        base.f();
    }
}

這個例子中呢，變數i，不要求是final的。因為 i 被傳遞給匿名類的基類的構造器，並沒有在匿名類內部直接使用。

帶例項初始化的“parcel”形式。

package com.innerClass;

public class Parcel10 {
    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;
            @Override
            public String readLabel() {
                return label;
            }
        };
    }
    public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Tasmania", 101.395F);
    }
}

10.6.1 再訪工廠方法
使用匿名內部類改造 interfaces/Factories.java 示例：

package com.innerClass;

public interface Service {
    void method1();
    void method2();
}

package com.innerClass;

public interface ServiceFactory {
    Service getService();
}

package com.innerClass;

public class Implementation1 implements Service{
    private Implementation1(){}
    @Override
    public void method1() {
        System.out.println("Implementation1 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation1 method2");
    }
    public static ServiceFactory factory = new ServiceFactory() {
        @Override
        public Service getService() {
            return new Implementation1();
        }
    };
}

package com.innerClass;


public class Implementation2 implements Service{
    private Implementation2(){}
    @Override
    public void method1() {
        System.out.println("Implementation2 method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation2 method2");
    }
    public static ServiceFactory factory = new ServiceFactory() {
        @Override
        public Service getService() {
            return new Implementation2();
        }
    };
}

package com.innerClass;

public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s = fact.getService();
        s.method1();
        s.method2();
    }

    public static void main(String[] args) {
        serviceConsumer(Implementation1.factory);
        serviceConsumer(Implementation2.factory);
    }
}

改造 interfaces/Games.java 示例：

package com.innerClass.games;

public interface Game {
    boolean move();
}

package com.innerClass.games;

public interface GameFactory {
    Game getGame();
}

package com.innerClass.games;

public class Checkers implements Game{
    private Checkers(){}
    private int moves = 0;
    private static final int MOVES = 3;

    @Override
    public boolean move() {
        System.out.println("Checkers move " + moves);
        return ++moves != MOVES;
    }
    public static GameFactory factory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Checkers();
        }
    };
}

package com.innerClass.games;

public class Chess implements Game{
    private Chess(){}
    private int moves = 0;
    private static final int MOVES = 4;
    @Override
    public boolean move() {
        System.out.println("Chess move "+ moves);
        return ++moves != MOVES;
    }
    public static GameFactory factory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Chess();
        }
    };
}

package com.innerClass.games;

public class games {
    public static void playGame(GameFactory factory){
        Game s = factory.getGame();
        while (s.move()){
            ;
        }
    }

    public static void main(String[] args) {
        playGame(Checkers.factory);
        playGame(Chess.factory);
    }
}

10.7 巢狀類