java之泛型的使用

在java中，普通的类和方法只能用具体的类型，这对代码的限制很大，代码的可重用性大大降低。

那么如何才能让同一个类和方法使用不同类型的对象呢？在接触泛型之前我们可能会想到通过类型转换的方法来实现。

public class Test {

    Object o;

    public Test(Object o) {

        this.o = o;

    }

    public void set(Object o){

        this.o=o;

    }

    public Object get(){

        return o;

    }

    public static void main(String[] args) {

        String str="hello world";

        Test test=new Test(str);

        String str2=(String) test.get();

    }

}

但是这种方法有很大的缺陷，容易在类型转换过程中出现错误，而使用泛型能很好地避免这个错误的出现。

泛型能够能够指定容器容器要装什么类型的对象，无须类型转换。

泛型类：

public class Test<T> {

    private T a;

    public Test(T a) {

        this.a = a;

    }

    public T getA() {

        return a;

    }

    public void setA(T a) {

        this.a = a;

    }

    public static void main(String[] args) {

        Test<String> test = new Test<>("test");

        System.out.println(test.getA());

    }

}

泛型方法:

    public <T> String getClassName(T t) {

        return t.getClass().getSimpleName();

    }

对于泛型方法和泛型类，我们通常首先选择泛型方法，毕竟，泛型类的束缚更大，它表示我们在整个类中都要使用着这类型；相对而言泛型方法就灵活许多，我们可以在不同的方法中使用不同的类型。

泛型擦除：

public static void main(String[] args) {

        List<Integer> list1 = new ArrayList<>();

        List<String> list2 = new ArrayList<>();

        System.out.println(list1.getClass()==list2.getClass());

        /*

        output:

        true

        */

}

list1和list2的泛型参数类型不相同，但从上面的结果中不难看出，系统认为它们是相同的类型，因为泛型只在编译过程起作用，当程序运行时泛型参数的具体信息都被擦除。

边界：

class Animal{

    void eat(){}

}

class Bird extends Animal {

}

当我们已经确认此泛型参数为一固定类型Animal或Animal的子类时，我们希望能够调用Animal对象中的eat方法，那我们又该如何实现呢？

这里我们需要用到泛型边界，它通过extends关键字来实现：

public class Test<T extends Animal> {

    public void test(T t) {

        t.eat();

    }

}

这里声明了边界Animal，它可以调用Animal中的成员。如果没有声明边界，则默认边界为Object。

当然如果只是实现这个目的，我们无需使用泛型：

public class Test{

    public void test(Animal a){

        a.eat();

    }

}

好像这里使用泛型没什么用处，其实并非如此。当泛型方法有泛型类型的返回值时，它能返回确切的类型：

public class Test<T extends Animal> {

    public T get(T t) {

        t.eat();

        return t;

    }

    public static void main(String[] args) {

        Animal a = new Test<>().get(new Animal());

        Bird b = new Test<Bird>().get(new Bird());

    }

}

这比不使用泛型灵活许多，所以，我们在考虑是否使用泛型时要根据具体情况而定，看看结构是否足够复杂，使用泛型是否会给我们带来方便。

通配符：

我们再来看一个错误例子:

List<Animal> list=new ArrayList<Bird>(); //error:Type mismatch: cannot convert from ArrayList<Bird> to List<Animal>

想当初第一次运行类似的代码时，我有些无法理解，Bird是Animal的子类，为何就不能向上转型呢呢，这泛型也太呆板了。仔细一想才发现，这根本就不是向上转型，List<Animal>代表Animal类型的列表，而ArrayList<Bird>代表Bird类型的列表。

可是我们就是想要实现这样的功能，那该怎么做？这里就需要用到通配符：

List<? extends Animal> list=new ArrayList<Bird>();

泛型与数组：

我们无法直接创建泛型数组实例，因为你数组类型必须是确定的，以此确保类型安全，但是擦除却使类型参数信息消失。

List<String>[] lists=new ArrayList<String>[12]; //error

但是们可以声明一个泛型数组：

List<String>[] lists;

根据以上两个特性，我们可以创建一个非泛型数组，再进行转型，从而获得泛型数组：

List<String>[] lists=(List<String>[])new ArrayList[12];

        //或简化为：List<String>[] lists=new ArrayList[12];

巴特西

java之泛型的使用

最新文章

热门文章