Java泛型及實踐

程式碼及說明：

package com.zsm.crazyjava;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * @author zsm
 * @date 2016年11月2日 下午11:23:30
 * @version 1.0
 * @parameter
 * @return
 */
// JDK5開始支援泛型。泛型（類、介面、方法）；泛型萬用字元、萬用字元上限、萬用字元下限
public class _16_Generic {
    // 泛型
    List<String> strListStand = new ArrayList<String>();
    // 泛型菱形語法（JDK7後初始化時泛型的具體型別可省略，自動判斷）
    List<String> strList = new ArrayList<>();

    // 泛型類、介面
    public interface Fruit<T> {
        void add(T fruit);
    }

    public interface MyMap<K, V> {
        Set<K> keySet();

        V put(K key, V value);
    }

    public static class Apple<T> {
        private T info;

        public Apple() {// 不能再寫成Apple<T>

        }

        public Apple(T info) {
            this.info = info;
        }

        public T getInfo() {
            return this.info;
        }

        // 靜態方法、靜態初始化塊、靜態變數宣告和初始化中不能使用泛型形參，靜態類或介面定義處則可以
        // static T name;//報錯
        // public static void bar(T msg) {}
        // static {T name = "xiaoming";}

        // 泛型方法則可以使用型別形參，即使是靜態方法。型別形參放在方法修飾符和返回值之間
        public static <E, F> void ttt(E name, F age) {
            ;
        }
    }

    // 泛型派生的子類、實現泛型介面的類的宣告中不能再包含泛型形參
    public class A1 extends Apple<String> {// 不能再寫成Apple<T>
        public String getInfo() {
            return super.info;
        }
    }

    // 帶泛型形參的類不會隨著型別實參的不同而成為不同的類，介面亦然
    static void testClassEqual() {
        System.out.println((new Apple<String>()).getClass() == (new Apple<Integer>()).getClass());// true
        List<String> strList = new ArrayList<>();
        List<Integer> intList = new ArrayList<>();
        System.out.println(strList.getClass() == intList.getClass());// true
    }

    // 若Foo是Bar的子類，則Foo[]是Bar[]的子類，但List<Foo>卻不是List<Bar>的子類。可以使用泛型萬用字元：?，
    public void wildcardTest1(List<Object> c) {// 呼叫時只能傳入List<Object>引數，不可傳入List<String>等引數，因為後者不是前者的子類
        for (int i = 0; i < c.size(); i++) {
            System.out.println(c.get(i));
        }
    }

    public void wildcardTest2(List<?> c) {// 此時可傳入List<String>等引數，但只可從c讀不可往裡寫，因為c型別不定。即帶型別萬用字元定義的物件只可讀不可寫
        for (int i = 0; i < c.size(); i++) {
            System.out.println(c.get(i));
            // c.add(new Object());//編譯錯誤，不可往c裡寫，因為c裡元素型別未定
        }
    }

    // 型別萬用字元上限
    public abstract class Shape {
        public abstract void draw(MyCanvas c);
    }

    public class Circle extends Shape {
        @Override
        public void draw(MyCanvas c) {
            // TODO Auto-generated method stub
            System.out.println("draw a circle on " + c);
        }
    }

    public class Rectangle extends Shape {
        @Override
        public void draw(MyCanvas c) {
            // TODO Auto-generated method stub
            System.out.println("draw a rectangle on " + c);
        }
    }

    public class MyCanvas {
        public void drawAll0(List<?> shapes) {// 使用萬用字元時型別未定，所以訪問每個元素只能用終極父類Object，這導致得進行麻煩的強制型別轉換
            for (Object obj : shapes) {
                Shape s = (Shape) obj;
                s.draw(this);
            }
        }

        public void drawAll1(List<? extends Shape> shapes) {// 使用萬用字元上限，從而知道元素元素型別的終極父類是Shape，這樣不用進行強轉。至多可以有一個類上限、多個介面上限，類上限需放最前。
            for (Shape s : shapes) {
                s.draw(this);
            }
        }
    }

    // 泛型方法：方法中所用型別形參不要求在類宣告中先出現該型別形參；型別形參位於方法修飾符和返回值之間；與泛型類、介面不同的是，無須在呼叫泛型方法時顯式指明實參型別
    public <T> void fromArrayToCollection(T[] a, Collection<T> c) {// a的實參可以是T[]的子型別
        for (T o : a) {
            c.add(o);
        }
    }

    public void test_fromArrayToCollection() {
        fromArrayToCollection((new Object[10]), new ArrayList<Object>());
        fromArrayToCollection((new Integer[10]), new ArrayList<Object>());
        fromArrayToCollection((new Integer[10]), new ArrayList<>());// 與泛型類、介面不同的是，無須在呼叫泛型方法前顯式指明實參型別（指在方法名前），編譯器自己確定
        fromArrayToCollection((new Integer[10]), new ArrayList<Number>());
        // fromArrayToCollection((new Integer[10]), new ArrayList<String>());//編譯錯誤
    }

    // 泛型方法和型別萬用字元：方法引數間或返回值與引數間存在型別依賴關係（如子類）時採用泛型方法，否則型別引數只用一次，沒有存在的必要，可以改用型別萬用字元。
    public <T, S extends T> void copy1(List<T> des, List<S> src) {// S僅用了一次且與其他引數間沒有依賴關係，因此沒有存在的必要，改為下面的方法。
        for (S s : src) {
            des.add(s);
        }
    }

    public <T> void copy2(List<T> des, List<? extends T> src) {// 去掉S，改為使用型別萬用字元上限。
        for (T t : src) {
            des.add(t);
        }
    }

    // 泛型方法 ———— 泛型構造器
    class Foo<E> {
        public <T> Foo(T t) {
            System.out.println(t);
        }

        public void add(E e) {

        }
    }

    public void test_genericConstructor() {
        new Foo("good");
        new Foo(1);
        new<String> Foo("good");// 顯示指定構造方法型別形參的實際型別
        new<String> Foo<Integer>("good");// 又指定了類的型別形參的實際型別
        new Foo<>("good");// 菱形語法
        // new<String> Foo<>(1);// 如果顯示指定了構造器型別形參的型別，則不可用菱形語法

        Foo<Integer> p1 = new<String> Foo("good");
        Foo<Integer> p2 = new<String> Foo<Integer>("good");
        Foo<Integer> p3 = new Foo<Integer>("good");
        // Foo<Integer> p4 = new<String> Foo<>("good");//如果顯示指定了構造器型別形參的型別，則不可用菱形語法
    }

    // 型別萬用字元下限。
    // 返回最後一個元素，型別不可丟。上面的copy2方法如果要返回最後一個被複制的元素，則返回的會是des中元素的型別T，這樣就丟失了src的型別即S。可以通過修改copy1解決，也可以通過萬用字元下限解決。
    public <T, S extends T> S copy3(List<T> des, List<S> src) {// S僅用了一次且與其他引數間沒有依賴關係，因此沒有存在的必要，改為下面的方法。
        int i = 0;
        for (i = 0; i < src.size(); i++) {
            des.add(src.get(i));
        }
        return src.get(i - 1);
    }

    public <T> T copy4(List<? super T> des, List<T> src) {// 去掉S，改為型別萬用字元下限。
        int i = 0;
        for (i = 0; i < src.size(); i++) {
            des.add(src.get(i));
        }
        return src.get(i - 1);
    }

    // 檫除與轉換：帶泛型宣告的類間轉換
    public static void test_Transform() {
        List list;// 不指定實際型別引數，為raw type，預設為上限型別，此為Object
        List<Integer> listInteger = new ArrayList<Integer>();
        listInteger.add(1);
        listInteger.add(2);
        list = listInteger;// List<Integer>物件賦給未指定型別的List，原始型別丟失，變為Object

        List<String> listStr = list;// 編譯沒問題，只有警告："未經檢查的轉換"
        System.out.println(listStr.get(0));// 但訪問裡面元素，會發生執行時異常
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}