泛型

一. 泛型的引入

class GenericDemo 
{
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");
        al.add(4);
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            String s = (String)it.next();
            System.out.println(s+":"+s.length());
        }
    }
}

向ArrayList中分别添加String类型和Integer类型的对象，由于ArrayList接收的是Object类型的对象，所以编译阶段不会出现什么问题，但是运行时会出现“java.lang.ClassCastException”异常，因此，导致此类错误编码过程中不易发现。而且这种写法需要将Object类型强制转换为String类型，操作比较繁琐。
为了解决这些问题，在JDK1.5版本以后出现了泛型。

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。泛型用于解决安全问题，是一个类型安全机制。

二. 泛型的使用

class GenericDemo 
{
    public static void main(String[] args) 
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");
        al.add(4);
        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s+":"+s.length());
        }
    }
}

将运行时期出现问题ClassCastException，转移到了编译时期，方便于程序员解决问题。让运行时问题减少，安全。而且避免了强制转换麻烦。

三. 泛型类

当类中要操作的引用数据类型不确定的时候，可以用泛型类进行扩展

class Student
{

}
class Worker
{

}
class Tool<Q>
{
    private Q q;
    public void setObject(Q q)
    {
        this.q = q;
    }
    public Q getObject()
    {
        return q;
    }
}
class Test
{
    public static void main(String[] args) 
    {
        Tool<Student> t = new Tool<Student>();
        t.setObject(new Student());
        Worker w = t.getObject();  //此处会报错
    }
}

在上面的代码中，在使用前类中要操作的引用数据类型是不确定的，使用时将Student类型作为参数传给Tool类，限定类型，实现了安全的拓展

四. 泛型方法

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不确定的不同类型，可以将泛型定义在方法上。

class Tool
{
    public <Q> void print(Q q)
    {
        System.out.println("print---"+q);
    }
    public static <T> void show(T t)
    {
        System.out.println("show---"+t);
    }
}
class Test
{
    public static void main(String[] args) 
    {
        Tool t = new Tool();
        t.print("haha");
        t.print(33);

        Tool.show("hehe");
    }
}

特殊的：静态方法操作的应用数据类型不确定时，一定要将泛型定义在方法上，因为静态方法初始化在对象产生之前进行，所以不能出现对象类型不确定的静态方法初始化

五. 泛型接口

interface Inter<T>
{
    void show(T t);
}
class InterImpl<T> implements Inter<T>
{
    public void show(T t)
    {
        System.out.println("show----"+t);
    }
}
class Test
{
    public static void main(String[] args) 
    {
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(22);
    }
}

六. 通配符

import java.util.*;
class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}
class Test
{
    public static void main(String args[])
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("person--1"));
        al.add(new Person("person--2"));
        al.add(new Person("person--3"));
        print(al);

        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("student--1"));
        al1.add(new Student("student--2"));
        al1.add(new Student("student--3"));
        print(al1);  
    }
    public static void print(ArrayList<? extends Person> a)
    {
        Iterator<? extends Person> it = a.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
}

? 通配符。也可以理解为占位符。
泛型的限定：
？ extends E: 可以接收E类型或者E的子类型，E为上限
？ super E: 可以接收E类型或者E的父类型，E为下限

import java.util.*;
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);
    }
}
class Comp implements Comparator<Person>  //注意
{
    public int compare(Person s1,Person s2)
    {
        return s2.getName().compareTo(s1.getName());
    }
}
class Test
{
    public static void main(String args[])
    {
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("Student--1"));
        ts.add(new Student("Student--2"));
        ts.add(new Student("Student--3"));
        Iterator<Student> it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        } 

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

比较器传入的对象是Person，这里是确定了上限，所以也可以被Person的子类Student和Worker使用，但是注意，只能使用父类的方法