Life at Shanghai

找到兩個簡單的guide，記下來備用：

http://fedoranews.org/contributors/stanton_finley/fc3_note/

http://www.mjmwired.net/resources.php?PHPSESSID=e63a1fe2caddc29e491f26c285189cdf

//從老家搬篇過來，看看排版與顯示效果如何。

6. Reusing Classes

Java編譯器并不會給任何reference產(chǎn)生缺省對象，這樣就避免了大多數(shù)情況下的不必要的負(fù)擔(dān)。初始化需要的對象可以在以下地點(diǎn)：

１，對象定義處。由于類初始化順序的規(guī)則，這樣做可以保證以此方法初始化的對象將會在構(gòu)造函數(shù)被調(diào)用前完成初始化。
２，構(gòu)造函數(shù)內(nèi)部。
３，當(dāng)需要使用該對象時，這種方式被稱為（緩式初始化）lazy initialization。如果一個對象并非總是必須，那么這種方式可以減少額外負(fù)擔(dān)。

關(guān)于清理動作，要注意的是順序：首先執(zhí)行當(dāng)前類的所有清理動作（其中次序和生成次序相反），而后再調(diào)用base class的清理函數(shù)。外帶一句，除了內(nèi)存，最好永遠(yuǎn)不要相信垃圾回收機(jī)制。

Final data

Bruce在這部分說：Java中final修飾對于基本類型和對象引用（object reference）而言，意義是不同的。用于基本類型時，final讓value（數(shù)值）保持不變。用于object reference時，final讓reference保持不變，但對象本身的內(nèi)容卻是可以更動的惡。Java并未提供讓任何對象保持不變的機(jī)制，雖然可以自己編寫具有保持不變效果的class。特別提醒，array也是對象。

我要說的是，我沒發(fā)現(xiàn)final在基本類型與對象引用的意義有何不同。final都是讓兩者的value保持不變，基本類型的value就是對應(yīng)的數(shù)值或者bool值。而對象引用的value在理解上可以解釋為指向object的地址。當(dāng)然，這里似乎對于Java的底層實(shí)現(xiàn)做了假設(shè)而我確實(shí)也沒細(xì)究過Java如何實(shí)現(xiàn)object reference的。但是，就Java語法及我個人的體會而言，我覺得這是很好的一種理解方式。

Blank finals

Java允許把數(shù)據(jù)成員聲明為final卻不賦予初始值。當(dāng)然，final修飾的數(shù)據(jù)成員必須在其被使用前完成初始化，這一點(diǎn)由編譯器保證。這個特性讓我們可以把某個數(shù)據(jù)成員聲明為final具有不變的特性，卻在每個對象中為不同的值。

Final arguments

Java中還可以把method的arguments聲明為final，意義不變，只是不變特性的范圍僅僅在此method內(nèi)。對于對象引用，即是在此method內(nèi)擁有此對象的一個不可變更的引用，而不影響此對象存在其他非final的引用。

Final method

有兩個原因把一個method修飾成final。第一，對于類A中的某個method，你希望在類A所有子類中此方法的表現(xiàn)不變，即此方法不可被覆寫（overriding）。第二，處于效率考慮，因?yàn)榫幾g器會嘗試把不太長的final method改為inner method。而Bruce Eckel建議我們不要相信編譯器的智商，只在確實(shí)處于設(shè)計的考慮需要時，才把method修飾為final。

final & private

private的method對于子類是不可見的，自然也無法覆寫（overriding）。似乎，private隱含了final？如果一個函數(shù)已經(jīng)是private，似乎final修飾與否都無關(guān)緊要？ 
首先，這兩個假設(shè)，前者錯誤，后者正確。因?yàn)閜rivate的method對于子類是不可見的， 所以對于子類而言如此的函數(shù)就如同是父類中的一段普通代碼。如果此時在子類中聲明一個與父類中的private method同名的函數(shù)，編譯器是允許的。然而，注意，此時只是在這個繼承體系中加入了一個新函數(shù)而已，并非是一個覆寫。因?yàn)楦矊懀╫verriding）的前提是，被覆寫的函數(shù)是可見，是父類的對外的界面。至于對private函數(shù)再加final修飾，編譯器是允許的。但毫無意義，因?yàn)閜rivate的函數(shù)對于子類不可見，所以也就無需聲明是否允許覆寫(overriding)。

下面還是貼段代碼來解釋：

/**//*
 * Created on 2004-11-30
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package com.smilereader.test;

/**//**
 * @author Sinbadblue Kong
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
class Treasure {
    
    private final void f(){
        System.out.println("Treasure.f()");
    }
    
    private void g(){
        System.out.println("Treasure.g()");        
    }
    
    final void e(){
        System.out.println("Treasure.e()");
    }
    
}

/**//*
 * Created on 2004-12-5
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package com.smilereader.test;

/**//**
 * @author Sinbadblue Kong
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
class Gemstone extends Treasure {
    
    //    add a new method Gemstone.f(), it isn't an overriding
    public final void f(){
        System.out.println("Gemstone.f()");
        
    }
    
    //  add a new method Gemstone.g(), it isn't an overriding
    public void g(){
        System.out.println("Gemstone.g()");
    }
 
    //can't overriding Treasure.e()
//    public void e(){
//        System.out.println("Gemstone.e()");
//    }

}

我覺得Java的編譯器在此處的處理不太合適，容易導(dǎo)致混淆。如果對于private 與 final修飾做互斥處理，我個人覺得會是比較合適的又容易理解的方式。

去年用英文寫B(tài)LOG時的帖子，自己轉(zhuǎn)自己，叫自轉(zhuǎn) :P

The Open Closed Principle (OCP) states that we should be able to add new features to our system without having to modify our set of preexisting classes. The following Class Diagram shows that how to design the relationship between the classes so as to adhere the OCP under certain circumstance:

The User class has a relationship to the UserType abstract class. The simple sample design shows that it adheres one of the tenets of OCP:“to reduce the coupling between classes to the abstract level. Instead of creating relationships between two concrete classes, we create relationships between a concrete and an abstract class ,or in Java, between a concrete class and an interface.

Principles should be reminded again and again. ^_^

"Everything is under testing" by Blue Kong