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

    }
}