回顾泛型

泛型
1. 泛型类：具有一个或多个类型变量的类，称之为泛型类！

class A<T> {
}

泛型方法：具有一个或多个类型变量的方法，称之为泛型方法！

class A<T> {
public T fun(T t1) {}
}

fun()方法不是泛型方法！它是泛型类中的一个方法！

public <T> T fun(T t1) {} --> 它是泛型方法

* 泛型方法与泛型类没什么关系，泛型方法不一定非要在泛型类中！

4. 泛型在类中或方法中的使用
* 泛型类中使用泛型：
    > 成员类型
    > 返回值和参数类型
    > 局部变量的引用上

class A<T> {
private T bean;//泛型可在成员变量上使用
public T fun(T t) {}//泛型可以在类中的方法上（返回值和参数类型）使用！

public void fun2() {//泛型还可以在局部变量的引用类型上使用
T b = ...
new T();//不行的！
}
}

5.1 继承泛型类

* 子类不是泛型类：需要给父类传递类型常量
> 当给父类传递的类型常量为String时，那么在父类中所有T都会被String替换！
* 子类是泛型类：可以给父类传递类型常量，也可以传递类型变量

* 子类不是泛型类：需要给父类传递类型常量
> 当给父类传递的类型常量为String时，那么在父类中所有T都会被String替换！

子类是泛型类：可以给父类传递类型常量，也可以传递类型变量

package cn.itcast;

import org.junit.Test;

public class Demo1 {
	@Test
	public void fun1() {
		AA3<Long> aa3= new AA3<Long>();
		aa3.
	}
}

class A<T> {
	private T t;
	
	public T fun1() {
		return t;
	}
	
	public void fun2(T t) {
		this.t = t;
	}
}
class AA3<E> extends A<E> {
	
}

class AA1 extends A<Integer> {//父类中的T,都会被Integer 替换
	
}

class AA2 extends A<String> {//父类中的T,都会被String替换
	
}

例如虽然写成了泛型但是jvm 是不认识的

public class Demo2 {
   @Test
   public void fun1() {
       Object[] objs = new Object[10];
       List list = new ArrayList()；
       String[] strs = new String[10];
       List<String> strList = new ArrayList<String>();

里面没有泛型

数组和集合的对比

@Test
	public void fun1() {
		//对比数组和集合
//		1 数组能实现的集合也能实现
		Object[] objs = new Object[10];
		List list = new ArrayList();
		
		String[] strs = new String[10];
		List<String> strList = new ArrayList<String>();
		//2 数据能实现的但是集合不能实现
		Object[] objArray = new String[10];
		objArray[0] = new Integer(100);//虽然可以识别了，但是会抛出异常 ArrayStoreException
		//集合败下阵来，由于泛型虚拟机是不认识的
		/*
		 * List<Object> objList = new ArrayList<String>();//虚拟机会转变为
		 * List objList = new ArrayList() 所以objList.add(new Integer(100)); 
		 * 这个仍然能执行，那就和数组没有区别了，所以虚拟机从一开始
		 * List<Object> objList = new ArrayList<String>(); 这步就不让执行了
		 * 所以泛型引用和创建两端，给出的泛型变量必须相同！
		 */
	}

泛型通配符使用的场景

方法的形参！

这种写法是错误的，由于泛型引用和创建两端，给出的泛型变量必须相同！

所以这种方法就是很不好，只能是重载

如果想调用一个方法怎么办

通配符的使用限制

1 其中的?就是通配符
通配符只能出现在左边！即不能在new时使用通配符！！！
List<?> list = new ArrayList<String>(); // List<?> list = new ArrayList<?>();是错误的

2 通配符的含义

?它表示一个不确定的类型，它的值会在调用时确定下来

这种写法是错的，因为不知道是什么类型是不能直接往里面加字符串，万一人家是

if(t instanceof EventLevelAndEventNumber){

Object s = list.get(0); 只能是通过这种方式调用

public void fun3() {
		List<Integer> intList = new ArrayList<Integer>();
		print1(intList);
		
		List<Long> longList = new ArrayList<Long>();
		print1(longList);
	}
	
	/*
	 * 给通配符添加了限定：
	 *   只能传递Number或其子类型
	 *   子类通配符对通用性产生了影响，但使用形参更加灵活
	 */
	public void print1(List<? extends Number> list) {
		/*
		 * 参数为泛型的方法还是不能使用
		 */
//		list.add(new Integer(100));
		/*
		 * 返回值为泛型的方法可用了！
		 */
		Number number = list.get(0);
	}

	public void fun4() {
		List<Integer> intList = new ArrayList<Integer>();
		print2(intList);
		
		List<Number> numberList = new ArrayList<Number>();
		print2(numberList);
		
		List<Object> objList = new ArrayList<Object>();
		print2(objList);
	}
	
	/*
	 * 给通配符添加了限定
	 *   只能传递Integer类型，或其父类型
	 */
	public void print2(List<? super Integer> list) {
		/*
		 * 参数为泛型的方法可以使用了
		 */
		list.add(new Integer(100));
		/*
		 * 返回值为泛型的方法，还是不能使用Integer in =  list.get(0); 不能使用
		 */
		Object obj =  list.get(0);
	}

2. 通配符的优点
使方法更加通用！

3. 通配符分类
无界通配：?
子类限定：? extends Object
父类限定：? super Integer

4. 通配符缺点
使变量使用上不再方便
无界：参数和返回值为泛型的方法，不能使用！
子类：参数为泛型的方法不能使用
父类：返回值为泛型的方法不能使用

5. 比较通配符
boolean addAll(Collection<E> c)

List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();

// 由于是List<Number> numList 调用的是addAll(Collection<E> c) 所以这个方法变为了addAll(Collection<Number> c)
numList.addAll(intList);//addAll(Collection<Number> c), 传递的是List<Integer> 编译不通过

boolean addAll(Collection<? extends E> c)

List<Number> numList = new ArrayList<Number>();
List<Integer> intList = new ArrayList<Integer>();
numList.addAll(intList);//addAll(Collection<? extends Number> c), 传递的是List<Integer> 编译通过了

猜你喜欢