第十五章泛型-有解無憂

文章目錄

- - - - 1.概念
      - 2.簡單泛型
      - 一個元組類別庫
      - 3.泛型介面
      - 4.泛型方法
      - 一個set使用工具
      - 5.匿名匿名內部類
      - 6.構建復雜模型
      - 7.擦除的神秘之處
      - 遷移兼容性
        邊界處的動作
      - 8.擦除的補償
      - 泛型陣列
      - 9.邊界
      - 10.通配符
      - 通配符
        無界通配符
      - 11.泛型中的問題
      - 任何基本型別都不能作為型別引數，
        由于擦除的原因，泛型不能多載
      - 12.自限定的型別
      - 自限定
        引數協變
      - 13.動態型別安全
      - 14.例外
      - catch陳述句不能捕獲泛型型別的例外，但可以作為方法簽名上throws 例外部分
      - 15.混型
      - 使用裝飾器模型
        動態代理可以實作近似的混型
      - 16.潛在型別機制
- 17.對缺乏潛在型別機制的補償
- - 反射
  - - - 18.將函式物件用作策略

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());
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/168824.html

標籤：其他

上一篇：JVM-類加載子系統

下一篇：【leetcode】每日精選題詳解之654. 最大二叉樹

第十五章 泛型

文章目錄

1.概念

2.簡單泛型

一個元組類別庫

3.泛型介面

4.泛型方法

一個set使用工具

5.匿名匿名內部類

6.構建復雜模型

7.擦除的神秘之處

遷移兼容性

邊界處的動作

8.擦除的補償

泛型陣列

9.邊界

10.通配符

通配符

無界通配符

11.泛型中的問題

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

由于擦除的原因，泛型不能多載

12.自限定的型別

自限定

引數協變