鸟欲高飞先振翅，人求上进先读书 [泛型 泛型类 泛型方法 泛型接口 泛型通配符详解]

5. 泛型

5.1 泛型概述【理解】

泛型的介绍
泛型是 JDK5中引入的特性，它提供编译时类型安全检测机制。

5.2 为什么会引入泛型？

public class TestDemo{
	public static void main(String[]args){
		ArrayListlist = new ArrayList();//创建集合对象
		list.add("aaa");
		list.add("bbb");
		list.add(""ccc");//添加集合元素
		//list.add(1);
		Iterator it = list.iterator();//创建迭代器对象
		while(it.hasNext()){
			//此时如果我们想要获取集合中每个元素的长度该怎么办？
			// 1.Object next = it.next();
			// 2.int length = next.length();
			String s = (String)it.next();
			int length = s.length;
			System.out.println(s);
			System.out.println(it.next());//打印集合中的每一个元素
		}
	}
}

我们来看如上代码，如果没有泛型，我们是可以正确打印出集合中的元素的，但是如果在使用迭代器遍历集合时，想要获取集合中每个元素的长度时，通过上述代码标注1和2的位置，可以得到元素长度吗？显然是不能的！
因为我们通过调用 next()方法，返回的元素的类型是Object 类型的，由继承体制可知，Object父类无法调用子类String子类中的特有的 length()方法，所以我们无法获取元素的长度，问题到这我们应该能想到强制类型转换来解决这个问题了，如上代码，显然是可以解决的，但是当我们在集合中添加一个Integer类型的元素时，此时程序编译是没有问题的，但是当运行程序时，我们发现程序会报错，这是为什么呢？ 不难发现，当使用迭代器遍历到 Integer类型的元素时，我们无法将 Integer类型的对象强制转换成 String 类型的对象，当引入泛型时我们将泛型定义为String类型，这样添加 Integer 类型的元素时，程序编译时就会报错，而且在获取元素的长度时也不需要进行强制类型转换了！是不是很高兴啊~我们也由此知道了引入泛型的好处。

5.3 泛型的好处

	1. 把运行时期的问题提前到了编译时期。
	2. 避免了强制类型转换。

5.4 泛型的定义格式

 1.<类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母。
 2.<类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开。

5.5 泛型类【应用】

定义格式

修饰符 class 类名 <类型>{}

示例代码
1.泛型类

public class Generic<T> {
	private E t;
	public T getT(){
		return t;
	}
	public void setT(T t){
	this.t = t;
	}
}

2.测试类

	public class GenericDemo1{
		public static void main(String[]args){
			Generic<String> g1 = new Generic<>();
			g1.setT("杨幂");
			System.out.println(g1.getT());

			Generic<Integer> g2 = new Generic<>();
			g2.setT(30);
			System.out.println(g2.s=getT());

			Generic<boolean> g3 = new Generic<>();
			g3.setT(true);
			System.out.println(g3.getT());
		}
	}

5.6 泛型方法

定义格式

修饰符 <类型> 返回值类型 方法名(类型 变量名){}

示例代码
1.带有泛型方法的类

public class Generic{
	public <T> void show(T t){
		System.out.println(t);
	}
}

2.测试类

public class GenericDemo2{
	public static void main(String[]args){
		Generic g = new Generic();
		g.show("柳岩");
		g.show(30);
		g.show(true);
		g.show(12.34);
	}
}

5.7 泛型接口【应用】

定义格式

修饰符 interface 接口名<类型>{}

示例代码
1.泛型接口

public interface Generic<T>{
	void show(T t);
}

2.泛型接口实现类1
定义实现类时，定义和接口相同泛型，创建实现类对象时明确泛型的具体类型

public class GenericImpl1<T> implements Generic<T> {
	@override
	public void show(T t) {
	System.out.println(t);
	}
}

3.泛型接口实现类2
定义实现类时，直接明确泛型的具体类型

public 	class GenericImpl2 implements Generic<Integer>{
	@override
	public void show(Integer t){
		System.out.println(t);
	}
}//此时GenericImpl2类相当于一个普通的类

4.测试类

public class GenericDemo3{
	public static void main(String[]args){
		GenericImpl1<String> g1 = new GenericImpl1<>();
		g1.show("林青霞");
		GenericImpl1<Integer> g2 = new GenericImpl1<>();
		g2.show(30);

		GenericImpl2 g3 = new GenericImpl2();
		g3.show(101);
		

5.8类型通配符

类型通配符：<?>

ArrayList<?>： 1. 表示元素类型未知的 ArrayList ，它的元素可以匹配任何类型。2.但是并不能把元素添加到 ArrayList 中了，获取出来的也是父类类型。

5.8.1 类型通配符上限<? extends 类型>

	ArrayList<? extends Number>:它表示的类型是 Number 或者其子类类型

5.8.2 类型通配符下限<? super 类型>

	ArrayList<? super Number>:它表示的类型	是 Number 或者其父类类型

5.8.3 泛型通配符的使用

public class GenericDemo4{
	public static void main(String[]args) {
		ArrayList<Integer> list1 = new ArrayList<>();
		ArrayList<String> list2 = new ArrayList<>();
		ArrayList<Number> list3 = new ArrayList<>();
		ArrayList<Object> list4 = new ArrayList<>();
		
		method(list1);
		method(list2);
		method(list3);
		method(list4);

		getElement1(list1);
		getElement1(list2);//报错，String不是Number的子类
		getElement1(list3);
		getElement1(list4);//报错，Object不是Number的子类

		getElement2(list1);//报错，Integer不是Number的父类
		getElement2(list2);//报错，String不是Number的父类
		getElement2(list3);
		getElement2(list4);
	}
	//泛型通配符：此时的泛型?,可以是任意类型。
	public static void method(ArrayList<?>list){}
	//泛型的上限：此时的泛型?,必须是Number类型或者Number类型的子类
	public static void getElement1(ArrayList<? extends Number>){}
	//泛型的下限：此时的泛型?,必须是Number类型或者Number类型的父类
	public static void getElement2(ArrayList<? super Number>){}
}