java泛型

package fanxing;


public class Order<T> {
private String orderName;
private int id;
private T t;
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
//不能在静态方法中使用泛型 ，确实 泛型 是在实例化后，静态方法，不需要实例化对象 
// public static void show(){
// System.out.println(t);
// }

//不能在try_catch上使用类的泛型 声明 
/* public void show(){
try{

}catch(T e){

}
}*/

}

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

package fanxing;


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


import org.junit.Test;


//自定义泛型类的使用
/*
 * 当实例化泛型类的对象时，指明泛型 的类型 ，指明以后，对应 的类中所有使用泛型 的位置 ，都 变为实例化中
 * 指定 的泛型 的类型*/
public class TestOrder {

public void orderTest(){
//未使用泛型 ，获得的T是Object类型的
Order o=new Order();
o.getT();
Order<String> order=new Order<String>();
//使用泛型 ，获得T的类型要是String类型的
order.getT();

SubOrder s0=new SubOrder();
//获得Integer类型
s0.getT();
}

/*泛型与继承 的关系 ,
* 若类A是类B的子类，那么 List<A> 就不是List<B>的子接口
* 通配符？list<A>,List<B>都 是List<?>的子类*/
@Test
public void test1(){
//子类能赋值 给父类
Object obj=null;
String str="AAA";
obj=str;

List<Object> list=null;
List<String> list1=new ArrayList<String>();
//不能将list1赋给list,说明不是父类与子类关系 ,
/*现在 中的实例举例，垃圾（相当于Object）包括可回收垃圾（String）和不可回收垃圾(Integer)，
* 但存放垃圾的垃圾桶（List<Object>）不能算是存放可回收垃圾或者 不可回收垃圾的父类，是并列的存在
* 相当 于该列的List<Object>和List<String>不是父子类关系 ，是并列关系 */
//list=list1;
//可以使用通配符，?,达到赋值 
List<?> listA=null;
listA=list1;

/*? extends A 可以存放A及其子类
* ? Super A 可以存放A及其父类*/
List<? extends Number> list3=null;
List<Integer> list4=null;
list3=list4;
//不能赋值 
//list3=list;
// ? Super A 可以存放A及其父类
List<? super Number> list5=null;
list5=list;

}
//只能传List<Object>型 的
public void show(List<Object> list){

}

//只能传List<String>型 的
public void show1(List<String> list){

}
//要想将两个都 传进去,用通配符List<?>
public void show2(List<?> list){

}

//通配符的使用
@Test
public void test2(){
List<String> list=new ArrayList<String>();
list.add("aa");
list.add("bb");
List<?> list1=null;
list1=list;
//可以读取声明 为通配符的集合类的对象 
Iterator<?> it=list1.iterator();
while(it.hasNext()){
//输出的都 是Object类型的
System.out.println(it.next());
}
//不能向声明为通配符的集合类中写入对象 ,不确实具体类型，所以不能写入
//list1.add("cc");

}


}
//继承泛型 类或泛型 接口时，可以指明泛型 的类型
//class SubOrder<T> extends Order<T>{
//
//}
class SubOrder extends Order<Integer>{

}