java學習初探十五之泛型

一、泛型（編譯期概念）
1爲什麼引入泛型？
（1）可以統一集合中的數據類型
（2）可以減少強制類型轉換
2.泛型語法如何實現？
3.泛型的優點和缺點？
優點：統一類型，減少強制轉換。
缺點：只能存儲一種類型。

以下程序沒有使用泛型，缺點？
如果集合不使用類型，則集合中的元素類型不統一。在遍歷集合的時候，只能拿出Object類型，需要做大量的強制類型轉換。麻煩。

package fanxing;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test01 {

    public static void main(String[] args) {
        Set s=new HashSet();
        A a=new A();
        B b=new B();
        C c=new C();

        s.add(a);
        s.add(b);
        s.add(c);

        //需求：遍歷集合，如果A類型調用m1方法，B類型調用m2方法，C類型調m3方法
        Iterator it=s.iterator();
        while (it.hasNext()) {
            Object o=it.next();
            //只能做大量的強制類型轉換
            if(o instanceof A) {
                A a1=(A)o;
                a1.m1();
            }else if(o instanceof B){
                B b1=(B)o;
                b1.m2();
            }else {
                C c1=(C)o;
                c1.m3();
            }
        }
    }
}
class A{
    public void m1() {
        System.out.println("A's m1...........");
    }
}
class B{
    public void m2() {
        System.out.println("B's m2...........");
    }
}
class C{
    public void m3() {
        System.out.println("C's m3...........");
    }
}

二、泛型語法如何實現
泛型是一個編譯階段的語法，在編譯階段統一集合中的類型。

（1）下面是List使用String泛型實例

package fanxing;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        //創建一個List集合，只能存儲字符串類型
        List<String> strs=new ArrayList<String>();
        //添加元素
        //Error
        //strs.add(1);

        strs.add("JACK");
        strs.add("SUN");
        strs.add("KING");
        strs.add("SMITH");
        //遍歷
        Iterator<String> it=strs.iterator();
        while (it.hasNext()) {
            String string = it.next();
            System.out.println(string);
        }   
    }
}

（2）下面是Map使用

package fanxing;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test03 {

    public static void main(String[] args) {
        Map<String, Integer> maps=new HashMap<String,Integer>();
        //存
        maps.put("西瓜", 10);
        maps.put("蘋果", 9);
        maps.put("香蕉", 20);
        //遍歷
        Set<String> keys=maps.keySet();
        Iterator<String> it=keys.iterator();
        while (it.hasNext()) {
            String key=it.next();
            Integer value=maps.get(key);
            System.out.println(key+"的價格是"+value);
        }
    }
}

（3）SortedSet使用泛型

package fanxing;

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class Test04 {

    public static void main(String[] args) {

        SortedSet<Manager> ss=new TreeSet<Manager>();

        //添加
        Manager m1=new Manager(1000.0);
        Manager m2=new Manager(1500.0);
        Manager m3=new Manager(1300.0);
        ss.add(m1);
        ss.add(m2);
        ss.add(m3);
        //遍歷
        Iterator<Manager> it=ss.iterator();
        while (it.hasNext()) {
            Manager manager=it.next();
            manager.work();
            System.out.println(manager);

        }
    }

}
class Manager implements Comparable<Manager>{
    double sal;
    public Manager(double sal) {
        this.sal=sal;
    }
    public String toString() {
        return sal+" ";
    }
    public void work() {
        System.out.println("工作，一個月"+sal+"元");
    }
    //實現接口中方法
    public int compareTo(Manager m) {
        double sal1=this.sal;
        double sal2=m.sal;
        if(sal1>sal2) {return 1;}
        else if(sal1<sal2) {return -1;}
        else {
            return 0;   
        }
    }
}

三、自定義泛型

package fanxing;

public class Test05 {

    public static void main(String[] args) {

        MyClass<String> mc=new MyClass<String>();
        //泛型就是編譯期檢查類型
        //Error
        //mc.m1(100);
        mc.m1("myclass");
    }
}
//自定義泛型
class MyClass<T>{
    public void m1(T t) {
        System.out.println(t);

    }
}