/**
 * 父类为泛型类
* @author 尚晓飞
* @date 2014-7-15 下午7:31:25 
* 
* 
* 父类和子类的泛型。
* 【泛型的具体声明】
* （1）子类直接声明具体类型
* （2）使用时指定具体类型（new 对象时）
* （3）子类泛型>=父类泛型（个数，类型，顺序无关）
* 
* 【泛型的确定】
* (1)属性：在父类中，泛型随父类泛型而定
*            子类中，泛型随子类泛型而定
* （2）重写方法中：
*         泛型全部随父类而定
* 【泛型的擦除】
* 父类和子类泛型要么同时擦除。统一object对待
* 子类不能擦除泛型，而父类存在泛型
* 
* 
* @param <T>
 */
public abstract  class Father<T,T1> {
    T name;
    public abstract T test(T t);
}

//子类声明时指定具体类型
//属性类型为具体类型
class Child1 extends Father<String,Integer>{

    @Override//重写方法中，泛型全部随父类而定
    public String test(String t) {
        // TODO Auto-generated method stub
        return null;
    }

    
}

//子类为泛型类.类型在使用时确定（new 对象时）
//子类类型>=父类类型 
class Child2<T1,T,T2> extends Father<T,T1>{
    @Override
    public T test(T t) {
        // TODO Auto-generated method stub
        return null;
    }
}

//子类为泛型类，父类不指定泛型，统一object对待，父类泛型的擦除
//子类和父类同时擦除泛型。
//子类不能单独擦除泛型，而父类不擦除泛型
class Child3<T1,T> extends Father{
    T1 name2;//子类中属性，随子类泛型而定

    @Override
    public Object test(Object t) {
        // TODO Auto-generated method stub
        return null;
    }
        
}

//这是报错的，子类擦除，父类使用泛型。编译通不过。
class Child extends Father<T, T1>{
    
}

public class Student<T> {
    T javase;
    T oracle;
    
    public T addStudent(T t1){
        T sT=t1;
        return sT ;
    }
    
    public Student() {
        super();
    }
    public Student(T javase, T oracle) {
        super();
        this.javase = javase;
        this.oracle = oracle;
    }
    public T getJavase() {
        return javase;
    }
    public void setJavase(T javase) {
        this.javase = javase;
    }
    public T getOracle() {
        return oracle;
    }
    public void setOracle(T oracle) {
        this.oracle = oracle;
    }
    
}

 1 /**
 2  * 泛型的擦除
 3  * 【1】子类继承|实现时不指定泛型
 4  * 【2】使用时不指定泛型
 5  *  统一Object对待，但泛型不是object，编译时不会类型检查
 6  *  编译器会发出警告，但不报错 
 7 * @author 尚晓飞
 8 * @date 2014-7-15 下午8:26:21 
 9 *
10  */
11 public class Test {
12     public static void main(String[] args) {
13         Student stu1=new Student();//如果使用时不确定泛型类型，编译器会发出警告，但不算错；
14         Object sd=stu1.javase;//类型统一用object对待。相当于object，而不是指object
15         
16         Student<Object> stu2=new Student<Object>();
17         
18         test1(stu1);//虽然没确定泛型，以object对待，只是相当于，但不确定。泛型擦除，编译时编译器不会类型检查。所以不报错
19         test1(stu2);//如果泛型指定是Object时，那么传入的实参的泛型必须是Object.此方法报错。泛型一旦确定，哪怕是指定Object,编译器会编译类型检查
20         
21         test2(stu1);
22         test2(stu2);
23         
24     }
25     
26     //方法一
27     public static void  test1(Student<Integer> st){}
28     //方法二
29     public static void test2(Student<?> st){}
30 }