时间戳

首页 > 技术文章 > java泛型

java泛型

esileme 2017-09-04 19:36 原文

泛型的定义

　　泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

为什么要引入泛型

　　在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

例子:从最常见的List说起.

	List list = new ArrayList();
	list.add("CSDN_SEU_Calvin");
	list.add(100);
	for (int i = 0; i < list.size(); i++) {
		// 取出Integer时，运行时出现异常
		String name = (String) list.get(i);
		System.out.println("name:" + name);
	}

　　这几行代码在java编译期不会对代码进行检查,当不指定List中元素类型时,我们可以向List中添加任意种元素,但是在运行的时候就会出现int无法转成String类型的情况,此时会报出无法转换的异常.

　　这时候如果在List中引入泛型，只需要将上述代码第一行改为

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

　　此时就无须对元素类型进行转换，在编译器的时候就已经出错了，这就是最常用的泛型。

泛型的规则限制

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如 < T extends superclass >。习惯上称为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如 Class< ? > classType = Class.forName( "java.lang.String" );

泛型类的复用性

　　容器类应该算得上最具重用性的类库之一。先来看一个没有泛型的情况下的容器类如何定义：

public class Container {
    private String key;
    private String value;

    public Container(String k, String v) {
        key = k;
        value = v;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

　　Container类保存了一对key-value键值对，但是类型是定死的，也就说如果我想要创建一个键值对是String-Integer类型的，当前这个Container是做不到的，必须再自定义。那么这明显重用性就非常低。

　　当然，我可以用Object来代替String，并且在Java SE5之前，我们也只能这么做，由于Object是所有类型的基类，所以可以直接转型。但是这样灵活性还是不够，因为还是指定类型了，只不过这次指定的类型层级更高而已，有没有可能不指定类型？有没有可能在运行时才知道具体的类型是什么？

　　所以，就出现了泛型。

public class Container<K, V> {
	private K key;
	private V value;

	public Container(K k, V v) {
		key = k;
		value = v;
	}

	public K getKey() {
		return key;
	}

	public void setKey(K key) {
		this.key = key;
	}

	public V getValue() {
		return value;
	}

	public void setValue(V value) {
		this.value = value;
	}
}

　　在编译期，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。可以看一下现在Container类对于不同类型的支持情况：

public class Main {

    public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

接口定义泛型

interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl<T> implements Info<T> { // 定义泛型接口的子类
	private T var; // 定义属性

	public InfoImpl(T var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	public void setVar(T var) {
		this.var = var;
	}

    @Override
	public T getVar() {
		return this.var;
	}
};

public class GenericsDemo24 {
	public static void main(String arsg[]) {
		Info<String> i = null; // 声明接口对象
		i = new InfoImpl<String>("汤姆"); // 通过子类实例化对象
		System.out.println("内容：" + i.getVar());

		Info<Integer> itn = new InfoImpl<Integer>(123);
		System.out.println("内容：" + itn.getVar());

	}
};

　　可以看到，定义了接口以及接口的实现类，此时我们在接口的实现类中并没有具体地给实现类中指定特定类型，具体是什么类型，交给初始化完成，这样在初始化的时候可以指定任意类型的值，如在实例化的时候可以是String，Integer等。　　

interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl implements Info<String> { // 定义泛型接口的子类
	private String var; // 定义属性

	public InfoImpl(String var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	public void setVar(String var) {
		this.var = var;
	}
	
	@Override
	public String getVar() {
		return this.var;
	}
};

public class GenericsDemo25 {
	public static void main(String arsg[]) {
		Info i = null; // 声明接口对象
		i = new InfoImpl("汤姆"); // 通过子类实例化对象
		System.out.println("内容：" + i.getVar());
					
	}
};

　　在上个例子中我们在实现类中将接口中的泛型实例化成String类型，所以在实例化实现类时就指定了实现类为String类型。

泛型方法

　　一个基本的原则是：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义：

public class Main {

	public static <T> void out(T t) {
		System.out.println(t);
	}

	public static void main(String[] args) {
		out("findingsea");
		out(123);
		out(11.11);
		out(true);
	}
}

　　可以看到方法的参数彻底泛化了，这个过程涉及到编译器的类型推导和自动打包，也就说原来需要我们自己对类型进行的判断和处理，现在编译器帮我们做了。这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数，大大增加了编程的灵活性。

public class Main {

	public static <T> void out(T... args) {
		for (T t : args) {
			System.out.println(t);
		}
	}

	public static void main(String[] args) {
		out("findingsea", 123, 11.11, true);
	}
}

　　输出和前一段代码相同，可以看到泛型可以和可变参数非常完美的结合。

泛型类型檫除

https://segmentfault.com/a/1190000003831229　　

参考：

百度百科  
https://segmentfault.com/a/1190000002646193  
https://my.oschina.net/roockee/blog/165378  
http://blog.csdn.net/seu_calvin/article/details/52230032

推荐阅读