第十五章泛型

1.概念

泛型實現了「引數化型別」的概念

2.簡單泛型

泛型的主要目的：用來指定容器要持有什麼型別物件，而且由編譯器來保證型別的正確性
一個元組類庫

(1) 元組（又稱：資料傳遞物件或信使）：它是將一組物件直接打包儲存與其中的一個單一物件。這個容器物件允許讀取其中元素，但不允許存放新物件
(2) 元組隱含的保持了其中元素的次序
(3) 元組中的物件可以是任意型別
(4) 元組利用繼承機制增加長度
(5) 宣告為final元素被構造出來便不能賦其他值，保護了public元素

3.泛型介面

生成器（generator）：負責建立物件的類
Java泛型的侷限性：基本型別無法作為型別引數，但JavaSE5可以自動打包和拆包

4.泛型方法

是否擁有泛型方法，與其所在的類是否為泛型沒有關係
如果泛型方法可以取代將整個方法泛型化，那麼只是用泛型方法
泛型方法的格式：泛型參數列置於返回值之前

public <T> void f(T x){}

編譯器的「型別引數推斷」：使用泛型方法，無需指明引數型別
槓桿利用型別引數推斷

(1) 型別推斷只對賦值操作有效，其他時候不起作用
(2) 呼叫泛型方法後，其返回值被賦給一個Object型別變數
(3) 顯示的型別說明
- i.在點操作符與方法名之間插入尖括號，把型別置於括號內
- ii.f(New.<Person,List>map())

一個set使用工具

    Set<T> res = new HashSet<T>(a)

	(1) res.addAll(b)：合併a、b兩個set
	(2) res.retainAll(b)：取兩個set交集
	(3) res.removeAll(b):從a中刪除b

5.匿名匿名內部類

泛型可以應用於內部類以及匿名內部類

6.構建複雜模型

package Chapter15.Test19;

import java.util.ArrayList;
public class CargoHold extends ArrayList<Container> {
    public CargoHold(int nContainers, int nProducts){
        for(int i = 0; i < nContainers; i++)
            add(new Container(nProducts));
    }
}
---------------------------------
package Chapter15.Test19;

import java.util.ArrayList;

//貨船
public class CargoShip extends ArrayList<CargoHold> {
    private ArrayList<Crane> cranes = new ArrayList<Crane>();
    private CommandSection cmdSection = new CommandSection();

    public CargoShip(int nCargoHolds, int nContainers, int nProducts) {//貨艙，集裝箱，物品
        for (int i = 0; i < nCargoHolds; i++)
            add(new CargoHold(nContainers, nProducts));
    }

    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        for (CargoHold cargoHold : this) {
            for (Container container : cargoHold) {
                for (Product product : container) {
                    stringBuilder.append(product);
                    stringBuilder.append("\n");
                }
            }
        }
        return stringBuilder.toString();
    }
}
------------------------------
package Chapter15.Test19;

//指揮部
public class CommandSection {
}
---------------------------------
package Chapter15.Test19;

import Chapter15.Test18.Generators;

import java.util.ArrayList;

//集裝箱
public class Container extends ArrayList<Product> {
    public Container(int nProducts) {
        Generators.fill(this, Product.generator, nProducts);
    }
}
-----------------------------------------
package Chapter15.Test19;

//起重機
public class Crane {
}
-----------------------------------------
package Chapter15.Test19;

import net.mindview.util.Generator;

import java.util.Random;

class Product {
  private final int id;
  private String description;
  private double price;
  public Product(int IDnumber, String descr, double price){
    id = IDnumber;
    description = descr;
    this.price = price;
    System.out.println(toString());
  }
  public String toString() {
    return id + ": " + description + ", price: $" + price;
  }
  public void priceChange(double change) {
    price += change;
  }
  public static Generator<Product> generator =
    new Generator<Product>() {
      private Random rand = new Random(47);
      public Product next() {
        return new Product(rand.nextInt(1000), "Test",
          Math.round(rand.nextDouble() * 1000.0) + 0.99);
      }
    };
}
-------------------------------
package Chapter15.Test19;

public class Test19 {
    public static void main(String[] args) {
        System.out.println(new CargoShip(14, 5, 10));//14個貨艙，5個集裝箱，10個貨物
    }
}

7.擦除的神祕之處

在泛型程式碼內部，無法獲得任何有關泛型引數型別的資訊

使用泛型時，任何具體的型別資訊都會被擦除，你唯一知道的就是你在使用的物件

Class c1 = new ArrayList<String>().getClass();
Class c2 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2);→true

可以給定泛型類的邊界，以此告知編譯器只能接受遵循這個邊界的型別，這裡使用extends關鍵字，泛型型別引數將擦除到他的第一個邊界（可能會有很多邊界）

  	public class Store <T extends Coffee & Generator> {}

（1）雖然T 被擦除為Coffee，但是同時可以使用Coffee，Generator的方法。

（2）只是如：void set(T t)的方法，此時編譯器提示引數型別為Coffee，只實現Generator的引數傳入，編譯器會報錯提示引數型別不正確。

遷移相容性

(1) 為了使泛型和非泛型程式碼共存
(2) 在基於擦除實現中，泛型型別被當作第二類型別處理
(3) 泛型只有在靜態類期間才出現（編譯器），在此之後，程式中所有的泛型都被擦除，替換為它們的非泛型上界（extends 後第一邊界，預設是Object）

邊界處的動作

(1) 「邊界就是發生動作的地方」
(2) 對傳入(set) 的值進行二外的編譯期檢查，並插入對傳出(get) 的值進行轉型

8.擦除的補償

因為擦除帶來的問題，任何執行時需要知道確切型別的操作都將無法運作（instanceof、new、==）
引入型別標籤補償：顯示的傳遞你的型別Class物件，以便可以在型別表示式中使用它【Class kind】定義一個Class物件
對於kind.newInstance()建立物件範例的方式，如果沒有預設的建構函式，執行會報錯並且編譯時無法檢查，如Integer。【因此推薦使用工廠模式】
如果說Class.newInstance是一種隱式的工廠，那麼FactoryMain.newInstanse就是一種顯示的工廠。
建立物件範例還可以使用【模板方法設計模式】
泛型陣列

(1) 任何想建立泛型陣列的地方都是用ArrayList
(2) 成功建立泛型陣列的唯一方式就是建立一個被擦除型別的新陣列，然後對其轉型

9.邊界

邊界使得你可以在用於泛型的引數型別上設定限制條件
可以按照自己的邊界型別來呼叫方法
當發生擦除時（例：），會擦除到第一個邊界，此時不僅可以使用Object方法，還可以使用邊界類ArrayList的方法
可以有多個邊界，類必須放第一個，後面為多介面。

10.萬用字元

可以將匯出類的陣列賦予給基本類型的陣列參照

Fruit[] fruits = new Apple[10];
fruits[1] = new Apple();
fruits[0] = new Fruit(); //可以編譯通過，執行報錯ArrayStoreException

(1) 因為陣列的型別實際上是Apple，所以元素可以放入Apple及其子類。放入Fruit編譯可以通過，執行會報錯ArrayStoreException。
(2) 泛型正是為了：將型別性錯誤檢測移到編譯期。

使用泛型容器代替

 List<Fruit> fruit = new ArrayList<Apple>(); //編譯錯誤

編譯錯誤的原因是Fruit的list 和 Apple 的list是兩種容器的型別，而不是僅僅是不同的持有型別。泛型沒有內建的協變型別，他們不能向上轉型。

協變：子類能向父類別轉換
逆變：父類別能向子類轉換
編譯器會直接拒絕對參數列中設計萬用字元的方法（例如：add()）的呼叫
編譯器無法驗證「任何事物」的型別安全（例如：<? extends Fruit>）
萬用字元

(1)【協變】萬用字元
- i.協變萬用字元
```
public static void main(String[] args) {
    List<? extends Fruit> fruits = new ArrayList<>();
    fruits.add(new Apple()); //Error 編譯錯誤
    fruits.add(new Fruit()); //Error 編譯錯誤
    fruits.add(null);

    Fruit fruit = fruits.get(0); //安全的
    System.out.println(fruit);
}
```
- ii.向上轉型的關係，可以使用匯出類萬用字元
  <? extends Fruit>，其意義是Fruit及其子類中的任意一種，具體哪一種不清楚，因此Fruit一定可以作為get方法的返回值，但不能set方法的引數(add同理)
- iii.泛型只是編譯器檢查，可以有各種方法繞過。比如利用反射向list中新增元素，或者向下面這樣：
  List<? extends Fruit> fruits = Arrays.asList(new Apple(), new Fruit());
(2)【逆變】萬用字元
- i.協變萬用字元
```
public static void main(String[] args) {
    List<? super Fruit> fruits = Arrays.asList();
    fruits.add(new Apple()); //安全
    fruits.add(new Fruit());  //安全
    fruits.add(null);

    Fruit fruit = fruits.get(0);//Error 編譯錯誤
    System.out.println(fruit);
}
```
- ii.建立關係，還可以使用超型別萬用字元 <? super Fruit> ，其意義是Fruit及其父類別中的任意一種，具體哪一種不清楚，因此Fruit一定可以作為set方法的引數（add同理），但卻不能作為get方法的返回值。
- iii.不能對泛型引數給出一個超型別邊界，即不能宣告

無界萬用字元

(1) 無界萬用字元

public static void main(String[] args) {
    List<?> fruits = Arrays.asList();
    fruits.add(new Apple()); //Error 編譯錯誤
    fruits.add(new Fruit()); //Error 編譯錯誤
    fruits.add(null);

    Fruit fruit = fruits.get(0);//Error 編譯錯誤

    fruits.add(new Object()); //Error 編譯錯誤
    Object obj = fruits.get(0); //安全
    System.out.println(obj);
}

(2) List<?> 無界萬用字元表示「任意事物」中的一種，哪一種還是不知道，因此沒有型別能作為set方法的引數（add同理），除了Object，其他型別也都不能作為get方法的返回值。由此可知 List（或List）和 List<?> 只是長得很像。
(3) 確切型別替換萬用字元的好處是：可以用泛型引數來做更多事
(4) 使用萬用字元使得你必須接受範圍更寬的引數化型別作為引數

11.泛型中的問題

任何基本型別都不能作為型別引數。

(1) ArrayList ×
(2) ArrayList √

一個類不能實現同以泛型介面的兩種變體

interface Payable<T> {}

class Employee implements Payable<Employee> {}
class Hourly extends Employee implements Payable<Hourly> {}

轉型和警告

使用帶有泛型型別的引數的轉型或instanceof不會有效

由於擦除的原因，泛型不能過載

錯誤：

    public void f(List<T> list){}
    public void f(List<W> list){}

正確：

    public void f1(List<T> list){}
    public void f2(List<W> list){}

基礎類別劫持了介面

Base類確定了介面I1泛型為String，那麼C1 繼承了Base ，再次實現介面I1，泛型不能是Integer，只能是String（被劫持）

12.自限定的型別

自限定

public class SelfBounded<T extends SelfBounded<T>> {}
    擦除，去掉 extends 和 T
public class SelfBounded<SelfBounded>{}

(2) 的意思是：自己限定自己，SelfBounded的泛型引數是SelfBounded自己
(3) 的意思是：泛型引數為SelfBound及其子類
(4) 自限定引數的意義在於：它可以保證型別引數必須與正在被定義的類相同

引數協變

(1) 自限定型別的價值在於他們可以產生協變引數型別
(2) 如果不使用自限定，將過載引數型別
(3) 如果使用自限定，只能獲得某一個方法的一個版本（覆蓋）

13.動態型別安全

靜態方法：checkedCollection()、checkedList()、checkedMap()、chenckedSet()、checkedSortedMap()、chenckedSortedSet()這些方法每一個都會將你希望動態檢查的容器當作第一個引數接受，並將你希望強制要求的型別作為第二個引數接受

14.異常

catch語句不能捕獲泛型型別的異常，但可以作為方法簽名上throws 異常部分

interface Test2<T extends Exception> {
    void test() throws T;
}

15.混型

概念：混合多個類的能力，以生產一個可以表示混型中所有型別的類
價值：他們可以將特性和行為一致地應用於多個類上
java語法上不支援多繼承，那麼最簡單實現方式，就是單繼承多介面 + 代理了（內部類實現多繼承也是一種代理）
使用裝飾器模型

(1) 裝飾器指定包裝在最初的物件周圍的所有物件都具有相同的基本介面
(2) 無論物件是否被修飾，你都擁有一個可以向物件傳送的公共訊息集
(3) 裝飾器是通過使用組合和形式化結構來實現的
(4) 對於裝飾器來說，其明顯的缺陷是它只能有效的工作於裝飾中的一層，而混型顯得更自然些

動態代理可以實現近似的混型

package Chapter15.Test39.DynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author:YiMing
 * @version:1.0
 */

//說話的能力
interface ISay {
    void say();
}

class SayImpl implements ISay {
    @Override
    public void say() {
        System.out.println("hello");
    }
}

//報時的能力
interface IDate {
    void now();
}

class DateImpl implements IDate {
    @Override
    public void now() {
        System.out.println(new Date());
    }
}

//唱歌的能力
interface ISing {
    void sing();
}

class SingImpl implements ISing {
    @Override
    public void sing() {
        System.out.println("lalalalalala!");
    }
}

class Mix implements InvocationHandler { //動態代理
    private Map<String, Object> delegates = new HashMap<>();

    public Mix(Object... args) {
        for (Object obj : args) {
            Class<?> clazz = obj.getClass();
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                if (!delegates.containsKey(method.getName())) {
                    delegates.put(method.getName(), obj);
                }
            }
        }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object delegate = delegates.get(method.getName());
        return method.invoke(delegate, args);
    }

    public static Object newInstance(Class[] clazzes, Object[] objects) {
        return java.lang.reflect.Proxy.newProxyInstance(Mix.class.getClassLoader(), clazzes, new Mix(objects));
    }
}


public class Proxy {
    public static void main(String[] args) {
        //混合三種能力
        Object mixObj = Mix.newInstance(
                new Class[]{ISing.class, IDate.class, ISay.class},
                new Object[]{new SingImpl(), new DateImpl(), new SayImpl()});

        ISing singObj = (ISing) mixObj;
        singObj.sing();

        ISay sayObj = (ISay) mixObj;
        sayObj.say();

        IDate dateObj = (IDate) mixObj;
        dateObj.now();
    }
}

16.潛在型別機制

只要求實現某個方法子集，而不是特定的類或者介面，使得你可以橫跨類繼承結構，呼叫不屬於公共介面的方法
簡單來說：我不關心你是什麼型別，只要你可以say() 和 sing() 就可以了
Python（動態型別語言）和C++（靜態型別語言）由於不具體要求具體型別，因此程式碼可以更泛化
Java語法不支援，潛在型別機制

17.對缺乏潛在型別機制的補償

反射

package Chapter15;
// Using Reflection to produce latent typing.
import java.lang.reflect.*;
import static net.mindview.util.Print.*;

// Does not implement Performs:
class Mime {
  public void walkAgainstTheWind() {}
  public void sit() { print("Pretending to sit"); }
  public void pushInvisibleWalls() {}
  public String toString() { return "Mime"; }
}

// Does not implement Performs:
class SmartDog {
  public void speak() { print("Woof!"); }
  public void sit() { print("Sitting"); }
  public void reproduce() {}
}	

class CommunicateReflectively {
  public static void perform(Object speaker) {
    Class<?> spkr = speaker.getClass();
    try {
      try {
        Method speak = spkr.getMethod("speak");
        speak.invoke(speaker);
      } catch(NoSuchMethodException e) {
        print(speaker + " cannot speak");
      }
      try {
        Method sit = spkr.getMethod("sit");
        sit.invoke(speaker);
      } catch(NoSuchMethodException e) {
        print(speaker + " cannot sit");
      }
    } catch(Exception e) {
      throw new RuntimeException(speaker.toString(), e);
    }
  }
}

public class LatentReflection {
  public static void main(String[] args) {
    CommunicateReflectively.perform(new SmartDog());
    CommunicateReflectively.perform(new Mime());
  }
} /* Output:
Woof!
Sitting
Mime cannot speak
Pretending to sit
*///:~

18.將函數物件用作策略

泛型在策略模式中的使用

package Chapter15;

/**
 * @author:YiMing
 * @version:1.0
 */
interface Strategy<T, R> {
    R operation(T obj1, T obj2);
}

//整數相加操作
class IntegerAddOperation implements Strategy<Integer, Integer> {
    @Override
    public Integer operation(Integer obj1, Integer obj2) {
        return obj1 + obj2;
    }
}

//字串比較操作
class StringCompareOperation implements Strategy<String, String> {
    @Override
    public String operation(String obj1, String obj2) {
        Integer result = obj1.compareTo(obj2);
        if ( result == 0) {
            return obj1 + " == " + obj2;
        } else if (result > 0) {
            return obj1 + " > " + obj2;
        } else {
            return obj1 + " < " + obj2;
        }
    }
}

public class Context {
    public static void execute( Object obj1, Object obj2,Strategy strategy) {
        Object result = strategy.operation(obj1, obj2);
        System.out.println(result);
    }

    public static void main(String[] args) {
        execute(1, 2, new IntegerAddOperation());
        execute("today", "tomorrow", new StringCompareOperation());
    }
}

第十五章 泛型

文章目錄

1.概念

2.簡單泛型

一個元組類庫

3.泛型介面

4.泛型方法

一個set使用工具

5.匿名匿名內部類

6.構建複雜模型

7.擦除的神祕之處

遷移相容性

邊界處的動作

8.擦除的補償

泛型陣列

9.邊界

10.萬用字元

萬用字元

無界萬用字元

11.泛型中的問題

任何基本型別都不能作為型別引數。

由於擦除的原因，泛型不能過載