泛型

概念：
jdk 1.5出现的安全机制。
好处：
1，将运行时期的问题ClassCastException转到了编译时期。
2，避免了强制转换的麻烦。
<>:
当操作引用数据类型不确定的时候，使用泛型，将要操作的引用数据类型传入即可
其实<>就是一个用于接收具体引用数据类型的参数范围。
在程序中只要用到了带有<>的类或者接口，就要明确传入具体的应用数据类型。
泛型的原理：
方形技术是给编译器使用的技术，用于编译时期，确保了类型的安全。
运行时会将泛型去掉，生成的class问件是不带泛型的，这个称为泛型的擦除。
为什么擦除？因为为了兼容运行时的类加载器。
泛型的补偿：
运行时，通过获取元素的类型进行转换动作，不用使用者再强制类型转换了，
代码演示：
定义一个人的类，包含人的年龄和姓名。

public class Person implements Comparable<Person> {    private int age;    private String name;    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Person(int age, String name) {        super();        this.age = age;        this.name = name;    }    public Person() {        super();    }    @Override    public int compareTo(Person p) {        int flag = this.age-p.age;        return flag==0?this.name.compareTo(p.name):flag;    }}

根据名字排序的比较器

public class CompareByName implements Comparator<Person> {    @Override    public int compare(Person o1, Person o2) {        int flag=o1.getName().compareTo(o2.getName());        return flag==0?o1.getAge()-o2.getAge():flag;    }}

测试类

public class FanXingDemo {    public static void main(String[] args){        TreeSet<Person> ts=new TreeSet<Person>(new CompareByName());        ts.add(new Person(18,"xiaoming"));        ts.add(new Person(20,"xiaoBai"));        ts.add(new Person(17,"xiaohong"));        ts.add(new Person(12,"xiaohai"));        Iterator<Person> it= ts.iterator();        while(it.hasNext()){            Person p=it.next();            System.out.println(p.getAge()+"+++"+p.getName());        }    }}

泛型类
在JDK 1.5后，使用泛型类来接收类中要操作的引用数据类型。
当类中的操作的引用数据类型不确定时，就使用泛型类来表示。
代码演示
定义一个Tool类

public class Tool<Element>{    private Element element;    public Element getElement() {        return element;    }    public void setElement(Element element) {        this.element = element;    }    //将泛型定义在方法上，该方法不在受类泛型的约束。    public <Y>void print(Y y){        System.out.println(y.toString());    }    //当方法静态时，不能访问类上定义的泛型，如果静态    //方法使用泛型，只能将泛型定义在方法上。    public static <H>void show(H h){        System.out.println(h.toString());    }}

测试类：

public class FanXingDemo {    public static void main(String[] args){        Tool<Student> tool=new Tool<Student>();        tool.setElement(new Student());        Student stu=tool.getElement();        tool.print("xiaoming");        //调用泛型中静态类的方法        Tool.show(123);    }}

泛型接口
代码演示：

interface inter<T>{    public void fun(T t);}class InterDemo1<Q> implements inter<Q>{    @Override    public void fun(Q t) {        System.out.println(t);    }}class InterDemo implements inter<String>{    @Override    public void fun(String str) {        System.out.println(str);    }}

测试类

public class FanXingDemo {    public static void main(String[] args){        InterDemo i=new InterDemo();        i.fun("xiaohong ");        InterDemo1 inter1=new InterDemo1();        inter1.fun(new Integer(6));    }}

泛型的高级应用
当传入的集合类型不确定，并且集合中的元素也不确定时，可以采用将集合向上转型和使用通配符来解决。
代码演示：
迭代并打印集合中的元素

    public void print(Collection<?> al) {        Iterator<?> it=al.iterator();        while(it.hasNext()){            System.out.println(it.next());        }    }

测试：

    public static void main(String[] args){        TreeSet<Integer> al=new TreeSet<Integer>();        al.add(123);        al.add(456);        ArrayList<String> al2=new ArrayList<String>();        al2.add("ccc");        al2.add("ddd");        print(al);        print(al2);    }

也可以将泛型定义在方法上：

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

泛型的限定：
上限：？ extends E :接收E类型或者E的子类型对象。

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

下限：？ extends E:接收E类型或者E的父类型。

一般在存储元素的时候使用上限，因为取出都是照上限类型来运算的，不会出现类型安全隐患。