Java泛型

package generic;

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

/*
 泛型的使用
1. jdk5.0新增的特性
2.在集合中使用泛型:
总结:
	集合接口或集合类在jdk5.日时都修改为带泛型的结构。
	在实例化集合类时，可以指明具体的泛型类型
	指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如:方法、构造器)使用到类的泛型的位置，都指定为实例化时的泛型
		比如: add(E e) ---> 实例化以后: add(Integer e)
	注意点:泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换。
	如果实例化时，没有指明泛型的类型。默认类型为java.lang.object类型。
3.自定义泛型结构：泛型类、泛型接口、泛型方法
 */

public class GenericTest {
	public static void main(String[] args) {
		GenericTest genericTest=new GenericTest();
		genericTest.test1();
		genericTest.test2();
		genericTest.test3();
	}
	//在集合中使用泛型之前
	public void test1() {
		ArrayList<Object> list=new ArrayList<Object>();
		list.add(123);
		list.add(123);
		list.add(123);
		//list.add("aaa");
		for(Object score:list) {
			int stuScore=(Integer)score;
			System.out.println(stuScore);
		}
	}
	//在集合中使用泛型
	public void test2() {
		ArrayList<Integer> list=new ArrayList<Integer>();
		list.add(123);
		list.add(123);
		list.add(123);
		//list.add("aaa");
		Iterator<Integer> iterator=list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());	
		}
	}
	public void test3() {
		Map<String, Integer> map=new HashMap<String, Integer>();
		map.put("aaa", 123);
		map.put("bbb", 123);
		map.put("ccc", 123);
		Set<Entry<String, Integer>> entry=map.entrySet();
		Iterator<Entry<String, Integer>> iterator=entry.iterator();
		while (iterator.hasNext()) {
			Map.Entry<String,Integer> entry2 = (Map.Entry<String,Integer>) iterator.next();
			String key= entry2.getKey();
			Integer value=entry2.getValue();
			System.out.println(key+" "+value);
			
		}
	}
}

自定义泛型结构:

package generic;

import java.util.List;

public class GenericTest1 {
	public static void main(String[] args) {
		GenericTest1 g1=new GenericTest1();
		g1.test1();
		g1.test2();
		g1.test3();
	}
	public void test1() {
		//静态方法不能使用类的泛型
		//异常类不能是类的泛型
		//泛型方法可以是静态类
		//如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为bject类型
		/*
		Order order = new Order();
		order. setOrderT(123);
		order . setOrderT("ABC" );
		*/
		//建议实例化指明类的泛型
		Order<String> order = new Order<String>();
		order.setOrderT("ABC" );
	}
	public void test2() {
		//由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
		SubOrder subOrder=new SubOrder();
		subOrder.setOrderT(112);
	}
	//测试泛型方法
	public void test3() {
		Order<String> order=new Order<String>();
		Integer[] arr=new Integer[] {1,2,3,4};
		//泛型方法在调用时，指明泛型参数的类型
		List<Integer> list=order.copyFromArrayToList(arr);
		System.out.println(list);
	}
}

package generic;

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

public class Order<T> {
	String orderName;
	int orderId;
	T orderT;
	public Order() {
		// TODO Auto-generated constructor stub
	}
	public Order(String orderName,int orderId,T orderT) {
		// TODO Auto-generated constructor stub
		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() {
		// TODO Auto-generated method stub
		//return super.toString();
		return orderName+" "+orderId+" "+orderT;
	}
	public <E> List<E> copyFromArrayToList(E[] arr){
		ArrayList<E> list=new ArrayList<E>();
		for (int i = 0; i < arr.length; i++) {
			E e = arr[i];
			list.add(e);
			
		}
		return list;
	}
}

```java
package generic;

public class SubOrder extends Order<Integer>{
	

}

泛型在继承方面的体现：

package generic;

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

public class GenericTest2 {
	/*
	 * 1.泛型在继承方面的体现
	 * 	虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。
	 * 	补充:类A是类B的父类，A<G>是B<G>的父类
	 */
	//通配符 ？
	public static void main(String[] args) {
		GenericTest2 genericTest2=new GenericTest2();
		genericTest2.test1();
	}
	public void test1(){
		List<String> list=new ArrayList<String>();
		list.add("aa");
		//不能添加null之外的数据，允许读取数据
		List<?> list1=null;
		list1=list;
		//list=list1;
		//list1.add()
		Iterator<?> iterator=list1.iterator();
		while (iterator.hasNext()) {
			Object object = (Object) iterator.next();
			System.out.println(object);
			
		}
	}
	@SuppressWarnings({ "unused", "null" })
	public void test2() {
		//有限制条件的通配符
		List<? extends Person> list1=null;
		List<? super Person> list2=null;
		List<Student> list3=null;
		List<Person> list4=null;
		List<Object> list5=null;
		list1=list3;
		list1=list4;
		//list1=list5;
		//list2=list3;
		list2=list4;
		list2=list5;
		Person person=list1.get(0);
		//list1.add(new Person());
		list2.add(new Person());
		list2.add(new Student());
	}
}

package generic;

public class Person {

}

package generic;

public class Student extends Person{

}