JavaSE-泛型机制

泛型是java编程中经常使用，且很有用的一个特性，经常在集合与DAO（数据库访问对象）编程中使用。

1、为什么要使用泛型：

在没有使用泛型时，集合存储和提取数据经常出现两个不足：

1.存储数据时，不能保证数据的类型安全，也就是说，同一集合中可以存储多种类型的数据

2.在集合中获取数据时，必须经过强制转换，才能转换为自己需要类型的数据，而且由于第一条的不足，导致会出现类型转换异常

这就相当于绕了一个弯，把原本的数据类型--->转换为Object类型存储--->转换为原本的数据类型以便使用。

代码：

//在没有使用泛型时：
//1、不能保证存储数据类型的安全
//2、数据需要强转，可能出现ClassCastExcepetion异常
@Test
public void testNoGeneric(){
List list = new ArrayList();
list.add(88);
list.add(90);
list.add(99);

list.add("AA");//不能保证存储数据类型安全

for(int i=0;i<list.size();i++){
int score = (int) list.get(i);//抛出ClassCastException异常
System.out.println(score);
}
}

java 的泛型机制就是解决这么样的问题，通过使用泛型：

1.保证数据存储类型的安全，就是通过指定泛型的类型，使得在存储数据时，只能存储先前指定类型

2.避免了数据类型的转换，也就避免了异常

代码：

//使用泛型，保证数据存储的类型安全
//同时，避免了强制类型转换
@Test
public void testGeneric1(){
//在指定泛型之后，该泛型类的所有有关泛型的方法或返回类型，都变成了指定的泛型类型
List<Integer> list =
new ArrayList<Integer>();//实现类的泛型可以不再指定，只需一个<>即可
list.add(88);
list.add(90);
list.add(99);
//list.add("AA");//编译时就会报错，保证数据存储类型的安全

//List容器的遍历方法
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
Integer score = it.next();
System.out.println(score);
}
//或者
//		for(Integer i:list){
//			System.out.println(i);
//		}
}

2、在集合中使用泛型：

其实通过指定泛型，泛型类的所有与泛型相关的方法都自动变成了指定的类型

集合List：见“为什么使用泛型”一节

集合Map：

@Test
public void test3(){
Map<String, Integer> map =
new HashMap<String,Integer>();//OR new HashMap<>()即可
map.put("AA", 78);
map.put("BB", 88);
map.put("CC", 99);

Set<Entry<String, Integer>> set = map.entrySet();
for(Entry<String, Integer> o:set){
System.out.println(o);
}
}

3、自定义泛型类、泛型接口和泛型方法

自定义泛型类

通过添加<T>在类型名后边:class ClassName<T>

自定义泛型类Order，

代码：

public class Order<T> {

private String orderName;
private int orderId;
private T t;
public List<T> list = new ArrayList<>();

public void add(){
list.add(t);
}

public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
@Override
public String toString() {
return "Order [orderName=" + orderName + ", orderId=" + orderId + ", t=" + t + "]";
}

//泛型方法,泛型方法的类型与泛型类无关
public <E> E getE(E e){
return e;
}
//泛型方法，实现数组到集合的复制
public <E> List<E> fromArrayToList(E[] arr, List<E> list){
for(E e:arr){//数组也可以这样遍历
list.add(e);
}
return list;
}
}

Order的使用，

代码：

//自定义泛型类的使用
@Test
public void test4(){
Order<Boolean> order = new Order<Boolean>();
order.setT(true);
Boolean b = order.getT();
System.out.println(b);

order.add();
List<Boolean> list = order.list;
System.out.println(list);

}

1.在实例化泛型类对象时，指定泛型的类型，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型

2.如果我们定义了泛型类，但在实例化中未指定泛型类型，那么默认是Object类型

子类继承泛型类，可以指定泛型类型，也可以保持子类继续是泛型类：

代码：

//定义泛型类的子类时，可以指明泛型类型，通过在父类后指定类型
class subOrder extends Order<Boolean>{
}
//也可以不指定，子类也还是泛型,子类父类都需指定泛型<T>
class subOrder2<T> extends Order<T>{

}

泛型接口同泛型类；

泛型方法

泛型方法其实与泛型类无关，泛型方法可以在泛型类中，也可以在非泛型类中。

泛型方法通过权限修饰符后添加泛型<E>，使函数方法成为泛型方法，参看Order类中两个泛型方法getE()和fromArrayToList()

//泛型方法,泛型方法的类型与泛型类无关
public <E> E getE(E e){
return e;
}
//泛型方法，实现数组到集合的复制
public <E> List<E> fromArrayToList(E[] arr, List<E> list){
for(E e:arr){//数组也可以这样遍历
list.add(e);
}
return list;
}

泛型方法的使用：（其实通过参数，便指定类泛型方法的泛型类型）

代码：

//泛型方法的使用
@Test
public void test5(){
Order<Boolean> order = new Order<Boolean>();
//调用泛型方法
Integer i = order.getE(50);//指定参数，返回类型确定为Integer
Double d = order.getE(4.3);//返回类型为Double

Integer[] ints = new Integer[]{1,2,3};
List<Integer> list = new ArrayList<>();
List<Integer> list3 = order.fromArrayToList(ints, list);
System.out.println(list3);
}

4、泛型与继承的关系

类之间存在继承关系，String类是Object类的子类，那么泛型中List<String>与List<Object>存在怎么样的关系呢？

List<String>与List<Object>是并列关系，不存在继承关系：

/*
* List<Object>与List<String>不存在子父类关系，属于并列关系
* 他们有共同的父类：List<?>
*/
@Test
public void test6(){
Object obj = null;
String str = "AA";
obj = str;//没问题，子类赋给父类

Object[] objs = null;
String[] strs = new String[]{"AA","BB","CC"};
objs = strs;//没问题，子类数组赋给父类数组

List<Object> listObject=null;
List<String> listString = new ArrayList<String>();
listObject = listString;//编译不通过，说明List<Object>与List<String>不存在子父类关系

}

其实，List<String>与List<Object> 有共同的父类：List<?> ，这就是通配符?的作用，看下节。

5、通配符

通配符，就是应对泛型类之间的继承关系的，分三种：

List<?> 是所有List<ClassName>的父类

代码：

/**
* 通配符?
* List<?> 是所有List<Object>、List<String> ... 的父类
*/
public void test7(){

List<?> list=null;//共同的父类，通配符?
List<Object> listObject = new ArrayList<Object>();
List<String> listString = new ArrayList<String>();
list = listObject;
list = listString;

show(listObject);
show(listString);
}

List<? extends A>是List<A类及其子类> 的父类

List<? super B> 是List<B类及其父类> 的父类

/*
* List<? extends A>是所有A类及其子类的父类，即：
* 	     可以存放A的所有子类及其本身ClassName类；
* List<? super B> 是所有B类及其父类的父类，即：
*    可以存放所有B的父类及B类；
*/
public void test8(){
List<? extends Number> list1 = null;
List<Integer> list2= null;
list1 = list2;//可以，因为Integer是Number的子类

List<Object> list3 = null;
//		list1 = list3;//编译不通过，因为Object 是Number的父类

List<? super Number> list4 = null;
list4 = list3;//可以
}

对于通配符的泛型集合List<?> ，是可以进行遍历查看操作的，但是不允许进行写入，只可以写入null

@Test
public void test9(){
List<String> list = new ArrayList<>();
list.add("AA");
list.add("BB");
list.add("CC");

List<?> list1= list;
//可以查看遍历声明通配符List<?>中的元素
Iterator<?> it = list1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

//不可以向声明为通配符的泛型List<?>中添加元素，唯一例外的是null
//		list1.add("AA");//编译不通过
list1.add(null);
}

6、其他注意点

1.静态方法中不能使用类的泛型

在泛型类中，静态方法中不能使用泛型，因为静态方法在类加载时就加载了，此时还未指定泛型类的类型，不能使用。

但是在静态方法中可以使用泛型方法，即结合静态方法与泛型方法：

public static <E> E test(E e){
return e;
}

2.如果泛型类是一个接口或者抽象类，则不可创建泛型类的对象

接口和抽象类本身就不可以创建类对象，跟泛型无多大关系

3.不能在catch语句中使用泛型

在泛型类中，可能会写到try-catch语句，进行异常的处理，但是泛型T是不可以在catch语句中使用的。
不能在catch语句中使用，是指catch(T t)是编译不通过的：

public void test(){
try{

}catch(T e){//编译错误

}
}

但是这样使用是可以的：

public void test(){
try{
T t;
}catch(Exception e){
T t;
}
}