JavaSE-泛型

package com.btp.t4;

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.Map.Entry;
import java.util.Set;

import org.junit.Test;
/*
 * 泛型的使用
 * 1.在集合中使用泛型
 * 2.自定义泛型类，泛型接口，泛型方法
 * 3.泛型与继承的关系
 * 4.通配符
 */
public class TestGeneric {
	//1,在集合中没有使用泛型的情况下
	@Test
	public void test1(){
		List list =new ArrayList();
		list.add(89);
		list.add(67);
		list.add(87);
		//没有使用泛型，任何Object及其子类对象都能添加进来
		list.add(new String("xiaoming"));
		
		for(Object obj:list)
		{
			//2.强转为int型时，可能报ClassCastException的异常
			int Score=(Integer)obj;
			System.out.println(Score);
		}
	}
	
	
	//在集合中使用泛型
	@Test
	public void test2(){
		List<Integer> list =new ArrayList<Integer>();//只能添加Integer类型的对象
		list.add(89);
		list.add(67);
		list.add(87);
		//list.add(new String("xiaoming"));//添加不进来
		Iterator<Integer> it=list.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	
	//Map使用泛型
	@Test
	public void test3(){
		Map<String,Integer> map=new HashMap<String,Integer>();
		map.put("kobe", 100);
		map.put("kobe1", 100);
		map.put("kobe2", 100);
		map.put("kobe3", 100);
		Set<Entry<String, Integer>> set=map.entrySet();//泛型可以嵌套，Entry是Map中的一个内部类
		for(Entry<String, Integer> o:set){
			System.out.println(o.getKey()+"--->"+o.getValue());
		}
	}
	
	
	//自定义泛型类的使用
	@Test
	public void test4(){
		//1.当实例化泛型类的对象时，指明泛型的类型
		//指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
		//2.如果我们自定义了泛型类。但在实例化时没有使用，那么默认类型是Object类型
		Order<Boolean> order=new Order<>();
		order.setT(true);
		order.add();
		System.out.println(order.getT());
		List<Boolean> list=order.list;
		System.out.println(list);
		
		System.out.println();
		
		SubOrder o=new SubOrder();
		List<Integer> list1=o.list;
		System.out.println(list1);
		
		System.out.println();
		
		//当通过对象调用泛型方法时，指明泛型方法的类型
		Integer i=order.getE(34);
		Double d=order.getE(2.3);
		String a=order.getE(new String("kobr"));
		System.out.println(a);
		
		System.out.println();
		
		Integer[] in=new Integer[]{1,2,3};
		//List<Integer> llist=new ArrayList<>();
		List<Integer> list3=order.fromArrayToList(in, new ArrayList<Integer>());
		System.out.println(list3);
	}
	
	
	//泛型与继承的关系
	//若类A是类B的子类，那么List<A>就不是List<B>的子接口
	@Test
	public void test5(){
		Object obj=null;
		String str="AA";
		obj=str;//可以赋值。说明String是Object的一个子类
		
		Object[] obj1=null;
		String[] str1=new String[]{"AA","BB","CC"};
		obj1=str1;//
		
		List<Object> list1=null;
		List<String> list2=new ArrayList<String>();
		//list1=list2;//错误：不能从 List<String> 转换为 List<Object>
		//假设list1=list2;满足,list和list1指向同一个内存
		//list.add(123);
		//String str=list2.get(0);//出现问题，所以假设不满足
	}
	
	/*
	 * 通配符:?
	 * List<A>,List<B>...都是List<?>的子类
	 * 
	 * ? extends A：可以存放A及其子类
	 * ? super A：可以存放A及其父类
	 */
	@Test
	public void test6(){
		List<?> list=null;
		List<Object> list1=new ArrayList<>();
		List<String> list2=new ArrayList<>();
		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;//错误，list1的Object是Number的父类
		List<? super Number> list5=null;
		list5=list1;//可以
		
	}
	/*
	 * 通配符的使用
	 */
	@Test
	public void test7(){
		List<String> list=new ArrayList<>();
		list.add("AA");
		list.add("BB");
		List<?> list1=list;
		//可以读取声明为通配符的集合类的对象
		Iterator<?> it=list1.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		//不允许向声明为通配符的集合类中写入对象，唯一例外的是null
		//list1.add("CC");//错误
		list1.add(null);//null可以存
		
	}
	
	public void show(Collection<Object> coll)//只有Object的可以放
	{}
	
	public void show1(Collection<?> coll)//都可以放
	{}
	
}


//自定义泛型类
class Order<T>{
	private String orderName;
	private int orderId;
	private T t;
	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[] e,List<E> list){
		for(E e1:e)
		{
			list.add(e1);
		}
		return list;
	}
	
	
	
}

//继承泛型类或泛型接口时，可以指明泛型的类型(常用在数据库各种不同的表的处理)
class SubOrder extends Order<Integer>{
	
}

　　

转载于:https://www.cnblogs.com/a842297171/p/5170342.html