技術標籤：java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.TreeSet;
/**
 * 泛型：
 *      jdk1.5出現的安全機制。
 * 好處：
 *      1.將執行時期的問題ClassCastException轉到了編譯時期。
 *      2.避免了強制轉換的麻煩。
 * <>什麼時候用：當操作的引用資料型別不確定的時候。就使用<>。將要操作的引用資料型別傳入即可。
 * 其實<>就是一個用於接收具體引用資料型別的引數範圍。
 * 在程式中只要用到了帶有<>的類或介面就要明確傳入的具體引用資料型別。
 * 
 * 泛型技術是給編譯器使用的技術，用於編譯時期。確保了型別的安全。
 * 執行時會將泛型去掉，生成的class檔案中是不帶泛型的，這稱之為“泛型的擦除”。
 * 為什麼擦除呢？為了相容執行的類載入器。
 * 
 * 泛型的補償：在執行時，通過獲取元素的型別進行轉換動作，不用使用者再強制轉換了。
 */
 

class Person implements Comparable<Person>{//<>內指定需要比較的物件
    private String name;
    private int age;
    public int compareTo(Person obj) {
        // Person p = (Person)obj;
        int temp = this.age-obj.age;
        return temp==0?this.name.compareTo(obj.name):temp;
    }
    
    Person
 
(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this
 
.age = age;
    }
}
//沒有使用泛型的Tool類
class Tool{
    private Object object;
    public Object getObject() {
        return this.object;
    }
    public void setObject(Object object) {
        this.object = object;
    }
}
//在jdk1.5使用泛型來接受類中要操作的引用資料型別。
//泛型類。什麼時候用？當類中操作的引用資料型別不確定時就用泛型來表示。
class Tool_<QQ>{
    private QQ q;
    public QQ getQQ(){
        return this.q;
    }
    public void setQQ(QQ object){
        this.q = object;
    }
    public void show(QQ object){
        System.out.println("show:"+object);
    }
    //將泛型定義在方法上
    public <W> void show1(W object){
        System.out.println("show1:"+object);
    }
    public static <W> void method(W object) {
        //當方法靜態時，不能訪問類上定義的泛型，如果靜態方法使用泛型，只能在方法上定義泛型
        System.out.println("method:"+object);
    }
}
public class packDemo{
    public static void main(String[] args){
        genericDemo_4();
    }
    public static void genericDemo_1(){
        ArrayList<String> al = new ArrayList<String>();
        al.add("hello");
        al.add("world");
        al.add("this");
        Iterator it = al.iterator();
        while(it.hasNext()){
            // String str = (String)it.next();
            System.out.println(it.next());
        }
    }
    public static void genericDemo_2(){
        TreeSet<Person> ts = new TreeSet<Person>();//Person類需要基礎comparable並覆蓋compareTo方法
        ts.add(new Person("pp", 24));               //也可定義比較器，在()中new，按其他規則排序
        ts.add(new Person("zz", 23));               //泛型裡面只能是引用資料型別，不能是int類，可以是Integer
        ts.add(new Person("ww", 25));
        Iterator<Person> it = ts.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
    /*
    泛型類
    */
    public static void genericDemo_3(){
        //未使用泛型類
        Tool tool = new Tool();
        tool.setObject(new Person("pp", 24));
        Person person = (Person)tool.getObject();
        System.out.println(person.getName());
        //使用泛型類之後：
        Tool_<Person> tool_ = new Tool_<Person>();
        tool_.setQQ(new Person("kpp", 24));
        Person person_ = tool_.getQQ();
        System.out.println(person_.getName());
    }
    public static void genericDemo_4(){
        Tool_<Person> tool_ = new Tool_<Person>();
        tool_.setQQ(new Person("kpp", 24));
        tool_.show1(tool_.getQQ());//show:[email protected]
        tool_.show1("object");
        tool_.method("hello");
        /*
        Integer a = new Integer(1);
        Integer a2 = -127;
        //直接=沒有new物件時，-127~128之間會自動拆箱為int型別，範圍之外會自動裝箱
        Integer a3 = -127;
        Integer a1 = new Integer(1);
        int b = -1;
        System.out.println(a==b);
        System.out.println(a==a1);
        System.out.println(a2==a3);
        */
    }
}

泛型介面

//泛型介面，將泛型定義在介面上.
interface Inter<T>{
    public void show(T t);
}
class InterImpl implements Inter<String>{
    public void show(String str) {
        System.out.println("interimpl:"+str);
    }
}
class InterImpl_2<Q> implements Inter<Q>{
    public void show(Q q) {
        System.out.println("InterImpl_2:"+q);
    }
}
public class packDemo{
    public static void main(String[] args){
        // genericDemo_4();
        InterImpl ii = new InterImpl();
        ii.show("hello");
        InterImpl_2<String> i2 = new InterImpl_2();
        i2.show("i2:hello");
    }
}