泛型

一. 泛型的引入

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使用，但是注意，只能使用父类的方法