Java学习----泛型

今日学习内容总结如下：

不引入泛型的问题：

当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

因此取出集合元素时需要人为的强制类型转化到具体的目标类型，但是很容易出现
ClassCastException异常

那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现java.lang.ClassCastException异常呢？

答案就是使用泛型，可以将运行时的类型检查搬到编译期实现

什么是泛型

泛型是jdk5引入的类型机制，就是将类型参数化。泛型作为一种安全机制而产生

泛型机制将类型转换时的类型检查从运行时提前到了编译时，使用泛型编写的代码比杂乱的使用object并在需要时再强制类型转换的机制具有更好的可读性和安全性。

泛型在本质上是指类型参数化。所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。

在声明List<E>阶段E是什么类型不确定，这里的E仅仅充当占位符的作用，在具体调用时类型才能确定，而E的所有位置将被指定的类型所替代

使用泛型的定义

public interface List<E> extends Collection<E>
这里的<>中的内容就是类型参数，一般建议使用T或者E之类的全大写
{
         E get(int index);  获取的元素类型就是定义时指定的类型
         void add(E element);
}

List<String> list=new ArrayList<String>();就是将String传递给E，用于替代定义中的EString str=list.get(0); 不需要进行类型转换

List<Date> list=new ArrayList<>();//这里使用菱形语法，支持泛型推导
list.add("abc");//语法报错，编译时就会进行类型检查
list.add(123);//语法报错
list.add(new Date());
for(int i=0;i<list.size();i++){
     Date temp=list.get(i);   直接获取目标类型，不需要进行类型转换
     System.out.println(temp.getYear()+1900);
}

典型场景

获取两个整数中较大的整数
        

Integer max(Integer a, Integer b){
             return a>b?a:b;      
         }

如果需要比较的不是Integer类型，而是Double或是Float类型，那么就需要另外再写max()方法【方法的重载】。

引入泛型的目的实际上就是能够在编写max()方法时，不必确定参数a和b的数据类型，而等到调用的时候再来确定这两个参数的数据类型，那么只需要编写一个max()就可以了，这将大大降低程序员编程的工作量。

Comparable接口---用于类定义中表示当前类型的对象是可比较的，接口中定义了比较方法，要求具体类型提供实现【具体的比较规则】

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

public class Test1 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Date());
		list.add(new Random());
		list.add("abcd");
		for (int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			if (obj != null) {
				if (obj instanceof String) {
					String ss = obj.toString();
					System.out.println(ss.length());
				} else if (obj instanceof Date) {
					Date dd=(Date)obj;
					System.out.println(dd);
				}
			}
		}
	}
}

定义泛型接口

public interface IA<T>{
   public T pp();
}

定义泛型类上给泛型添加约束

public class MyClass<T extends IA>{}

在泛型类或者泛型接口中不允许直接使用super

// 在这里, Integer 可以认为是 Integer 的 "父类"
List<? super Integer> array = new ArrayList<Integer>();
// Number 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Number>();
// Object 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Object>();

如果要求泛型实现两个或者两个以上的接口，要求传入的类型T必须同时实现了接口1和接口2。

public class MyClass<T extends 接口1 & 接口2>{}

如果要求泛型必须继承B类，同时实现IC接口

public class MyClass<T extends B & IC >{}

如果要求泛型继承一个类并且实现接口

public class MyClass<T extends 类型 & 接口>{}

<? extends T>只能用于方法返回，告诉编译器此返参的类型的最小继承边界为T，
T和T的父类都能接收，但是入参类型无法确定，只能接受null的传入
<? super T>只能用于限定方法入参，告诉编译器入参只能是T或其子类型，而返参只能用Object类接收

• `?`既不能用于入参也不能用于返参
• 频繁往外读取内容的，适合用上界extends
• 经常往里插入的，适合用下界Super

import java.util.ArrayList;
import java.util.List;

public class Test1 {
	public void pp(List<?> list) {
//		list.add("123"); // 语法报错
		
//		Object aa="123";
//		list.add(aa);
		
		for(Object tmp:list) {
			System.out.println(tmp);
		}
	}
	
	public void bb(List<Object> list) {}

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("bbbb");
		
		Test1 t = new Test1();
		t.pp(list);
		
//		t.bb(list);   //List<String>和List<Object>之间没有任何关系
		
		List<Object> alist=new ArrayList<>();
		alist.add("1234");
		alist.add(1234);
		t.bb(alist);
	}
}