java程式設計思想重點筆記（java程式設計師必看）

阿新 • • 發佈：2018-12-10

Java中的多型性理解（注意與C++區分）

Java中除了static方法和final方法（private方法本質上屬於final方法，因為不能被子類訪問）之外，其它所有的方法都是動態繫結，這意味著通常情況下，我們不必判定是否應該進行動態繫結—它會自動發生。

final方法會使編譯器生成更有效的程式碼，這也是為什麼說宣告為final方法能在一定程度上提高效能（效果不明顯）。

如果某個方法是靜態的，它的行為就不具有多型性：

class StaticSuper {
    public static String staticGet() {
        return "Base staticGet()";
    }

    public String dynamicGet() {
        return "Base dynamicGet()";
    }
}

class StaticSub extends StaticSuper {
    public static String staticGet() {
        return "Derived staticGet()";
    }

    public String dynamicGet() {
        return "Derived dynamicGet()";
    }
}

public class StaticPolymorphism {

    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.staticGet());
        System.out.println(sup.dynamicGet());
    }

}

輸出：

Base staticGet()
Derived dynamicGet()

建構函式並不具有多型性，它們實際上是static方法，只不過該static宣告是隱式的。因此，建構函式不能夠被override。

在父類建構函式內部呼叫具有多型行為的函式將導致無法預測的結果，因為此時子類物件還沒初始化，此時呼叫子類方法不會得到我們想要的結果。

class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }
    Glyph() {
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(). radius = " + radius);
    }

    void draw() {
        System.out.println("RoundGlyph.draw(). radius = " + radius);
    }
}

public class PolyConstructors {

    public static void main(String[] args) {
        new RoundGlyph(5);

    }

}

輸出：

Glyph() before draw()
RoundGlyph.draw(). radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(). radius = 5

為什麼會這樣輸出？這就要明確掌握Java中建構函式的呼叫順序：

（1）在其他任何事物發生之前，將分配給物件的儲存空間初始化成二進位制0；
（2）呼叫基類建構函式。從根開始遞迴下去，因為多型性此時呼叫子類覆蓋後的draw()方法（要在呼叫RoundGlyph建構函式之前呼叫），由於步驟1的緣故，我們此時會發現radius的值為0；
（3）按宣告順序呼叫成員的初始化方法；
（4）最後呼叫子類的建構函式。

只有非private方法才可以被覆蓋，但是還需要密切注意覆蓋private方法的現象，這時雖然編譯器不會報錯，但是也不會按照我們所期望的來執行，即覆蓋private方法對子類來說是一個新的方法而非過載方法。因此，在子類中，新方法名最好不要與基類的private方法採取同一名字（雖然沒關係，但容易誤解，以為能夠覆蓋基類的private方法）。

Java類中屬性域的訪問操作都由編譯器解析，因此不是多型的。父類和子類的同名屬性都會分配不同的儲存空間，如下：

// Direct field access is determined at compile time.
class Super {
    public int field = 0;
    public int getField() {
        return field;
    }
}

class Sub extends Super {
    public int field = 1;
    public int getField() {
        return field;
    }
    public int getSuperField() {
        return super.field;
    }
}

public class FieldAccess {

    public static void main(String[] args) {
        Super sup = new Sub();
        System.out.println("sup.filed = " + sup.field + 
                ", sup.getField() = " + sup.getField());
        Sub sub = new Sub();
        System.out.println("sub.filed = " + sub.field + 
                ", sub.getField() = " + sub.getField() + 
                ", sub.getSuperField() = " + sub.getSuperField());
    }

}

輸出：

sup.filed = 0, sup.getField() = 1
sub.filed = 1, sub.getField() = 1, sub.getSuperField() = 0

Sub子類實際上包含了兩個稱為field的域，然而在引用Sub中的field時所產生的預設域並非Super版本的field域，因此為了得到Super.field，必須顯式地指明super.field。

2. is-a關係和is-like-a關係

is-a關係屬於純繼承，即只有在基類中已經建立的方法才可以在子類中被覆蓋，如下圖所示：

基類和子類有著完全相同的介面，這樣向上轉型時永遠不需要知道正在處理的物件的確切型別，這通過多型來實現。
is-like-a關係：子類擴充套件了基類介面。它有著相同的基本介面，但是他還具有由額外方法實現的其他特性。

缺點就是子類中介面的擴充套件部分不能被基類訪問，因此一旦向上轉型，就不能呼叫那些新方法。

3. 執行時型別資訊（RTTI + 反射）

概念
RTTI：執行時型別資訊使得你可以在程式執行時發現和使用型別資訊。
使用方式
Java是如何讓我們在執行時識別物件和類的資訊的，主要有兩種方式（還有輔助的第三種方式，見下描述）：
- 一種是“傳統的”RTTI，它假定我們在編譯時已經知道了所有的型別，比如Shape s = (Shape)s1；
- 另一種是“反射”機制，它執行我們在執行時發現和使用類的資訊，即使用Class.forName()。
- 其實還有第三種形式，就是關鍵字instanceof，它返回一個bool值，它保持了型別的概念，它指的是“你是這個類嗎？或者你是這個類的派生類嗎？”。而如果用==或equals比較實際的Class物件，就沒有考慮繼承—它或者是這個確切的型別，或者不是。
工作原理
要理解RTTI在Java中的工作原理，首先必須知道型別資訊在執行時是如何表示的，這項工作是由稱為Class物件的特殊物件完成的，它包含了與類有關的資訊。Java送Class物件來執行其RTTI，使用類載入器的子系統實現。

無論何時，只要你想在執行時使用型別資訊，就必須首先獲得對恰當的Class物件的引用，獲取方式有三種：
（1）如果你沒有持有該型別的物件，則Class.forName()就是實現此功能的便捷途，因為它不需要物件資訊；
（2）如果你已經擁有了一個感興趣的型別的物件，那就可以通過呼叫getClass()方法來獲取Class引用了，它將返回表示該物件的實際型別的Class引用。Class包含很有有用的方法，比如：

package rtti;
interface HasBatteries{}
interface WaterProof{}
interface Shoots{}

class Toy {
    Toy() {}
    Toy(int i) {}
}

class FancyToy extends Toy
implements HasBatteries, WaterProof, Shoots {
    FancyToy() {
        super(1);
    }
}

public class RTTITest {

    static void printInfo(Class cc) {
        System.out.println("Class name: " + cc.getName() + 
                ", is interface? [" + cc.isInterface() + "]");
        System.out.println("Simple name: " + cc.getSimpleName());
        System.out.println("Canonical name: " + cc.getCanonicalName());
    }

    public static void main(String[] args) {
        Class c = null;
        try {
            c = Class.forName("rtti.FancyToy"); // 必須是全限定名（包名+類名）
        } catch(ClassNotFoundException e) {
            System.out.println("Can't find FancyToy");
            System.exit(1);
        }
        printInfo(c);

        for(Class face : c.getInterfaces()) {
            printInfo(face);
        }

        Class up = c.getSuperclass();
        Object obj = null;
        try {
            // Requires default constructor.
            obj = up.newInstance();
        } catch (InstantiationException e) {
            System.out.println("Can't Instantiate");
            System.exit(1);
        } catch (IllegalAccessException e) {
            System.out.println("Can't access");
            System.exit(1);
        }
        printInfo(obj.getClass());
    }

}

輸出：

Class name: rtti.FancyToy, is interface? [false]
Simple name: FancyToy
Canonical name: rtti.FancyToy
Class name: rtti.HasBatteries, is interface? [true]
Simple name: HasBatteries
Canonical name: rtti.HasBatteries
Class name: rtti.WaterProof, is interface? [true]
Simple name: WaterProof
Canonical name: rtti.WaterProof
Class name: rtti.Shoots, is interface? [true]
Simple name: Shoots
Canonical name: rtti.Shoots
Class name: rtti.Toy, is interface? [false]
Simple name: Toy
Canonical name: rtti.Toy

（3）Java還提供了另一種方法來生成對Class物件的引用，即使用類字面常量。比如上面的就像這樣：FancyToy.class;來引用。
這樣做不僅更簡單，而且更安全，因為它在編譯時就會受到檢查（因此不需要置於try語句塊中），並且它根除了對forName方法的引用，所以也更高效。類字面常量不僅可以應用於普通的類，也可以應用於介面、陣列以及基本資料型別。

注意：當使用“.class”來建立對Class物件的引用時，不會自動地初始化該Class物件，初始化被延遲到了對靜態方法（構造器隱式的是靜態的）或者非final靜態域（注意final靜態域不會觸發初始化操作）進行首次引用時才執行：。而使用Class.forName時會自動的初始化。

為了使用類而做的準備工作實際包含三個步驟：
- 載入：由類載入器執行。查詢位元組碼，並從這些位元組碼中建立一個Class物件
- 連結：驗證類中的位元組碼，為靜態域分配儲存空間，並且如果必需的話，將解析這個類建立的對其他類的所有引用。
- 初始化：如果該類具有超類，則對其初始化，執行靜態初始化器和靜態初始化塊。

這一點非常重要，下面通過一個例項來說明這兩者的區別：

package rtti;
import java.util.Random;
class Initable {
        static final int staticFinal = 47;
        static final int staticFinal2 = ClassInitialization.rand.nextInt(1000);

        static {
            System.out.println("Initializing Initable");
        }
}
class Initable2 {
        static int staticNonFinal = 147;

        static {
            System.out.println("Initializing Initable2");
        }
}
class Initable3 {
        static int staticNonFinal = 74;

        static {
            System.out.println("Initializing Initable3");
        }
}
public class ClassInitialization {

        public static Random rand = new Random(47);

        public static void main(String[] args) {
            // Does not trigger initialization
            Class initable = Initable.class;
            System.out.println("After creating Initable ref");
            // Does not trigger initialization
            System.out.println(Initable.staticFinal);
            // Does trigger initialization(rand() is static method)
            System.out.println(Initable.staticFinal2);

            // Does trigger initialization(not final)
            System.out.println(Initable2.staticNonFinal);

            try {
                Class initable3 = Class.forName("rtti.Initable3");
            } catch (ClassNotFoundException e) {
                System.out.println("Can't find Initable3");
                System.exit(1);
            }
            System.out.println("After creating Initable3 ref");
            System.out.println(Initable3.staticNonFinal);
        }
}

輸出：

After creating Initable ref
47
Initializing Initable
258
Initializing Initable2
147
Initializing Initable3
After creating Initable3 ref
74

RTTI的限制？如何突破？ — 反射機制
如果不知道某個物件的確切型別，RTTI可以告訴你，但是有一個限制：這個型別在編譯時必須已知，這樣才能使用RTTI識別它，也就是在編譯時，編譯器必須知道所有要通過RTTI來處理的類。

可以突破這個限制嗎？是的，突破它的就是反射機制。
Class類與java.lang.reflect類庫一起對反射的概念進行了支援，該類庫包含了Field、Method以及Constructor類（每個類都實現了Member介面）。這些型別的物件是由JVM在執行時建立的，用以表示未知類裡對應的成員。這樣你就可以使用Constructor建立新的物件，用get()/set()方法讀取和修改與Field物件關聯的欄位，用invoke()方法呼叫與Method物件關聯的方法。另外，還可以呼叫getFields()、getMethods()和getConstructors()等很便利的方法，以返回表示欄位、方法以及構造器的物件的陣列。這樣，匿名物件的類資訊就能在執行時被完全確定下來，而在編譯時不需要知道任何事情。

####反射與RTTI的區別
當通過反射與一個未知型別的物件打交道時，JVM只是簡單地檢查這個物件，看它屬於哪個特定的類（就像RTTI那樣），在用它做其他事情之前必須先載入那個類的Class物件，因此，那個類的.class檔案對於JVM來說必須是可獲取的：要麼在本地機器上，要麼可以通過網路取得。所以RTTI與反射之間真正的區別只在於：對RTTI來說，編譯器在編譯時開啟和檢查.class檔案（也就是可以用普通方法呼叫物件的所有方法）；而對於反射機制來說，.class檔案在編譯時是不可獲取的，所以是在執行時開啟和檢查.class檔案。

下面的例子是用反射機制打印出一個類的所有方法（包括在基類中定義的方法）：

package typeinfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;

// Using reflection to show all the methods of a class.
// even if the methods are defined in the base class.
public class ShowMethods {
    private static String usage = 
        "usage: \n" + 
        "ShowMethods qualified.class.name\n" +
        "To show all methods in class or: \n" +
        "ShowMethods qualified.class.name word\n" +
        "To search for methods involving 'word'";

    private static Pattern p = Pattern.compile("\\w+\\.");

    public static void main(String[] args) {
        if(args.length < 1) {
            System.out.println(usage);
            System.exit(0);
        }
        int lines = 0;
        try {
            Class<?> c = Class.forName(args[0]);
            Method[] methods = c.getMethods();
            Constructor[] ctors = c.getConstructors();
            if(args.length == 1) {
                for(Method method : methods) {
                    System.out.println(p.matcher(method.toString()).replaceAll(""));
                }
                for(Constructor ctor : ctors) {
                    System.out.println(p.matcher(ctor.toString()).replaceAll(""));
                }
                lines = methods.length + ctors.length;
            } else {
                for(Method method : methods) {
                    if(method.toString().indexOf(args[1]) != -1) {
                        System.out.println(p.matcher(method.toString()).replaceAll(""));
                        lines++;
                    }
                }
                for(Constructor ctor : ctors) {
                    if(ctor.toString().indexOf(args[1]) != -1) {
                        System.out.println(p.matcher(ctor.toString()).replaceAll(""));
                        lines++;
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            System.out.println("No such Class: " + e);
        }

    }
}

輸出：

public static void main(String[])
public final native void wait(long) throws InterruptedException
public final void wait() throws InterruptedException
public final void wait(long,int) throws InterruptedException
public boolean equals(Object)
public String toString()
public native int hashCode()
public final native Class getClass()
public final native void notify()
public final native void notifyAll()
public ShowMethods()

4. 代理模式與Java中的動態代理

代理模式
在任何時刻，只要你想要將額外的操作從“實際”物件中分離到不同的地方，特別是當你希望能夠很容易地做出修改，從沒有使用額外操作轉為使用這些操作，或者反過來時，代理就顯得很有用（設計模式的關鍵是封裝修改）。例如，如果你希望跟蹤對某個類中方法的呼叫，或者希望度量這些呼叫的開銷，那麼你應該怎樣做呢？這些程式碼肯定是你不希望將其合併到應用中的程式碼，因此代理使得你可以很容易地新增或移除它們。

interface Interface {
    void doSomething();
    void somethingElse(String arg);
}

class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("doSomething.");
    }

    @Override
    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}

class SimpleProxy implements Interface {

    private Interface proxy;

    public SimpleProxy(Interface proxy) {
        this.proxy = proxy;
    }

    @Override
    public void doSomething() {
        System.out.println("SimpleProxy doSomething.");
        proxy.doSomething();
    }

    @Override
    public void somethingElse(String arg) {
        System.out.println("SimpleProxy somethingElse " + arg);
        proxy.somethingElse(arg);
    }
}

public class SimpleProxyDemo {

    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        consumer(new RealObject());
        consumer(new SimpleProxy(new RealObject()));
    }

}

輸出：

doSomething.
somethingElse bonobo
SimpleProxy doSomething.
doSomething.
SimpleProxy somethingElse bonobo
somethingElse bonobo

動態代理
Java的動態代理比代理的思想更向前邁進了一步，因為它可以動態地建立代理並動態地處理對所代理方法的呼叫。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class DynamicProxyHandler implements InvocationHandler {

    private Object proxy;

    public DynamicProxyHandler(Object proxy) {
        this.proxy = proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("*** proxy: " + proxy.getClass() +
                ". method: " + method + ". args: " + args);
        if(args != null) {
            for(Object arg : args)
                System.out.println(" " + arg);
        }
        return method.invoke(this.proxy, args);
    }
}

public class SimpleDynamicProxy {

    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        // insert a proxy and call again:
        Interface proxy = (Interface)Proxy.newProxyInstance(
                Interface.class.getClassLoader(), 
                new Class[]{ Interface.class },
                new DynamicProxyHandler(real));

        consumer(proxy);
    }

}

輸出：

doSomething.
somethingElse bonobo
*** proxy: class typeinfo.\$Proxy0. method: public abstract void typeinfo.Interface.doSomething(). args: null
doSomething.
*** proxy: class typeinfo.\$Proxy0. method: public abstract void typeinfo.Interface.somethingElse(java.lang.String). args: [Ljava.lang.Object;@6a8814e9
bonobo
somethingElse bonobo

5. 即時編譯器技術 — JIT

Java虛擬機器中有許多附加技術用以提升速度，尤其是與載入器操作相關的，被稱為“即時”（Just-In-Time，JIT）編譯器的技術。這種技術可以把程式全部或部分翻譯成本地機器碼（這本來是JVM的工作），程式執行速度因此得以提升。當需要裝載某個類時，編譯器會先找到其.class檔案，然後將該類的位元組碼裝入記憶體。此時，有兩種方案可供選擇：
（1）一種就是讓即時編譯器編譯所有程式碼。但這種做法有兩個缺陷：這種載入動作散落在整個程式生命週期內，累加起來要花更多時間；並且會增加可執行程式碼的長度（位元組碼要比即時編譯器展開後的本地機器碼小很多），這將導致頁面排程，從而降低程式速度。
（2）另一種做法稱為惰性評估（lazy evaluation），意思是即時編譯器只在必要的時候才編譯程式碼，這樣，從不會被執行的程式碼也許就壓根不會被JIT所編譯。新版JDK中的Java HotSpot技術就採用了類似方法，程式碼每次被執行的時候都會做一些優化，所以執行的次數越多，它的速度就越快。

6. 訪問控制權限

Java訪問許可權修飾詞：public、protected、包訪問許可權（預設訪問許可權，有時也稱friendly）和private。
包訪問許可權：當前包中的所有其他類對那個成員具有訪問許可權，但對於這個包之外的所有類，這個成員卻是private。
protected：繼承訪問許可權。有時基類的建立者會希望有某個特定成員，把對它的訪問許可權賦予派生類而不是所有類。這就需要 protected來完成這一工作。protected也提供包訪問許可權，也就是說，相同包內的其他類都可以訪問protected元素。 protected指明“就類使用者而言，這是private的，但對於任何繼承於此類的匯出類或其他任何位於同一個包內的類來說，它卻是可以訪問的”。比如：
基類：
```
package access.cookie;
public class Cookie {
    public Cookie() {
        System.out.println("Cookie Constructor");
    }

    void bite() {  // 包訪問許可權，其它包即使是子類也不能訪問它
        System.out.println("bite");
    }
}
```
子類：
```
package access.dessert;
import access.cookie.Cookie;

public class ChocolateChip extends Cookie {

    public ChocolateChip() {
        System.out.println("ChocolateChip constructor");
    }

    public void chomp() {
        bite();  // error, the method bite() from the type Cookie is not visible
    }
}
```
可以發現子類並不能訪問基類的包訪問許可權方法。此時可以將Cookie中的bite指定為public，但這樣做所有的人就都有了訪問許可權，為了只允許子類訪問，可以將bite指定為protected即可。

7. 組合和繼承之間的選擇

組合和繼承都允許在新的類中放置子物件，組合是顯式的這樣做，而繼承則是隱式的做。
組合技術通常用於想在新類中使用現有類的功能而非它的介面這種情形。即在新類中嵌入某個物件，讓其實現所需要的功能，但新類的使用者看到的只是為新類所定義的介面，而非所嵌入物件的介面。為取得此效果，需要在新類中嵌入一個現有類的private物件。但有時，允許類的使用者直接訪問新類中的組合成分是極具意義的，即將成員物件宣告為public。如果成員物件自身都隱藏了具體實現，那麼這種做法是安全的。當用戶能夠了解到你正在組裝一組部件時，會使得埠更加易於理解。比如Car物件可由public的Engine物件、Wheel物件、Window物件和Door物件組合。但務必要記得這僅僅是一個特例，一般情況下應該使域成為private。
在繼承的時候，使用某個現有類，並開發一個它的特殊版本。通常，這意味著你在使用一個通用類，併為了某種特殊需要而將其特殊化。稍微思考一下就會發現，用一個“交通工具”物件來構成一部“車子”是毫無意義的，因為“車子”並不包含“交通工具”，它僅是一種交通工具（is-a關係）。
“is-a”（是一個）的關係是用繼承來表達的，而“has-a”（有一個）的關係則是用組合來表達的。
到底是該用組合還是繼承，一個最清晰的判斷方法就是問一問自己是否需要從新類向基類進行向上轉型，需要的話就用繼承，不需要的話就用組合方式。

8. final關鍵字

對final關鍵字的誤解
當final修飾的是基本資料型別時，它指的是數值恆定不變（就是編譯期常量，如果是static final修飾，則強調只有一份），而對物件引用而不是基本型別運用final時，其含義會有一點令人迷惑，因為用於物件引用時，final使引用恆定不變，一旦引用被初始化指向一個物件，就無法再把它指向另一個物件。然而，物件其自身卻是可以被修改的，Java並未提供使任何物件恆定不變的途徑（但可以自己編寫類以取得使物件恆定不變的效果），這一限制同樣適用陣列，它也是物件。
使用final方法真的可以提高程式效率嗎？
將一個方法設成final後，編譯器就可以把對那個方法的所有呼叫都置入“嵌入”呼叫裡。只要編譯器發現一個final方法呼叫，就會（根據它自己的判斷）忽略為執行方法呼叫機制而採取的常規程式碼插入方法（將自變數壓入堆疊；跳至方法程式碼並執行它；跳回來；清除堆疊自變數；最後對返回值進行處理）。相反，它會用方法主體內實際程式碼的一個副本來替換方法呼叫。這樣做可避免方法呼叫時的系統開銷。當然，若方法體積太大，那麼程式也會變得雍腫，可能受到到不到嵌入程式碼所帶來的任何效能提升。因為任何提升都被花在方法內部的時間抵消了。

在最近的Java版本中，虛擬機器（特別是hotspot技術）能自動偵測這些情況，並頗為“明智”地決定是否嵌入一個final 方法。然而，最好還是不要完全相信編譯器能正確地作出所有判斷。通常，只有在方法的程式碼量非常少，或者想明確禁止方法被覆蓋的時候，才應考慮將一個方法設為final。

類內所有private 方法都自動成為final。由於我們不能訪問一個private 方法，所以它絕對不會被其他方法覆蓋（若強行這樣做，編譯器會給出錯誤提示）。可為一個private方法新增final指示符，但卻不能為那個方法提供任何額外的含義。

9. 策略設計模式與介面卡模式的區別

策略設計模式
建立一個能夠根據所傳遞的引數物件的不同而具有不同行為的方法，被稱為策略設計模式，這類方法包含所要執行的演算法中固定不變的部分，而“策略”包含變化的部分。策略就是傳遞進去的引數物件，它包含要執行的程式碼。
介面卡模式
在你無法修改你想要使用的類時，可以使用介面卡模式，介面卡中的程式碼將接受你所擁有的介面，併產生你所需要的介面。

10. 內部類

內部類與組合是完全不同的概念，這一點很重要。
為什麼需要內部類？ — 主要是解決了多繼承的問題，繼承具體或抽象類
- 一般來說，內部類繼承自某個類或實現某個介面，內部類的程式碼操作建立它的外圍類的物件。所以可以認為內部類提供了某種進入其外圍類的視窗。
- 內部類最吸引人的原因是：每個內部類都能獨立地繼承自一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。
- 如果沒有內部類提供的、可以繼承多個具體的或抽象的類的能力，一些設計與程式設計問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。介面解決了部分問題，而內部類有效的實現了“多重繼承”。也就是說，內部類允許繼承多個非介面型別。
考慮這樣一種情形：如果必須在一個類中以某種方式實現兩個介面。由於介面的靈活性，你有兩種選擇：使用單一類或者使用內部類。但如果擁有的是抽象的類或具體的類，而不是介面，那就只能使用內部類才能實現多重繼承。

使用內部類，還可以獲得其他一些特性：
- 內部類可以有多個例項，每個例項都有自己的狀態資訊，並且與其外圍類物件的資訊相互獨立。
- 在單個外圍類中，可以讓多個內部類以不同的方式實現同一個介面或繼承同一個類。
- 建立內部類物件的時刻並不依賴於外圍類物件的建立。
- 內部類並沒有令人迷惑的is-a關係，它就是一個獨立的實體。

11. String型別 — 不可變

用於String的“+”與“+=”是Java中僅有的兩個過載過的操作符，而Java並不允許程式設計師過載任何操作符。
考慮到效率因素，編譯器會對String的多次+操作進行優化，優化使用StringBuilder操作（javap -c class位元組碼檔名命令檢視具體優化過程）。這讓你覺得可以隨意使用String物件，反正編譯器會為你自動地優化效能。但編譯器能優化到什麼程度還不好說，不一定能優化到使用StringBuilder代替String相同的效果。比如：
```
public class WitherStringBuilder {
    public String implicit(String[] fields) {
        String result = "";
        for(int i = 0; i < fields.length; i++)
            result += fields[i];
        return result;
    }

    public String explicit(String[] fields) {
        StringBuilder result = new StringBuilder();
        for(int i = 0; i < fields.length; i++)
            result.append(fields[i]);
        return result.toString();
    }
}
```
執行javap -c WitherStringBuilder，可以看到兩個方法對應的位元組碼。
implicit方法：

public java.lang.String implicit(java.lang.String[]);
Code:
0: ldc #16 // String
2: astore_2
3: iconst_0
4: istore_3
5: goto 32
8: new #18 // class java/lang/StringBuilder
11: dup
12: aload_2
13: invokestatic #20 // Method java/lang/String.valueOf:(
Ljava/lang/Object;)Ljava/lang/String;
16: invokespecial #26 // Method java/lang/StringBuilder.”<
init>”:(Ljava/lang/String;)V
19: aload_1
20: iload_3
21: aaload
22: invokevirtual #29 // Method java/lang/StringBuilder.ap
pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
25: invokevirtual #33 // Method java/lang/StringBuilder.to
String:()Ljava/lang/String;
28: astore_2
29: iinc 3, 1
32: iload_3
33: aload_1
34: arraylength
35: if_icmplt 8
38: aload_2
39: areturn
public java.lang.String implicit(java.lang.String[]);
Code:
0: ldc #16 // String
2: astore_2
3: iconst_0
4: istore_3
5: goto 32
8: new #18 // class java/lang/StringBuilder
11: dup
12: aload_2
13: invokestatic #20 // Method java/lang/String.valueOf:(
Ljava/lang/Object;)Ljava/lang/String;
16: invokespecial #26 // Method java/lang/StringBuilder.”<
init>”:(Ljava/lang/String;)V
19: aload_1
20: iload_3
21: aaload
22: invokevirtual #29 // Method java/lang/StringBuilder.ap
pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
25: invokevirtual #33 // Method java/lang/StringBuilder.to
String:()Ljava/lang/String;
28: astore_2
29: iinc 3, 1
32: iload_3
33: aload_1
34: arraylength
35: if_icmplt 8
38: aload_2
39: areturn

可以發現，StringBuilder是在迴圈之內構造的，這意味著每經過迴圈一次，就會建立一個新的StringBuilder物件。

explicit方法：

public java.lang.String explicit(java.lang.String[]);
Code:
0: new #18 // class java/lang/StringBuilder
3: dup
4: invokespecial #45 // Method java/lang/StringBuilder.”<
init>”:()V
7: astore_2
8: iconst_0
9: istore_3
10: goto 24
13: aload_2
14: aload_1
15: iload_3
16: aaload
17: invokevirtual #29 // Method java/lang/StringBuilder.ap
pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
20: pop
21: iinc 3, 1
24: iload_3
25: aload_1
26: arraylength
27: if_icmplt 13
30: aload_2
31: invokevirtual #33 // Method java/lang/StringBuilder.to
String:()Ljava/lang/String;
34: areturn
}

可以看到，不僅迴圈部分的程式碼更簡短、更簡單，而且它只生成了一個StringBuilder物件。顯式的建立StringBuilder還允許你預先為其指定大小。如果你已經知道最終的字串大概有多長，那預先指定StringBuilder的大小可以避免多次重新分配緩衝。

####總結
因此，當你為一個類重寫toString()方法時，如果字串操作比較簡單，那就可以信賴編譯器，它會為你合理地構造最終的字串結果。但是，如果你要在toString()方法中使用迴圈，那麼最好自己建立一個StringBuilder物件，用它來構造最終的結果。

System.out.printf()和System.out.format()方法模仿自C的printf，可以格式化字串，兩者是完全等價的。

Java中，所有新的格式化功能都由java.util.Formatter類處理。
String.format()方法參考了C中的sprintf()方法，以生成格式化的String物件，是一個static方法，它接受與Formatter.format()方法一樣的引數，但返回一個String物件。當你只需使用format()方法一次的時候，該方法很方便。

import java.util.Arrays;
import java.util.Formatter;

public class SimpleFormat {

    public static void main(String[] args) {
        int x = 5;
        double y = 5.324667;
        System.out.printf("Row 1: [%d %f]\n", x, y);
        System.out.format("Row 1: [%d %f]\n", x, y);

        Formatter f = new Formatter(System.out);
        f.format("Row 1: [%d %f]\n", x, y);

        String str = String.format("Row 1: [%d %f]\n", x, y);
        System.out.println(str);

        Integer[][] a = {
            {1, 2, 3}, {4, 5, 6},
            {7, 8, 3}, {9, 10, 6}
        };
        System.out.println(Arrays.deepToString(a));
    }
}

12. 序列化控制

- 當我們對序列化進行控制時，可能某個特定子物件不想讓Java序列化機制自動儲存與恢復。如果子物件表示的是我們不希望將其序列化的敏感資訊（如密碼），通常會面臨這種情況。即使物件中的這些資訊是private屬性，一經序列化處理，人們就可以通過讀取檔案或者攔截網路傳輸的方式來訪問到它。有兩種辦法可以防止物件的敏感部分被序列化：
  - 實現Externalizable代替實現Serializable介面來對序列化過程進行控制，Externalizable繼承了Serializable介面，同時增添了兩個方法：writeExternal()和readExternal()。
  兩者在反序列化時的區別：
  - 對Serializable物件反序列化時，由於Serializable物件完全以它儲存的二進位制位為基礎來構造，因此並不會呼叫任何建構函式，因此Serializable類無需預設建構函式，但是當Serializable類的父類沒有實現Serializable介面時，反序列化過程會呼叫父類的預設建構函式，因此該父類必需有預設建構函式，否則會拋異常。
  - 對Externalizable物件反序列化時，會先呼叫類的不帶引數的構造方法，這是有別於預設反序列方式的。如果把類的不帶引數的構造方法刪除，或者把該構造方法的訪問許可權設定為private、預設或protected級別，會丟擲java.io.InvalidException: no valid constructor異常，因此Externalizable物件必須有預設建構函式，而且必需是public的。
  - Externalizable的替代方法：如果不是特別堅持實現Externalizable介面，那麼還有另一種方法。我們可以實現Serializable介面，並新增writeObject()和readObject()的方法。一旦物件被序列化或者重新裝配，就會分別呼叫那兩個方法。也就是說，只要提供了這兩個方法，就會優先使用它們，而不考慮預設的序列化機制。
  
  這些方法必須含有下列準確的簽名：
```
private void writeObject(ObjectOutputStream stream) 
        throws IOException;
private void readObject(ObjectInputStream stream)
        throws IOException, ClassNotFoundException
```
  - 可以用transient關鍵字逐個欄位地關閉序列化，它的意思是“不用麻煩你儲存或恢復資料—我自己會處理的”。由於Externalizable物件在預設情況下不儲存它們的任何欄位，所以transient關鍵字只能和Serializable物件一起使用。

java程式設計思想重點筆記（java程式設計師必看）

Java中的多型性理解（注意與C++區分）

2. is-a關係和is-like-a關係

3. 執行時型別資訊（RTTI + 反射）

4. 代理模式與Java中的動態代理

5. 即時編譯器技術 — JIT

6. 訪問控制權限

7. 組合和繼承之間的選擇

8. final關鍵字

9. 策略設計模式與介面卡模式的區別

10. 內部類

11. String型別 — 不可變

12. 序列化控制

java程式設計思想重點筆記（java程式設計師必看）

Java程式設計思想重點筆記（Java開發必看）

Java程式設計思想重點筆記（Java開發必看)

Java程式設計思想閱讀筆記（第10章內部類）

JAVA程式設計思想學習筆記（一）

Java程式設計思想讀書筆記（一）第1~13、16章

JAVA程式設計思想學習筆記（三）操作符

【Java】《Java程式設計思想》筆記（含練習題答案程式碼）-第二章一切都是物件

JAVA程式設計思想學習筆記（八）介面

JAVA程式設計思想學習筆記（七）多型

JAVA程式設計思想學習筆記（六）複用類

JAVA程式設計思想學習筆記（五）訪問許可權控制

JAVA程式設計思想學習筆記（四）初始化與清理

JAVA程式設計思想學習筆記（二）一切都是物件

JAVA程式設計思想學習筆記（十一）容器類List

Java程式設計思想重點筆記

【Java程式設計思想閱讀筆記】Java資料儲存位置

Stack Overflow 2017 開發者調查報告（程式設計師必看）

java程式設計思想讀書筆記二（物件的建立）

java程式設計思想讀書筆記一（面向物件）

java程式設計思想重點筆記（java程式設計師必看）

Java中的多型性理解（注意與C++區分）

2. is-a關係和is-like-a關係

3. 執行時型別資訊（RTTI + 反射）

4. 代理模式與Java中的動態代理

5. 即時編譯器技術 — JIT

6. 訪問控制權限

7. 組合和繼承之間的選擇

8. final關鍵字

9. 策略設計模式與介面卡模式的區別

10. 內部類

11. String型別 — 不可變

12. 序列化控制

相關推薦