java泛型简单介绍

综述：
泛型是JDK5.0之后加入的新特性，属于编译期的概念。引入泛型可以统一集合中的数据类型从而减少强制类型转换。泛型的优点是统一类型，减少强制转换，这同时也是他的缺点，因为引用了泛型类型将过度统一。泛型中常见的T、E分别代表Type、Element，只是一个标识符，没有其它的意义。

示例及解释：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class GenericTest01 {

    public static void main(String[] args) {
        // ***************************传统方式遍历集合涉及实体时需要强转   start***************************
        // 创建一个集合，存储A、B、C，此处使用Set
        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);
        // 遍历集合，并调用内部唯一方法
        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 if (o instanceof C) {
                C c1 = (C) o;
                c1.m3();
            }
        }// 输出B's m1....  A's m1....  C's m1....
        // ***************************传统方式遍历集合涉及实体时需要强转   end***************************
        
        // ***************************集合使用泛型因为已经制定类型无需强转   start***************************
        // 只能存储String的List
        List<String> ls = new ArrayList<String>();
        ls.add("字符串");
        // ls.add(1);// 添加其它类型报错
        
        // 规定key为字符串，value为整数的Map
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("小米5", 3000);
        // map.put(1000, "3000");// key和value不匹配报错
        
        // SortedSet使用泛型添加实体类，需要重写Comparto方法，用于自动排序
        SortedSet<Coder> coder = new TreeSet<Coder>();
        Coder t1 = new Coder(13000);
        Coder t2 = new Coder(8000);
        Coder t3 = new Coder(3000);
        coder.add(t1);
        coder.add(t2);
        coder.add(t3);
        Iterator<Coder> cit =  coder.iterator();
        while (cit.hasNext()) {
            Coder p = cit.next();
            p.job();// 传统需要强转，此处已经知道类型无需强转
        }// 输出：码农，一个月3000.0元   码农，一个月8000.0元   码农，一个月13000.0元
        
        // 自定义泛型
        Mine<String> me = new Mine<String>();
        me.m1("Mike");
        // ***************************集合使用泛型因为已经制定类型无需强转   end***************************
        
    }
    
    static class A {
        public void m1 () {
            System.out.println("A's m1....");
        }
    }
    static class B {
        public void m2 () {
            System.out.println("B's m1....");
        }
    }
    static class C {
        public void m3 () {
            System.out.println("C's m1....");
        }
    }
    // Comparable接口指定泛型
    static class Coder implements Comparable<Coder>{
        double sal;
        
        Coder (double sal) {
            this.sal = sal;
        }
        // 重写toString方法
        public String toString () {
            return "薪资：" + sal + " ";
        }
        public void job() {
            System.out.println("码农，一个月" + sal + "元");
        }
        public int compareTo(Coder c) {
            double sal1 = this.sal;
            double sal2 = c.sal;// 无需强转
            if (sal1 > sal2) {
                return 1;
            } else if (sal1 < sal2) {
                return -1;
            }
            return 0;
        }
    }
    // 自定义泛型类
    static class Mine<T> {
        public void m1(T t) {
            System.out.println(t);
        }
    }
}