泛型

泛型：标签
在这里插入图片描述

集合接口和集合类在jdk5.0之后都修改为带泛型的结构
在实例化集合类时，可以指明具体的泛型类型
指明完以后，在集合类或者集合接口中凡是定义类或接口时，内部结构使用到泛型的位置，都指定为实例化时的泛型类型
泛型的类型必须是类，不能是基本数据类型，需要用到基本数据类型的位置，用包装类替换
如果实例化时，没有指明泛型的位置，就是Object类型

package Collection;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class ArrayListTest {
	// 使用泛型
	@Test
	public void test(){
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(12);
		list.add(25);
		list.add(33);
		//list.add("AA");//报错，不让你进来了，保证数据的安全
		// 方式一
//		for(Integer scores : list){
//			int stuScore = scores;//不用强转了
//			System.out.println(stuScore);
//		}
	
		// 方式二
		Iterator<Integer> iterator = list.iterator();
		while(iterator.hasNext()){
			int scores = iterator.next();
			System.out.println(scores);
		}
		
	}
	
	//在集合中使用泛型
	@Test
	public void test2(){
		Map<String,Integer> map = new HashMap<String,Integer>();
		
		map.put("tom", 123);
		map.put("am", 52);
		map.put("sd", 13);
		map.put("twd", 173);
		
		// 泛型的嵌套
		Set<Map.Entry<String,Integer>> entry = map.entrySet();
		System.out.println(entry);
		Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
		while(iterator.hasNext()){
			Map.Entry<String, Integer> e = iterator.next();
			String key = e.getKey();
			Integer value = e.getValue();
			System.out.println(key + "----------" + value);
		}
		
		
	}

}

自定义泛型结构：泛型类，泛型接口，泛型方法

一个自定义Order类

package File;

// 自定义泛型类
public class Order<T> {
	
	String orderName;
	int orderId;
	
	// 类的内部结构就可以使用类的泛型
	T orderT;
	public Order(){}
	
	public Order(String orderName,int orderId,T orderT){
		this.orderName = orderName;
		this.orderId = orderId;
		this.orderT = orderT;
	}
	
	public T getOrderT(){
		return orderT;
	}
	
	public void setOrderT(T orderT){
		this.orderT = orderT;
	}

	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId + ", orderT=" + orderT + "]";
	}
	
	
}

在相同包下测试

package File;

import org.junit.Test;

public class GenericTest1 {
	
	@Test
	public void test1(){
		//Order order = new Order();  //没有指明类的泛型，则此泛型类型为Object
		// 建议写上,这样第三个参数就是String类型
		Order<String> order1 = new Order<String>("OrderAA",123,"string");
		
		
		
	}

}

子类在继承带泛型的父类时，指明了泛型类型，则实例化对象时，不再需要指明泛型

需要注意的点

在这里插入图片描述

泛型方法是在方法中出现了泛型的结构，泛型的参数与类的泛型参数没有任何关系。即泛型方法所属的类是不是泛型类无关

泛型方法，可以声明为静态，因为泛型参数是在调用方法时确定，并非在实例化时确定

泛型在继承关系中的体现

类A是类B的父类，G《A》和 G《B》二者不具备子父类关系，二者是并列关系

List<Object> list1 = null;
List<String> list2 = null;
list1 = list2;//报错

但A《G》是 B《G》的父类

通配符的使用

通配符：？
G《A》和G《B》的共同父类是G《？》

@Test
public void test2(){
	List<Object> list1 = null;
	List<String> list2 = null;
	
	List<?> list3 = null;
	
	list3 = list1;
	list3 = list2;
	
	print(list1);//
	print(list2); //都可以调用了
}

public void print(List<?> list){
	Iterator<?> iterator = list.iterator();
	while(iterator.hasNext()){
		Object obj = iterator.next();
		System.out.println(obj);
	}
	
	}