java泛型剖析

一 java泛型是什么？泛型的好处是啥？
那些拥有Java1.4或更早版本的开发背景的人都知道，
1> 在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。
2> 它提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。
二 泛型类
当类中操作的引用数据类型不确定的时候，就用泛型类。

public class Tool{
    public T obj;
    public T getObject(){
        return obj;
    }
    public void setObject(T str){
        System.out.println("111");
        this.obj=str;
    }

}
public class Car{
    public Car() {
    super();
    }
}
public class Bus {
    public Bus() {
    super();
    }
}
public class GenericDemo {
    public static void main(String[] args) {

    Tool<Car>tool=new Tool<Car>();
    tool.setObject(new Car());
    Car car=tool.getObject();
    tool.setObject(New Bus());//wrong
    }
}

某类操作不确定的引用数据类型，就用泛型类。没有泛型之前，用Object，即Tool类如下：

public class Tool{

    public Object obj;

    public Object getObject(){
        return obj;
    }
    public void setObject(Object str){
        System.out.println("111");
        this.obj=str;
    }

}
public class GenericDemo{
    Tool  tool=new Tool ();
    tool.setObject(new Car());
    tool.setObject(new Bus());
    Car car=(Car)tool.getObject();}//需要强转。就和ArrayList加泛型效果一样，可在编译期检查。

这样的话，就可以往里添加任何对象，但是不安全。使用泛型类将运行时的安全检查转换到了编译时期，避免了强转的麻烦。
三 泛型方法
我们的目标是想在调用show函数时，能够分别输出String和Integer结果，而不是传给不同参数的show函数。

public class Car<T>{
    public int viechle;
    public String battery;
    public Car(int viechle, String battery) {
        super();
        this.viechle = viechle;
        this.battery = battery;
    }
    public void show(String str){
        System.out.println(str);
    }

    public void show1(Object str){
        System.out.println(str);
    }
    public void show2(T str){
        System.out.print(str);
    }
    public <E> void show3(E str){
    }
}
<pre name="code" class="java">public class GenericDemo {
    public static void main(String[] args) {

        Car<String>car=new Car<String>();
        car.show3("d23");
        car.show3(3);
                car.show3(new Integer(3));
    }

}

public class Car<T>{
    public int viechle;
    public String battery;
    public Car(int viechle, String battery) {
        super();
        this.viechle = viechle;
        this.battery = battery;
    }
    public void show(String str){
        System.out.println(str);
    }

    public void show1(Object str){
        System.out.println(str);
    }
    public void show2(T str){
        System.out.print(str);
    }
    public <E> void show3(E str){
    }
}
public class GenericDemo {
    public static void main(String[] args) {

        Car<String>car=new Car<String>();
        car.show3("d23");
        car.show3(3);
                car.show3(new Integer(3));
    }

}

当调用show1方法时，是可以实现我们的目标的，通过向上转型，Object可以转换为String和Integer类型。当调用show2方法时，由于Car已经定义为String类型，即T被转换为String类型，这样在调用show2方法时，只能输出字符串类型，输出整数类型就会提示错误。当然我们还有一种方法，就是使用泛型函数show3，这样就可以根据需要，在执行时给定输入类型，达到输入啥类型输出啥类型的效果。
四 泛型接口
将泛型定义在接口上，实现接口的类要给出具体的类型。

public interface Inter<T> {
    public <Q> void show(Q str);//泛型函数，依然适用于输出任何类型的参数。</span>
    public void show2(T str);

}
public class InterClass2 implements Inter<String> {//实现接口时，要在接口处(Inter)和实现函数处(show2)给出具体的类型。这样main函数中就可以放心的往里放String类型字符串。

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        InterClass2 inter=new InterClass2();
        inter.show2("2");
    }

    @Override
    public void show2(String str) {
        // TODO Auto-generated method stub
        System.out.println(str);
    }

}
---------------------另外一种实现方式---------------------------------------------
public class InterClass<T> implements Inter<T> {//实现接口时，不给出具体类型，而是在main函数中，通过创建对象，确定泛型的具体类型。

    public void show2(T str) {
        // TODO Auto-generated method stub
        System.out.println(str);
    }
    public static void main(String[] args) {
    InterClass<Integer>inter=new InterClass<Integer>();
    inter.show2(2);}}

五 通配符
顾名思义，通通都能匹配的符号，用？来接收任何未知类型。以打印集合元素为例，我有ArrayList、ArrayList、HashSet三个集合，想通过printCollection函数，往里传啥类型就输出该类型所有元素。–可以用通配符来实现。

public class PrintColl {

    public static void printCollection(Collection<?>col){//如果只是ArrayList<String>和HashSet<String>集合，可用Collection<String>col方式（抽取共性）。但涉及到List和Set集合，并且有String和Integer不同类型，就得先抽取List和Set的共性：Collection，然后用通配符？表示String和Integer。
        Iterator<?>it=col.iterator();
        System.out.print(it.next());
    }
    public static void main(String[] args){
        ArrayList<String>a1=new ArrayList<String>();
        ArrayList<String>a2=new ArrayList<String>();
        HashSet<String>a3=new HashSet<String>();
        printCollection(a1);
        printCollection(a2);
        printCollection(a3);//这样的话，能全部通过编译，一次输出不同类型。
    }
}
-------------------------------------------------------------------------------------
//其实printCollection函数，可用泛型函数实现相同功能。
public static <T> void printCollection(T str){
    Iterator<T>it=col.iterator();
    System.out.print(it.next());
 }

六 泛型上下限
我有两个类Person和Dog，类Student继承了Person类。现在我想实现这样的功能：在调用printCollection函数时只打印Person及其子类对象，而不是一股脑统统的都打印出来。—-上(下)限。

public class Person {
    String name;
    int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

}
public class Student extends Person {

    public Student(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }

}
public class Dog {
    int age;
    public Dog(int age){
        this.age=age;
    }

}
public class PrintColl {

    public static void printCollection(Collection<? extends Person>col){
        Iterator<? extends Person>it=col.iterator();
        Person p=it.next();//确定上下限后，就可以用父类Person来接收所有子类型了，多好，将运行时的问题转换到了编译期。
         System.out.print(p);}
    public static void main(String[] args){
    ArrayList<Person>a1=new ArrayList<Person>();//ArrayList<Person>a1=new ArrayList<Student>()这样是不可以的，声明时集合中只能放Person对象，实体却把Student放进去了，不能同一代表。同样，反过来也不行，不能把实体Person放到Student的集合中去。两边泛型得匹配。
ArrayList<Dog>a2=new ArrayList<Dog>();
HashSet<Student>a3=new HashSet<Student>();
printCollection(a1);
//printCollection(a2);//添加a2就会出现问题，因为只能放Person及其子类。
printCollection(a3);}
}


------------在通过jdk两个例子解释下上下限-----------------------------------
Interface Collection<E>{
boolean addAll(Collection<?extends E>coll);//这样写，我可以往集合里添加E及其子类元素。如果是addAll(Collection<E>就只能往里添加E类元素，扩展性不强)
}
-----------------------------------------------------------------------------------------------------------------------------
class TreeSet<E>{
        TreeSet(Comparator<? super E>comparator);//若是TreeSet(Comparator<E>comparator)就只能用E类的比较器；若写成这种形式（下限），E的子类也可以用父类的比较器。
}