泛型的使用韧桂

泛型的使用

1.泛型的声明 interface List 和 class TestGen<K,V> 其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。常用T表示，是Type的缩写。

2.泛型的实例化：一定要在类名后面指定类型参数的值（类型）。如： List strList = new ArrayList(); Iterator iterator = customers.iterator();

T只能是类，不能用基本数据类型填充。

3.1 对于泛型类（含集合类） 1.对象实例化时不指定泛型，默认为：Object。 2.泛型不同的引用不能相互赋值。 3.加入集合中的对象类型必须与指定的泛型类型一致。 4.静态方法中不能使用类的泛型。 5.如果泛型类是一个接口或抽象类，则不可创建泛型类的对象。 6.不能在catch中使用泛型 7.从泛型类派生子类，泛型类型需具体化

泛型的使用 1.在集合中使用泛型(掌握) 2.自定义泛型类、泛型接口、泛型方法（理解 —>使用） 3.泛型与继承的关系 4.通配符

代码

package fourteen;

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

import org.junit.Test;

/*
 * 泛型的使用
 * 1.在集合中使用泛型(掌握)
 * 2.自定义泛型类、泛型接口、泛型方法（理解 --->使用）
 * 3.泛型与继承的关系
 * 4.通配符
 * 
 */
public class TestGeneric {
	/*
	 * 通配符的使用
	 */
	@Test
	public void test7(){
		List<String> list = new ArrayList<String>();
		list.add("AA");
		list.add("BB");
		List<?> list1 = list;
		//可以读取声明为通配符的集合类的对象
		Iterator<?> iterator = list1.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		//不允许向声明为通配符的集合类中写入对象。唯一例外的是null
//		list1.add("CC");
//		list1.add(123);
		list1.add(null);
	}
	/*
	 * 通配符 ?
	 * List<A>、List<B>、。。。。都是List<?>的子类
	 * 
	 * ? extends A :可以存放A及其子类
	 * ? super A:可以存放A及其父类
	 */
	@Test
	public void test6(){
		List<?> list = null;
		List<Object> list1 = new ArrayList<Object>();
		List<String> list2 = new ArrayList<String>();
		list = list1;
		list = list2;
		
		show(list1);
//		show(list2);
		show1(list1);
		show1(list2);
		
		List<? extends Number> list3 = null;
		List<Integer> list4 = null;
		list3 = list4;
//		list3 = list1;
		List<? super Number> list5 = null;
		list5 = list1;
	}
	
	public void show(List<Object> list){
		
	}
	public void show1(List<?> list){
		
	}
	/*
	 * 泛型与继承的关系:
	 * 若类A是类B的子类，那么List<A>就不是List<B>的子接口
	 */
	@Test
	public void test5(){
		Object obj = null;
		String str = "AA";
		obj = str;
		
		Object[] obj1 = null;
		String[] str1 = new String[]{"AA","BB","CC"};
		obj1 = str1;
		
		List<Object> list = null;
		List<String> list1 = new ArrayList<String>();
//		list = list1;
		//假设list = list1满足
		//list.add(123);
		//String str = list1.get(0);//出现问题，所以假设不满足
	}
	
	//自定义泛型类的使用
	@Test
	public void test4(){
		//1.当实例化泛型类的对象时，指明泛型的类型。
		//指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
		//2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认类型是Object类的
		Order<Boolean> order = new Order<Boolean>();
//		order.getT();
		order.setT(true);
		System.out.println(order.getT());
		order.add();
		List<Boolean> list = order.list;
		System.out.println(list);
		
		SubOrder o = new SubOrder();
		List<Integer> list1 = o.list;
		System.out.println(list1);
		//当通过对象调泛型方法时，指明泛型方法的类型。
		Integer i = order.getE(34);
		Double d = order.getE(2.3);
		
		Integer[] in = new Integer[]{1,2,3};
		List<Integer> list2 = new ArrayList<>();
		List<Integer> list3 = order.fromArrayToList(in, list2);
		System.out.println(list3);
	}

	@Test
	public void test3(){
		Map<String,Integer> map = new HashMap<>();
		map.put("AA", 78);
		map.put("BB", 87);
		map.put("DD", 98);
		
		Set<Map.Entry<String,Integer>> set = map.entrySet();
		for(Map.Entry<String,Integer> o : set){
			System.out.println(o.getKey() + "--->" + o.getValue());
		}
	}
	
	//2.在集合中使用泛型
	@Test
	public void test2(){
		List<Integer> list = new ArrayList<Integer>();//<>只能填类，后一个可省略
		list.add(78);
		list.add(87);
//		list.add("AA");
		
//		for(int i = 0;i < list.size();i++){
//			int score = list.get(i);
//			System.out.println(score);
//		}
		Iterator<Integer> it = list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
	
	//1.在集合中没有使用泛型的情况下
	@Test
	public void test1(){
		List list = new ArrayList();
		list.add(89);
		list.add(87);
		list.add(67);
		//1.没有使用泛型，任何Object及其子类的对象都可以添加进来
		list.add(new String("AA"));
		
		for(int i = 0;i < list.size();i++){
			//2.强转为int型时，可能报ClassCastException的异常
			int score = (Integer)list.get(i);
			System.out.println(score);
		}
	}
}

代码

package fourteen;

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

//自定义泛型类
public class Order<T> {
	private String orderName;
	private int orderId;
	private T t;
	List<T> list = new ArrayList<>();
	
	public void add(){
		list.add(t);
	}
	public  T getT(){
		return t;
	}
	public void setT(T t){
		this.t = t;
	}
	//不可以在static方法中使用泛型的声明
//	public static void show(){
//		System.out.println(t);
//	}
	public void info(){
		//不可以在try-catch中使用类的泛型的声明
//		try{
//			
//		}catch(T e){
//			
//		}
	}
	//声明泛型方法
	public static <E> E getE(E e){
		return e;
	}
	//实现数组到集合的复制
	public <E> List<E> fromArrayToList(E[] e,List<E> list){
		for(E e1 : e){
			list.add(e1);
		}
		return list;
	}
	
	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;
	}
	@Override
	public String toString() {
		return "Order [orderName=" + orderName + ", orderId=" + orderId
				+ ", t=" + t + "]";
	}
}
//继承泛型类或泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer>{
	
}

二、自定义泛型类代码一：

package fourteen;

import java.util.List;

//DAO:database access object 数据库访问对象
public class DAO<T> {//具有通用性
	public void add(T t){
		//....
	}
	public T get(int index){
		return null;
	}
	public List<T> getForList(int index){
		return null;
	}
	public void delete(int index){
		
	}
}

代码二：

package fourteen;

public class TestCustomerDAO {
	public static void main(String[] args) {
		CustomerDAO c = new CustomerDAO();
		c.add(new Customer());
		c.get(0);
	}
}

代码三：

package fourteen;

public class CustomerDAO extends DAO<Customer>{//T 变为Customer

}

代码四：

package fourteen;

public class TestCustomerDAO {
	public static void main(String[] args) {
		CustomerDAO c = new CustomerDAO();
		c.add(new Customer());
		c.get(0);
	}
}

代码五：

package fourteen;

public class Student {

}

代码六：

package fourteen;

public class ExamStudentDAO extends DAO<Student>{

}