泛型

为什么要泛型？如果不使用泛型会写成如何？

public class NoGenerci {

    public static void main(String[] args) {

        Set set = new HashSet();
        A a = new A();
        B b = new B();
        C c = new C();
        
        set.add(a);
        set.add(b);
        set.add(c);
        
        //要求遍历集合，调用里面的方法
        Iterator it = set.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();
            }
        }
        
    }

}
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 () ... ");
    }
}

C's m3 () ...
A's m1 () ...
B's m2 () ...

所以以上程序没有使用泛型有啥缺点？

集合中的元素类型不统一、在遍历集合的时候只能拿出Object出来做大量的强制类型转换，折腾

优点呢？

集合中可以存储不同类型的元素，如果使用泛型就只能存一种

所以关键还是看你怎么看这个问题！

那么泛型语法如何实现

泛型是一个编译阶段的语法，在编译阶段统一集合中的元素，如

public class GenericTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("kobe");
        list.add("lbj");
        list.add("tracy");
        list.add("kg");
        
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

}

 SortedSet实现泛型

public class SortedSetTest {

    public static void main(String[] args) {
        
        SortedSet<Manager> set = new TreeSet();
        
        Manager m1 = new Manager(1500);
        Manager m2 = new Manager(15200);
        Manager m3 = new Manager(12500);
        Manager m4 = new Manager(150);
        Manager m5 = new Manager(500);
    
        set.add(m1);
        set.add(m2);
        set.add(m3);
        set.add(m4);
        set.add(m5);
        //遍历
        Iterator<Manager> it = set.iterator();
        while (it.hasNext()){
            Manager m = it.next();
            System.out.println(m.sal);
        }
    }

}

class Manager implements Comparable<Manager>{
    double sal;
    
    public Manager(double sal){
        this.sal = sal;
    }
    
    @Override
    public int compareTo(Manager o) {
        if (this.sal > o.sal) //这里就不用再强制转换了
            return 1;
        else if (this.sal < o.sal)
            return -1;
        else 
            return 0;
    }
}

 自定义泛型

public class CustomGeneric {

    public static void main(String[] args) {
        MyClass<String> m = new MyClass();
        m.print("hello"); //这里只能是String，不然编译报错，因为泛型是编译器检查类型
    }
    
}

class MyClass<T>{
    
    public void print(T t){
        System.out.println(t);
    }
}