码迷,mamicode.com
首页 > 编程语言 > 详细

[Java5新特性]泛型

时间:2015-05-31 23:20:53      阅读:204      评论:0      收藏:0      [点我收藏+]

标签:java5   集合   泛型   类型通配符   泛型方法   

Java中集合的问题

Java中的集合有个缺点:就是当我们把数据放置到集合中时,集合是不会记住数据类型的。也就是说,当我们再从集合中获取到数据时,数据类型都变成了Object类型了。

换句话讲,集合对元素类型是没有任何限制的。这样可能会出现一些问题,例如如果我们要创建一个专门存储字符串的List集合的话,也可以将Integer类型数据放置进入。即使放置进去的都是字符串数据,从List集合取出时,还是需要类型转换的(因为集合中元素类型都是Object类型)。

例如下面这个例子:创建一个只保存字符串的List集合,但Integer类型的数字也是可以保存的。在从List集合中取出元素时,是需要强制类型转换的。

public class Demo {
    public static void main(String[] args) {
        // 创建一个只保存字符串的List集合
        List list = new ArrayList();
        list.add("Hello");
        list.add("World");
        list.add(1000);

        for (int i = 0; i < list.size(); i++) {
            String str = (String) list.get(i);
            System.out.println(str);
        }
    }
}

上述案例如果想要解决的话,我们可以自定义扩展ArrayList,以保证自定义ArrayList只能保存字符串数据类型。

public class Demo {
    private List list = new ArrayList();
    // 定义自定义ArrayList的add方法
    public boolean add(String ele) {
        return list.add(ele);
    }
    // 重写get方法,将get方法的访挥之类型改为String类型.
    public String get(int index) {
        return (String) list.get(index);
    }
    public int size() {
        return list.size();
    }
}

这种方式虽然有效,但局限性很大。在实际开发时,我们需要自定义大量List子类,增大开发工作量,且不具通用性。

什么是泛型

在Java 5版本后,为我们提供了泛型来解决上述问题。首先,我们来查看以下ArrayList的源代码片段:

public class ArrayList<E> {
    public int size() {
        return size;
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
}

通过查看源代码我们发现,在ArrayList底层代码中,ArrayList类后跟着“”写法,实际上这就是泛型。在ArrayList类的add方法和get方法中,我们也可以看到add方法增加的元素类型是E类型,get方法获取元素返回的类型也是E类型。

所以,上述问题我们可以利用Java 5版本后提供的泛型来解决:

public class Demo {
    public static void main(String[] args) {
        // 创建一个只保存字符串的List集合
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        list.add("World");

        for (int i = 0; i < list.size(); i++) {
            String str = (String) list.get(i);
            System.out.println(str);
        }
    }
}

那到底什么是泛型呢?泛型其实就是允许在定义类或接口时指定类型形参,这个类型形参将在声明变量、创建对象时确定。说白了,如果集合就像是一个装满东西的瓶子的话,那泛型就像是瓶子上的标签,指定当前这个瓶子只能存放哪一类的东西。

如何定义泛型类

利用泛型定义接口或类的具体方式是怎么样的呢?其实在上述案例中,我们查看的ArrayList类就是一个泛型类,而ArrayList类实现的List就是一个泛型接口。

public class ArrayList<E> {
    public int size() {
        return size;
    }
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
}
public interface List<E> {
    int size();
    boolean add(E e);
    E get(int index);
}

通过上面两个Java底层提供的案例,我们如果自定义泛型接口或类,应该遵循什么规则呢?

  • 在类名后编写“”表示该类接收的是泛型,T就代表泛型。在创建该类对象时,指定具体类型。(T不具备实际含义,这里可以随意指定。)
  • 在泛型类中的方法可以接收泛型参数或返回泛型。
  • 在泛型类中,泛型只能用于非static成员中。
public class Demo<T> {
    private T bean;

    public T getBean() {
        return bean;
    }

    public void setBean(T bean) {
        this.bean = bean;
    }
}

如何定义泛型方法

除了可以定义泛型接口或类之外,还有一些情况:定义接口或类时没有使用泛型,但定义方法时想自定义类型形参。在Java 5版本后还提供了泛型方法的支持。

所谓泛型方法,就是在声明方式时定义一个或多个类型参数。泛型方法的使用格式如下:

修饰符 <T, S> 返回值类型 方法名(形参列表){
    方法体
}

根据这个格式,我们来自定义一个泛型方法:

public class Demo {
    public static <T> T get(T[] ts) {
        return ts[0];
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, 2, 3 };

        // 调用方法时,自动识别泛型!因为arr这个参数是Integer[],所以相当于给T赋值为Integer
        Integer i = get(arr);
        System.out.println(i);
    }
}

类型通配符

如果我们在使用一个泛型类时,应该为该泛型类传入一个类型实参,如果没有传递类型实参的话,就会引起泛型安全警告。下面我们来看一个例子:

public class Demo {
    public void demo(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

这个案例中,我们定义了一个方法,接收一个泛型为String类型的List集合,并遍历该List集合,打印每一个元素内容。但问题是该方法只能遍历打印泛型为String类型的List集合,如果要想完成同样功能的Integer类型的话,我们需要重新定义一个方法。

public class Demo {
    public void demo(List<Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

但问题在于,当上面两个方法出现在同一个类中时,会报错“Method demo(List) has the same erasure demo(List) as another method in type Demo”。原因在于除了泛型不同之外,实际上这两个方法是相同的,而在同一个类中是不允许出现多个相同的方法的。

这个问题的解决方法就是,我们可以将参数中泛型内容去掉,例如下面的代码:

public class Demo {

    public static void print(List list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void main(String[] args) {
        List<String> strings = null;
        List<Integer> integers = null;
        print(strings);
        print(integers);
    }
}

这样在在print方法中,既可以接收Integer类型的List集合,也可以接收String类型的List集合了。但是,这时会提示泛型安全警告“List is a raw type. References to generic type List should be parameterized”

要想彻底解决这个问题,我们需要使用类型通配符。通过类型通配符上面的代码可以改写成如下方式:

public class Demo6 {

    public static void print(List<?> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void main(String[] args) {
        List<String> strings = null;
        List<Integer> integers = null;
        print(strings);
        print(integers);
    }
}

上述案例中的“

List<? extends Number> listList<? super Integer> list

这里①表示类型通配符的上边界,含义是当前的泛型可以接收所有Number类型的子类型;②表示类型通配符的下边界,含义是当前的泛型可以接收所有Integer类型的父类型。


转载说明:请注明作者及原文链接,谢谢!

[Java5新特性]泛型

标签:java5   集合   泛型   类型通配符   泛型方法   

原文地址:http://blog.csdn.net/longestory/article/details/46292883

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!