泛型--

泛型是什么？有什么好处？

泛型：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);
    }
}