泛型--

泛型是什麼？有什麼好處？

泛型：JDK1.5以後出現的新特性，用於解決安全問題，是一個類型安全機制
好處：
1）將運行時期出現問題ClassCastException，轉移到了編譯時期，方便程序員解決問題；
2）避免了強制轉型的麻煩。

（一）泛型常用於哪些地方？

1.1 集合類中

示例1：

class GenericDemo1
{
    public static void main(String args[])
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("sdf");
        al.add("sdfsdf");
        al.add("sdfsdf");

        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s+s.length());
        }

    }
}

1.2 在比較器中的應用:
1）Comparator，Compare方法
2）Comparatable，ComparaTo方法
3）equals方法是覆寫Object的，所以不能變泛型。

示例2：

import java.util.*;

class GenericDemo2
{
    public static void main(String args[])
    {
        TreeSet<String> ts = new TreeSet<String>(new LenComparator());
        ts.add("sdf");
        ts.add("sdfsdf");
        ts.add("sdfsdf");

        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s+s.length());
        }
    }
}

class LenComparator extends Comparator<String>
{
    public boolean compare(String o1,String o2)
    {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));//如果倒序則調換o1，o2的位置。
        if(num==0)
        {
            return o1.compareTo(o2);
        }
        return num;
    }
}

（二）泛型結構

1）泛型類
2）泛型方法
3）泛型接口

2.1 泛型類在什麼時候定義？
當類中要操作的引用數據類型不確定的時候，早期使用Object來完成擴展，現在使用泛型來擴展。
示例3：

class Worker
{
}

class Student
{
}

class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}

class Utils<T>
{
    private T t;
    public void setObject(T t)
    {
        this.t = t;
    }
    public T getObject()
    {
        return t;
    }
}

class GenericDemo3
{
    public static void main(String args[])
    {
        Tool t = new Tool();
        t.setObject(new Worker());
        Worker w = (Worker)t.getObject();

        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        Worker w = u.getObject();

    }
}

2.2 泛型方法
定義：泛型只在方法內有用。
方法中的泛型有三種情況：
1）可以跟類中定義的泛型一致
2）也可以在方法上定義，與類中的泛型不一致
3）靜態方法定義的泛型，不能和類中定義的泛型一致，必須定義在方法上，必須放在返回值類型前面，修飾符後面。public static method(T t）
示例4：

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

class Demo
{
    public <T> void show(T t)
    {
        System.out.println(t);
    }
    public <Q> void print(Q q)
    {
        System.out.println(q);
    }
}
class Demo<T>
{
    public void show(T t)
    {
        System.out.println(t);
    }
    public <Q> void print(Q q)
    {
        System.out.println(q);
    }
    public static <W > void method(W w)
    {
        System.out.println(w);
    }
}



class GenericDemo4
{
    public static void main(String args[])
    {
        Demo<String> d = new Demo<String>();
        d.show("hehheeh");
        d.print(new Integer(4));


        Demo d1 = new Demo();
        d1.show("hehheeh");
        d1.print(new Integer(4));
    }
}

2.3 泛型接口
interface inter
{
void show(T t);
}
class interImpl implements inter
{
void show(T t)
{
System.out.println(t);
}
}

（三）泛型的限定

3.1 . 通配符？
？表示通配符，不需要再方法上定義泛型
？extends E，E類型或者其子類可以，指定上限
？ super E，E類型及其父類可以，指定下限。

示例5：

class GenericDemo5
{
    public static void main(String args[])
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("shf01");
        al.add("shf02");
        al.add("shf03");
        al.add("shf04");

        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(1);
        al1.add(2);
        al1.add(3);
        al1.add(4);

        print(al);
        print(al1);
    }
    public static void print(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    public static <T> void print(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            T t = it.next();
            System.out.println(t);
        }
    }
}

3.2 指定上限。

示例6：

import java.util.*;
class GenericDemo6
{
    public static void main(String args[])
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("asdkdf1"));
        al.add(new Person("asdkdf2"));
        al.add(new Person("asdkdf3"));
        al.add(new Person("asdkdf4"));


        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("dfdks1"));
        al1.add(new Student("dfdks2"));
        al1.add(new Student("dfdks3"));

        print(al);
        print(al1);
    }

    public static void print(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }

}


class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

3.3 指定下限：

示例7：

import java.util.*;
class GenericDemo7
{
    public static void main(String args[])
    {
        TreeSet<Person> al = new TreeSet<Person>(new Com());
        al.add(new Person("pasdkdf3"));
        al.add(new Person("pasdkdf1"));
        al.add(new Person("pasdkdf2"));
        al.add(new Person("pasdkdf4"));
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }

        TreeSet<Student> al1 = new TreeSet<Student>(new Com());
        al1.add(new Student("sdfdks1"));
        al1.add(new Student("sdfdks3"));
        al1.add(new Student("sdfdks2"));
        Iterator<Student> it1 = al1.iterator();
        while(it1.hasNext())
        {
            System.out.println(it1.next().getName());
        }


        TreeSet<Worker> al2 = new TreeSet<Worker>(new Com());
        al2.add(new Worker("wdfdks---1"));
        al2.add(new Worker("wdfdks---3"));
        al2.add(new Worker("wdfdks---2"));
        Iterator<Worker> it2 = al2.iterator();
        while(it2.hasNext())
        {
            System.out.println(it2.next().getName());
        }
    }

}

class Com implements Comparator<Person> //此處的泛型必須是父類的。
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p2.getName());//此處必須是父類Person類的方法
    }
}


class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}