Java泛型

Java泛型

泛型实质上就是使程序员定义安全类型。在没有出现泛型之前，Java也提供了对Object的引用“任意化”操作，这种“任意化”操作就是对Object引用进行向下转型及向上转型操作，但某些强制类型转化的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转化存在安全隐患，所以提供了泛型机制。
回顾向上转型与向下转型：

/**
 * 回顾向上转型与向下转型
 * @author 我是灰太狼
 *
 */
public class Test {
	private Object genericity;//定义Object类型成员变量
	
	//设置相应的getXXX()方法
	public Object getGenericity() {
		return genericity;
	}
	//设置相应的setXXX()方法
	public void setGenericity(Object genericity) {
		this.genericity = genericity;
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.setGenericity(new Boolean(true));//向上转型操作
		System.out.println(t.getGenericity());
		t.setGenericity(new Float(11.1));
		Float f = (Float) t.getGenericity();//向下转型操作
		System.out.println(f);
	}
}

运行结果：

定义泛型类：

/**
 * 定义泛型类
 * @author 我是灰太狼
 *
 * @param <T>
 */
public class OverClass<T> {
	private T over;//定义泛型成员变量
	
	
	public T getOver() {//设置getXXX()方法
		return over;
	}

	public void setOver(T over) {//设置setXXX()方法
		this.over = over;
	}
	public static void main(String[] args) {
		//实例化一个Boolean型的对象
		OverClass<Boolean> over1 = new OverClass<>();
		//实例化一个Float型的对象
		OverClass<Float> over2 = new OverClass<>();
		over1.setOver(true);//不需要进行类型转换
		over2.setOver(11.1f);
		Boolean b = over1.getOver();//不需要进行类型转换
		Float f = over2.getOver();
		System.out.println(b);
		System.out.println(f);
	}
}

运行结果：

泛型的常规用法：
1、定义泛型时声明多个类型

/**
 * 定义泛型类时声明多个类型
 * @author 我是灰太狼
 *
 * @param <T1>
 * @param <T2>
 */
public class MutiClass<T1,T2> {
	public static void main(String[] args) {
		//实例化
		MutiClass<Boolean, Float> mutiClass = new MutiClass<>();
	}
}

2、定义泛型类时声明数组类型

/**
 * 定义泛型数组
 * @author 我是灰太狼
 *
 */
public class ArrayClass<T> {
	private T[] array;//定义泛型数组

	public T[] getArray() {
		return array;
	}

	public void setArray(T[] array) {
		this.array = array;
	}
	
	public static void main(String[] args) {
		ArrayClass<String> a = new ArrayClass<>();
		String[] array = {"成员1","成员2","成员3","成员4","成员5"};
		a.setArray(array);
		for (int i = 0; i < a.getArray().length; i++) {
			System.out.println(a.getArray()[i]);
		}
	}
}

运行结果：

3、集合类声明容器的元素

/**
 * 定义泛型集合类
 * @author 我是灰太狼
 *
 * @param <K>
 * @param <V>
 */
public class MutiOverClass<K,V> {
	public Map<K, V> map = new HashMap<K, V>();
	
	//设置put()方法，将对应的键名和键值存入集合对象中
	public void put(K k,V v){
		map.put(k, v);
	}
	
	//根据键名获取键值
	public V get(K k){
		return map.get(k);
	}
	
	public static void main(String[] args) {
		//实例化泛型类对象
		MutiOverClass<Integer, String> mu = new MutiOverClass<>();
		for (int i = 0; i < 5; i++) {
			//根据集合的长度循环将键名与具体值放入集合中
			mu.put(i, "集合成员"+i);
		}
		for (int i = 0; i < mu.map.size(); i++) {
			//调用get()方法获取集合中的值
			System.out.println(mu.get(i));
		}
	}
	
}

运行结果：

泛型的高级用法：
1、限制泛型可用类型

/**
 * 限制泛型可用类型
 * @author 我是灰太狼
 *
 * @param <T>
 */
public class LimitClass<T extends List> {
	public static void main(String[] args) {
		//可以实例化已经实现List接口的类
		LimitClass<ArrayList> l1 = new LimitClass<>();
		LimitClass<LinkedList> l2 = new LimitClass<>();
		//这句是错误的，因为HashMap没有实现List()接口
		//LimitClass<HashMap> l3 = new LimitClass<>();
		
	}
}

2、使用类型通配符

/**
 * 使用类型通配符
 * @author 我是灰太狼
 *
 * @param <T>
 */
public class A<T> {
	public static void main(String[] args) {
		A<? extends List> a = null;
		a = new A<ArrayList>();
		a = new A<LinkedList>();
	}
}

泛型总结：
泛型的使用方法：
1、泛型的参数只能是类类型，不可能是简单的类型，如A这种泛型就是错误的。
2、泛型的类型个数可以是多个。
3、可以使用extends 关键字限制泛型的类型。
可以使用通配符限制泛型的类型。