java泛型

public class Test <T>{
    T one;

    @Override
    public String toString() {
        return "Test [one=" + one + "]";
    }

    public T getOne() { //返回值可以是List<T>，在内部T就是实际的类型
        return one;
    }

    public void setOne(T one) {
        this.one = one;
    }
    
    public static void main(String[] args) {
        Test<Integer> t1 = new Test<Integer>();
        t1.setOne(123);
        System.out.println(t1);
    }
}

interface Dao <T, K>{
    //T x;    //报错，因为是public static final,泛型不能用static修饰
    T findById(K id);
    List<T> findAll();
}

class MyDao implements Dao<Integer, String>{

    @Override
    public Integer findById(String id) {
        return null;
    }

    @Override
    public List<Integer> findAll() {
        return null;
    }
    
}

interface Dao {
    Integer findById(String id);
    List<Integer> findAll();
}

class MyDao1<T, K, V> implements Dao<T, K>{
    V x;
    
    @Override
    public T findById(K id) {
        return null;
    }
    
    @Override
    public List<T> findAll() {
        return null;
    }
}

public class Generic <T>{
    T value;    //泛型类声明的类型参数，只能声明
    T [] values; 　　//泛型数组的声明，注意只能声明
    public T getValue() {
        System.out.println(value);
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
    
    public <T> void printT(T t) {    //函数自己的类型参数，屏蔽了类的泛型参数
        T x = t;                    //当然，不是泛型类也可以有泛型方法，他俩无关联
        System.out.println(t);
    }
    
    public <E> void setT(E t) {    //函数自己的类型参数E
        this.value = (T) t;        //需要强制转换，不然报错。
    }
    
    public static <E> void sayHi(E name) {
        System.out.println("Hi "+name);
    }
    
    public static void main(String[] args) {
        Generic.<String>sayHi("name");    //静态的泛型方法
        Generic.sayHi("123");
        Generic<Double> one = new Generic<Double>();
        one.<String>setValue(3.5);    //不是泛型方法，非要指定类型，会警告。
        one.<String>getValue();        //也能看出，这个类型指定毫无作用
        one.setValue(3.14);
        one.getValue();        //输出3.14
        one.<Integer>printT(555);    //输出555，说明函数的泛型与类的泛型无关
        one.printT(666);    //直接输入，不指定类型，编译器能够推断出来，
                            //因为一个类型对应一个参数，类型可以由参数确定
                            //泛型类型参数不能是基本类型，所以666被装箱为Integer类型
    }
}

class TestGeneric<T extends Number>{}    //空实现

TestGeneric<Object> objTest = new TestGeneric<Object>();     //报错
TestGeneric<Integer> intTest = new TestGeneric<Number>();    //报错
TestGeneric<Number> numTest = new TestGeneric<Integer>();    //报错

/*声明时*/
class Pen1<T>{}
class Pen2<?>{}        //报错，声明不能使用<?>

class Pen3<T extends Number>{}
class Pen4<? extends Number>{ //报错，不能使用?作为泛型类型，但可以作为限制，像下面这样

@SuppressWarnings("unchecked")    //这是Collections的源码，?可以像下面这样作为限制
public static <T extends Comparable<? super T>> void sort(List<T> list) {
    list.sort(null);
} //泛型T必须实现Comparable接口，并且这个接口中的类型为T或T的父类，声明T，但T要满足?的限制

/*main中使用时*/
Pen1<?> penx = new Pen1<Integer>();
Pen1<? extends Number> peny = new Pen1<Integer>();　//上文中解决父子关系的方法

ArrayList<String> ls = new ArrayList<String>();
ls.add("123");
ls.add("456");
        
List<?> list = ls;　//可以赋值，可以匹配任意类，添加的方法受限
Object get1 = list.get(0); //获取的是一个Object，限制get方法
System.out.println(list.get(0)); //输出调用的是实际内存中对象的方法，所以一定是123
//list.add("123");//报错，限制set方法，The method add(capture#2-of ?) in the type 
//List<capture#2-of ?> is not applicable for the arguments (String)，参数不匹配

//list.add(list.get(0));//同样报错，The method add(capture#2-of ?) in the type 
//List<capture#2-of ?> is not applicable for the arguments (capture#3-of ?)

//定义辅助方法
public static <T> void add1(List<T> list, T str) {  //这样不行
    list.add(list.get(0));
    list.add(str);
}

public static <T> void add2(List<T> list) {　　
    list.add(list.get(0));
}　　　　//方法定义的泛型T，放入了泛型类List<T>中

//调用
add1(list, new String("098"));    //报错
add2(list);    //编译成功，利用泛型函数的参数，保留类型信息

List<? extends Number> list = new ArrayList<Integer>();

class TestGeneric<T extends Abc&Serializable>{}    //空实现，在定义时的限定

class Abc{}

//调用时
TestGeneric<Abc> test = new TestGeneric<Abc>();  //报错，因为Abc没有实现Serizlizable接口

List<Integer> l = new ArrayList<Integer>();
l.add(new Integer(1));
l.add(new Integer(200));
        
List<? extends Number> list = l;    //可以放泛型的子类
System.out.println(list.get(0));
//list.add(new Integer(300));  报错，和<?>一样的原因，参数中有泛型的方法不能使用
Number number = new Integer(300);
//list.add(number);    //即便是Number也报错

List<? super Number> list1 = new ArrayList<Object>();
//List<? super Number> list2 = new ArrayList<Integer>();    //报错Integer不是Number的父类

class A{
    @Override
    public String toString() {
        return "A []";
    }
}
class B extends A {
    @Override
    public String toString() {
        return "B []";
    }
}
class C extends B {
    @Override
    public String toString() {
        return "C []";
    }
}

//调用时
List<? super B> list = new ArrayList<B>();    
//list.add(new A());    //报错
list.add(new B());
list.add(new C());
Object x = list.get(0);    //返回类型为Object