Java - 泛型

泛型：JDK 1.5 以后出现，用于解决安全问题，是一种类型安全机制。
好处：
1. 运行时出现的问题转移到编译时期，运行时更安全。
2. 避免了强制转换麻烦

泛型格式：通过 <> 定义操作的引用数据类型
通常在集合框架中很常见。

例子：

import java.util.*;
class GenericDemo
{
    public static void main(String[] args)
    {
        //使用集合时，将集合中存储数据类型传递到<>中即可
        TreeSet<Person> ts = new TreeSet<Person>(new MyComparator());
        ts.add(new Person("lisa011",23));
        ts.add(new Person("sa002",23));
        ts.add(new Person("sa002",24));
        ts.add(new Person("dsa002",24));
        ts.add(new Person("dsa003432",12));
        Iterator<Person> it = ts.iterator();
        while(it.hasNext())
        {
            Person p = it.next();
            System.out.println(p.getName()+"::"+p.getAge());
        }
    }

}

class Person implements Comparable<Person>{
    private String name;
    private int age ;
    public String getName()
    {
        return this.name;
    }
    public int getAge()
    {
        return this.age;
    }
    Person(String name,int age)
    {
        this.name = name;
        this.age = age ;
    }
    public int compareTo(Person o1)
    {
        if(this.age > o1.age)
            return 1;
        if(this.age == o1.age)
            return this.name.compareTo(o1.name);
        return -1;
    }
}

class MyComparator implements Comparator<Person>
{
    public int compare(Person o1,Person o2)
    {
        int num = new Integer(o1.getName().length()).compareTo(new Integer(o2.getName().length()));
        if(num==0)
            return o1.getName().compareTo(o2.getName());
        return num;
    }

}

泛型类：当类中操作的引用数据类型不确定时，现在可以定义泛型来操作。
泛型类定义的泛型在整个类中有效，如果被方法使用，那么泛型类对象明确操作类型后，所有要操作的类型就固定。

import java.util.*;

class Teacher
{
}

class Student
{
}

class Util<T>
{
    private T obj;

    public void setObject(T obj)
    {
        this.obj = obj;
    }

    public T getObject()
    {
        return this.obj;
    }

}

class GenericDemo2 
{
    public static void main(String[] args)
    {
        Util<Teacher> t = new Util<Teacher>();
        t.setObject(new Teacher());
        //编译时报错，Teacher无法转换成Student
        Student stu = (Student)t.getObject();
    }
}

为了让不同方法操作不同类型，而且类型不确定，可以将泛型定义在方法上。

import java.util.*;

class GenericDemo3 
{
    public static void main(String[] args)
    {
        Util<String> t = new Util<String>();
        t.print("sads");
        t.out(123);

    }
}

class Util<T>
{

    public <T> void print(T obj)
    {
        System.out.println(obj);
    }

    public <T> void show(T obj)
    {
        System.out.println(obj);
    }

    //静态方法不可以访问类上定义的泛型，只能定义在方法上。
    public static <T> void out(T obj)
    {
        System.out.println(obj);
    }   
}

泛型定义在接口上，类实现接口也定义操作泛型

import java.util.*;

//泛型定义在接口上
interface Inter<T>
{
    void show(T t);
}

class InterImpl<T> implements Inter<T>
{
    public void show(T t)
    {
        System.out.println(t);
    }
}

class GenericDemo4
{
    public static void main(String[] args)
    {
        InterImpl<String> in = new InterImpl<String> ();
        in.show("aaa");
    }
}

泛型限定：
< ? extends E > 可以接收 E 以及 E 的子类。
< ? super E > 可以接收 E 或 E 的父类

import java.util.*;

class GenericDemo6
{
    public static void main(String[] args)
    {
        TreeSet<Student> al = new TreeSet<Student>(new MyComp());
        al.add(new Student("lisa11",23));
        al.add(new Student("lisa2",23));
        al.add(new Student("lisa3",23));
        printCall(al);

        TreeSet<Teacher> al2 = new TreeSet<Teacher>(new MyComp());
        al2.add(new Teacher("lisa11",23));
        al2.add(new Teacher("lisa2",23));
        al2.add(new Teacher("lisa3",23));
        printCall(al2);

    }

    // ? 称作为 通配符 或者 占位符  
    public static void printCall(Collection<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }

}

class Person implements Comparable<Person>{
    private String name;
    private int age ;
    public String getName()
    {
        return this.name;
    }
    public int getAge()
    {
        return this.age;
    }
    Person(String name,int age)
    {
        this.name = name;
        this.age = age ;
    }
    public int compareTo(Person o1)
    {
        if(this.age > o1.age)
            return 1;
        if(this.age == o1.age)
            return this.name.compareTo(o1.name);
        return -1;
    }
}

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

class Teacher extends Person 
{
    Teacher(String name,int age)
    {
        super(name,age);
    }
}


// Comparator <? super E>
class MyComp implements Comparator<Person>
{
    public int compare(Person o1,Person o2)
    {
        int num = new Integer(o1.getName().length()).compareTo(new Integer(o2.getName().length()));
        if(num==0)
            return o1.getName().compareTo(o2.getName());
        return num;
    }
}