Java自学笔记：泛型

泛型类：

public class Test2 {
    public static void main(String[] args) {
        //在new A的对象指定泛型的类型String
        A<String> a1 = new A<String>();
        //对象使用setKey(T key)方法，中的key形参就是String
        a1.setKey("张三");
        //T getKey()，返回值就有new对象确定返回值是String
        System.out.println(a1.getKey());
    }
}

class A<T>{
     private T key;
     public void setKey(T key){
         this.key=key;

     }
     public T getKey(){
         return this.key;
     }
}

泛型方法：

public class Test1 {
    public static void main(String[] args) {
        B1<Object> b1= new B1<Object>();
        B1<String> b2= new B1<String>();

        B2 b3 = new B2();
    }
}

interface TB<T>{
    T test(T t);
}
//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class B1<T> implements TB<T>{

    @Override
    public T test(T t) {
        return null;
    }
}
/*
如果实现接口时指定接口的泛型的具体数据类型
这个类实现接口的所有方法的位置都要泛型替换实际的具体数据类型
 */
class B2 implements TB<String>{
    @Override
    public String test(String s) {
        return s;
    }
}

泛型方法：

public class Test3 {
    public static void main(String[] args) {
        Cc<Object> c = new Cc<Object>();
        c.Test1("xxx");
        //泛型方法，在调用之前没有固定的数据类型
        //在调用时，传入的参数是什么类型，就会把泛型改成什么类型
        c.test2(2);
        c.Test1(true);
    }
}

class Cc<E>{
    private E e;
    public static<T> void test4(T t){

        //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法自己定义的泛型
//        System.out.println(this.e);
        //静态方法的泛型方法
          System.out.println(t);
    }
    //无返回值的泛型方法
    public <T> void Test1(T s){
        //在类上定义的泛型，可以在普通的方法中使用
        System.out.println(this.e);
        T t = s;
    }
    //有返回值的泛型方法
    public <T> T test2(T s){
        return s;
    }
    //形参为可变参数的泛型方法
    public <T> void Test3(T... sb){
        for (T s: sb){
            System.out.println(s);
        }
    }
}

泛型通配符：

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

public class Test4 {
    public static void main(String[] args) {
        Dd d = new Dd();
        List<String> C1 = new ArrayList<String>();
        d.test1(C1);
        List<Integer> C2 = new ArrayList<Integer>();
        d.test1(C2);
        List<C1> Lc = new ArrayList<C1>();
        d.test2(Lc);
        List<D1> Ld = new ArrayList<D1>();
        d.test2(Ld);
//        List<B12> Lb = new ArrayList<B12>();
//        d.test2(Lb);

        List<B12> Lb = new ArrayList<B12>();
        d.test3(Lb);
        List<IAImpl> LIA = new ArrayList<IAImpl>();
        d.test4(LIA);
    }


}
class Dd{
    //test1方法需要一个list集合的参数，不确定list集合到底是存的数是什么类型
    public void test1(List<?> list1){
    }
    //list参数的元素数据类型时C1及其子类
    public void test2(List<? extends C1> list2){
    }
    //list参数的元素数据类型时C1及其父类
    public void test3(List<? super C1> list2){
    }
    //list参数的元素数据类型时IA的实现类
    public void test4(List<? extends IA> list2){
    }
}

class A1{}
class B12 extends A1{}
class C1 extends B12{}
class D1 extends C1{}

interface IA{}
class IAImpl implements IA{}