泛型about

package com.hu;
import java.util.ArrayList;
import java.util.List;

public class Order<T> {
public String name;
public int OderId;
public T t;

public T getT(){
return t;
}
//定义一个泛型方法
//通过对象调泛型方法是，指明泛型方法的类型
public <E>E getE(E e){
return e;
}
public void setT(T t){
this.t=t;
}

List<T> list=new ArrayList<T>();
public void addList(){
list.add(t);
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getOderId() {
return OderId;
}
public void setOderId(int oderId) {
OderId = oderId;
}
@Override
public String toString() {
return "Order [name=" + name + ", OderId=" + OderId + ", t=" + t + "]";
}


}
class Suboedr extends Order<Integer>{
//指定了继承的类型使用那种类型
}
class suborder<T> extends Order<T>{
//在实例化的时候指定泛型类
}

**************************************************************

package com.hu;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

public class Generic {

@Test
public void test() {
List<Integer> list=new ArrayList<Integer>();
list.add(87);
list.add(97);
list.add(23);
list.add(4535);

Map<String, Integer> map=new HashMap<String,Integer>();
map.put("aa", 87);
map.put("bb", 97);
map.put("xoam", 12);

Set<Map.Entry<String, Integer>> set=map.entrySet();
for(Map.Entry<String, Integer> o:set){
System.out.println(o+".."+o.getKey()+"---"+o.getValue());
}
}
//自定义泛型类的使用
@Test
public void test4(){
Order order=new Order();
Object object=order.getClass();//因为没有使用泛型只能用object类型来接收

//当实例化泛型类的对象的时候需指明泛型的类型
//指明以后对应的类中所有使用泛型的地方，都变为实例化中指定的泛型类型
//如果我们在定义的时候指定了泛型类，但是实例化的时候并没哟用泛型类，这时候默认类型为Object类型
Order<Boolean> order2=new Order<Boolean>();
order2.setT(false);
boolean b=order2.getT();
order2.addList();
List<Boolean> list=order2.list;
System.out.println(b+" ** "+list);
//调用泛型方法
Integer integer=order2.getE(23);
String string=order2.getE("system");
}
@Test
public void test5(){
Suboedr suboedr=new Suboedr();
List<Integer> list=suboedr.list;
System.out.println(list);
}

@Test
public void test6(){
suborder<String> suborder=new suborder<String>();
List<String> list=suborder.list;
list.add("abic");
System.out.println(list);
}
//关于泛型的继承如果A是B的一个子类则　　　List<A> 不是List<b>的一个子接口

/*
* 通配符 ？
* List<A> List<B> 都是List<?>de子类
*/
@Test
public void test7(){
List<?> list=null;
List<Object> list2=new ArrayList<>();
List<String> list3=new ArrayList<>();
list=list2;
list=list3;
}
@Test
public void test8(){
List<String> list=new ArrayList<String>();
list.add("AA");
list.add("bb");
list.add("cc");
List<?> list1=new ArrayList<>();
//list1.add()声明为通配符的集合类中不能写入东西
list1=list;
Iterator<?> iterator=list1.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}