<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    eric-1001c

      BlogJava :: 首頁 :: 新隨筆 :: 聯系 :: 聚合  :: 管理 ::
      3 隨筆 :: 45 文章 :: 12 評論 :: 0 Trackbacks

    1) 惰性初始化。就是在正要使用這些對象之前,對對象進行初始化的方法。這種方式可以減少額外的負擔;

     

    public class Bath{
       
    private String
          s1 
    = "Happy",
          s2,
          s3;

       
    public Bath(){
          print(
    "inside Bath()");
          s2 
    = "Joy";
       }


       
    public String toString(){
          
    //惰性初始化
          if(s3==null) s3 = "Exciting";

          
    return "s1="+s1+"; s2="+s2+"; s3="+s3;
       }

    }

    2)在繼承層次結構中,構造器的構建過程(或者說類)是從基類“向外”擴散的,所以基類在導出類構造器可以訪問之前就已經完成了初始化,換句話說,調用基類的構造器必須是導出類構造器中要做的第一件事情(當然這是編譯器的工作); 

    3)代理。是繼承和組合之間的折衷。使用代理可以擁有更多的控制力,因為可以選擇只提供在成員對象中的方法的某個子集(繼承就完全“暴露”了方法接口)

     1class Cleanser {
     2    private String s = "Cleanser";
     3    
     4    public void append(String a ){
     5        s += a;
     6    }

     7    public void dilute(){
     8        append("dilute()");
     9    }

    10    public void apply(){
    11        append("apply()");
    12    }

    13    public void scrub(){
    14        append("scrub()");
    15    }

    16    public String toString(){
    17        return s;
    18    }

    19}

    20
    21public class Detergent {
    22    private String name;
    23    private Cleanser cleanser = new Cleanser();
    24    
    25    public Detergent(String name){
    26        this.name = name;
    27    }

    28        
    29        //只選擇暴露了Cleanser的部分方法子集
    30    public void scrub(){
    31        cleanser.scrub();
    32    }

    33    public void apply(){
    34        cleanser.apply();
    35    }

    36    public void dilute(){
    37        cleanser.dilute();
    38    }

    39    public String toString(){
    40        return cleanser.toString();
    41    }

    42    /**
    43     * @param args
    44     */

    45    public static void main(String[] args) {
    46        Detergent detergent = new Detergent("detergent");
    47        detergent.apply();
    48        detergent.dilute();
    49        System.out.println(detergent.toString());
    50    }

    51}

    3)在清理方法中,必須注意對基類清理方法和成員對象清理方法的調用順序,以防止某個子對象依賴于另一個子對象情形的發生:首先,執行類的所有特定的清理動作,其順序同生成順序相反;然后,調用基類的清理方法

    4)@Override注解可以防止你不想重載(overload)時而意外進行了重載,同時也要求你使用了@Override注解后就得覆蓋原來的方法
     1public class PrivateExtend1{
     2    private final void f(){
     3        System.out.println("privateExtend f()");
     4    }

     5    
     6    private  final void g(){
     7        System.out.println("privateExtend g()");
     8    }

     9}

    10
    11class PrivateExtend2 extends PrivateExtend1{
    12//這里不注解就會錯
    13//    @override 
    14    public final void f(){
    15        System.out.println("privateExtend2 f()");
    16    }

    17    
    18//    @Override
    19    public final void g(){
    20        System.out.println("privateExtend2 g()");
    21    }

    22}

    5) 對于組合和繼承的選擇,一個最清晰的判斷方法就是問一問自己是否需要從新類向基類進行向上轉型。如果必須向上轉型,則繼承是必要的,但如果不需要,則應當好好考慮自己是否需要繼承。組合的好處是允許你在運行時確定對象類型,甚至調用的方法,比如 strategy pattern通過設置基類的成員變量,而傳入導出類作為參數來動態改變對象類型以及方法。

    6) 雖然可以通過protected關鍵創建一些protected域,但最好的方式還是將域保持為private;然后通過protected方法來控制類的繼承者的訪問權限。

    7) 對于基本類型,final使數值恒定不變;而用于對象引用,final使引用恒定不變。一旦引用被初始化指向一個對象,就無法再把它改為指向另一個對象。然而,對象其自身卻是可以被修改的。

    8) final和static final的區別。區別只有當數值運行時內被初始化才會顯現,這是因為編譯器對編譯時數值一視同仁。
    import java.util.Random;

    public class FinalStatic {
        
    private final int i1 = new Random().nextInt();
        
    private static final int i2 =  new Random().nextInt();
        
        
    public String toString(){
            
    return ("i1: "+i1+"\t"+"i2: "+i2);
        }

        
    /**
         * 
    @param args
         
    */

        
    public static void main(String[] args) {
            FinalStatic fs 
    = new FinalStatic();
            System.out.println(fs.toString());
            
            FinalStatic fs2 
    = new FinalStatic();
            System.out.println(fs2.toString());
        }

    }

    //output
    i1: -1658811818    i2: 219593609
    i1: 
    -33942    i2: 219593609

    9) Java允許“空白final”,即指被聲明為final但又未給定初值的域。無論什么情況,編譯器都確保空白final在使用前必須被初始化
    class Poppet{
        
    private int i;
        Poppet (
    int i){
            
    this.i = i;
        }

    }

    public class BlankFinal {
        
    //poppet is a blank final
        private final Poppet poppet;
        
        
    //blank final must be initialized before constructor
        public BlankFinal(){
            poppet
    = new Poppet(5);
        }

        
    /**
         * 
    @param args
         
    */

        
    public static void main(String[] args) {
            BlankFinal bf 
    = new BlankFinal();
    //        cann't change a final field of the object after the constructor`
    //        bf.poppet = new Poppet(0);
        }

    }

    10)初始化及類的加載:
       1.在Beetle運行時,所發生的第一件事情就是試圖訪問Beetle.maini()(一個static方法)。于是加載器開始啟動并找出Beetle類的編譯代碼(Beetle.class)。在加載過程中,編譯器注意到它有基類(extends告知),于是就繼續加載基類,如果基類還有基類,就繼續加載下去;
       2.接下來,根基類的static初始化即會被執行,然后下一個導出類的static,以此類推。
       3.必要的類都加載完畢,對象開始創建。首先,對象中的所有基本類型都會被設為默認值,對象引用被設為null;然后,基類的成員變量會被初始化;接著基類的構造器會被調用,在基類構造器完成之后,實例變量按其次序被初始化,最后,構造器其余部分被執行
    class Insect{
        
    private int i = 9;
        
    protected int j;
        
        Insect()
    {
            System.out.println(
    "i="+i+", j="+j);
            j 
    = 39;
        }

        
        
    private static int x1 = printInit("static Insect.x1 initialized");
        
    static int printInit(String s){
            System.out.println(s);
            
    return 47;
        }

    }

    public class Beetle extends Insect{
        
    private int k = printInit("Beetle.k initialized");
        
    public Beetle(){
            System.out.println(
    "k=" +k);
            System.out.println(
    "j=" +j);
        }

        
    private static int x2 = printInit("static Beetle.x2 initialized");
        
    /**
         * 
    @param args
         
    */

        
    public static void main(String[] args) {
            System.out.println(
    "Beetle constructor");
            Beetle b 
    = new Beetle();
        }

    }

    //output
    static Insect.x1 initialized
    static Beetle.x2 initialized
    Beetle constructor
    i
    =9, j=0
    Beetle.k initialized
    k
    =47
    j
    =39

    posted on 2007-07-10 23:39 Eric-1001c 閱讀(153) 評論(0)  編輯  收藏 所屬分類: ThinkingInJava
    主站蜘蛛池模板: 在线免费观看韩国a视频| 亚洲国产另类久久久精品小说| 精品国产免费观看久久久| 久久久久亚洲AV无码专区首JN| 国产精品爱啪在线线免费观看| 亚洲AV成人精品网站在线播放| sihu国产精品永久免费| 久久精品亚洲一区二区 | 久久免费高清视频| 亚洲综合无码AV一区二区 | 亚洲国产模特在线播放| 大陆一级毛片免费视频观看i| 国产精品综合专区中文字幕免费播放| 久久亚洲精品成人777大小说| 四虎成人免费大片在线| 在线涩涩免费观看国产精品 | 亚洲欧洲免费无码| jyzzjyzz国产免费观看| 亚洲乱码一二三四区国产| 国产亚洲大尺度无码无码专线| 韩国免费一级成人毛片| 少妇性饥渴无码A区免费| 亚洲国产成人综合精品| 久久国产亚洲电影天堂| 国产一级做a爱免费视频| 曰批视频免费40分钟试看天天 | 日本亚洲中午字幕乱码| 亚洲日本国产乱码va在线观看| 精品亚洲一区二区三区在线观看| 成人一区二区免费视频| 亚洲高清免费在线观看| 国产偷窥女洗浴在线观看亚洲| 一本无码人妻在中文字幕免费| 久久国产乱子伦精品免费一| 国产成人精品日本亚洲网址| 国产亚洲av片在线观看16女人| 国产一区二区视频免费| 免费做爰猛烈吃奶摸视频在线观看| a在线观看免费视频| 成年免费大片黄在线观看com| 亚洲视频中文字幕|