《Thinking in Java》Seven 複用類

組合：在一個新類中建立另外一個已有類的對象。

繼承：是全部OOP語言不可缺乏的組成部分，會自動獲得基類中全部的域和方法，extends

package sixth;

class Art{
 Art(){System.out.println("JiLei1");}
}
class Drawing extends Art{
 Drawing(){
  System.out.println("extends JiLei 2");
 }
}
public class ExtendsD extends Drawing{
 
 public static void main(String[] args){
  new ExtendsD();
 }
}/*JiLei1
extends JiLei 2*/

代理

代理是組合和繼承的中庸之道

package sixth;

//代理是組合和繼承的中庸之道

class Cleaner{
 private String s = "Cleaner";
 public void append(String a){System.out.println(s += a);}
 public void apply(){append("apply()");}
 public void scrub(){append("scrub()");}
 public String toString(){return s;}
}

//將一個成員對象置於所要構建的類中private Cleaner cle = new Cleaner();像組合

/*同時在新類中暴露該對象的全部方法public void append(String a){cle.append(a);}
//public void apply(){cle.apply();}
//public void scrub(){cle.scrub();}
//public String toString(){System.out.println(s);return s;}像繼承*/

public class DaiLi {
 private String s = "DaiLi";
 private Cleaner cle = new Cleaner();
 public void append(String a){cle.append(a);}
 public void apply(){cle.apply();}
 public void scrub(){cle.scrub();}
 public String toString(){System.out.println(s);return s;}
 
 public static void main(String[] args){
  DaiLi dL = new DaiLi();
  dL.append("12");
  dL.apply();
  dL.scrub();
  dL.toString();
 }

}/*使用代理

Outputs:
Cleaner12
Cleaner12apply()
Cleaner12apply()scrub()
DaiLi*/

 

初始化順序

 package sixth;
class Insect {
    private static int si = numOfLegs("Static si Insect");
    protected int j;
    private int i = 0;
    public Insect() {
    
        // j並未初始化
      
        System.out.println("Insect Constructor: i = " + i + " j = " + j);
        j = 10;
    }
    protected static int numOfLegs(String s) {
        System.out.println(s);
        return 4;
    }
}
class Beetle extends Insect {
    private static int si = numOfLegs("Static si Beetle");
    private int i = numOfLegs("Beetle");
  
    // 並未顯示調用Insect的構造函數
  
    public Beetle() {
        System.out.println("Beetle Constructor: i = " + i + " si = " + si);
    }
}
public class Cockroach extends Beetle {
    private static int si = numOfLegs("Static si Cockroach");
    private int i = numOfLegs("Cockroach");
  
    // 並未顯示調用Insect的構造函數
   
    public Cockroach() {
        System.out.println("Cockroach Constructor: i = " + i + " si = " + si);
    }
    public static void main(String[] args) {
        System.out.println("Cockroach Construct");
   
       Cockroach b = new Cockroach(); // 構造引發靜態變量初始化
    
        System.out.println(Cockroach.si); // 調用靜態變量
    }
}
/*
 * Static si Insect //根基類的static先被加載
Static si Beetle    //基類的static被加載
Static si Cockroach //導出類 static加載
Cockroach Construct //進入main()
Insect Constructor: i = 0 j = 0//根基類的構造器加載，對象中的基本類型被初始化 j被初始化爲0，對象的引用被初始化爲null 
Beetle        //基類方法
Beetle Constructor: i = 4 si = 4 //導出類構造器
Cockroach
Cockroach Constructor: i = 4 si = 4
4*/

final和private

package sixth;
class WithFinals{
 private final void f(){
  System.out.println("WithFinals f()");
 
  }//與不加final是同樣的，private方法隱含是final的
 
 protected void g(){
  System.out.println("WithFinals g()");
  }
}
final class OverridePrivate extends WithFinals{

 //@Override private方法沒法覆蓋

 private void f(){
  System.out.println("OverridePrivate f()");
 }
 @Override
 protected void g(){
  System.out.println("OverridePrivate g()");
  }
}

//final類不能被繼承

/*class OverridePrivate2 extends OverridePrivate{
 //@Override
 public final void f(){
  System.out.println("OverridePrivate2 f()");
 }
 @Override
 public void g(){
  System.out.println("OverridePrivate2 g()");
 }
}*/
public class FinalMethod {
 public static void main(String[] args){
  //OverridePrivate2 op2 = new OverridePrivate2();
  //op2.f();
  //op2.g();
  
  //OverridePrivate op = op2;
 
  //op.f(); 沒法調用
 
  //op.g();
  
  WithFinals wf = new WithFinals();
  
  wf.g();
 
  //wf.f(); 沒法調用the method f() from WithFinals is not visible
 
  //private方法當作他所屬的類的組織結構的緣由而存在 無其餘意義
 
 }
}

static final

一個既是static又是final的域佔據一段不能改變的存儲空間，定義爲static強調只有一份，定義爲final說明是一個常量。

向上轉型

導出類是基類的一個超集，可能含有比基類更多的方法，但至少具有基類的方法，在向上轉型過程當中可能會丟失方法。

package sixth;
class Amphibian{
 public void say(Amphibian a){
  System.out.println(a + " say hi");
 }
}
class Frog extends Amphibian{
 
}
public class XiangShangZhuanXing {
 
 public static void say(Amphibian a){
  System.out.println(a + " say hello");
 }
 public static void main(String[] args){
  Frog frog = new Frog();
  frog.say(frog);
  say(frog);
 }
}
/*sixth.Frog@19e0bfd say hi  基類的方法
sixth.Frog@19e0bfd say hello*/