java之泛型

package collections;

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

public class Test6 {
    static void main(String[] args) {
        A<String> a1 = new A<String>();
        //这里setKey中接受的参数为String类型，因为在实例化的时候声明了String泛型
        a1.setKey("a");
        System.out.println(a1.getKey());
        A<Integer> a2 = new A<Integer>这里setKey中接受的参数为Integer类型，因为在实例化的时候声明了Integer泛型
        a2.setKey(1);
        System.out.println(a2.getKey());
        A a3 = new A();
        假设不指定泛型，那么默认接受为Object
        a3.setKey(1);
        System.out.println(a3.getKey());
        同样的类，指定了不同的泛型，就不能进行相互赋值，比如a1=a2
    }
}
此处的泛型T可以任意取名，一般用T,表示Type
class A<T>{
    private T key;
     setKey(T key){
        this.key = key;
    }
    public T getKey(){
        return this.key;
    }
}

 Test7 {
     main(String[] args) {
        Mm<Integer> mm = new Mm<Integer>();
        mm.test(1);
        这种情况下不能指定泛型
        Mn mn =  Mn();
        mn.test("a");
    }
}
interface M<T>{
    T test(T t);
}
未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需要将泛型的声明也一起加入到类中
class Mm<T> implements M<T>{

    @Override
     T test(T t) {
         TODO Auto-generated method stub
        null;
    }
    
}
传入实参时，则需要都修改成实参
class Mn implements M<String> String test(String t) {
        ;
    }
    
}

 Test8 {
     main(String[] args) {
        P<Object> p = new P<Object>();
        p.test("aa"泛型方法在调用前没有固定的数据类型
        在调用时，传入的参数是什么类型，就会把泛型改成什么类型
        p.test1(1);
        p.test1(trueclass P<E>在类上定义的泛型，可以在普通方法中使用
     E e;
    
    static <T>   test3(T t) {
        在静态方法中不能使用类定义的泛型，如果要使用泛型，只能使用静态方法自己定义的泛型
        System.out.println(t);
    }
    
    无返回值的泛型
    public <T>  test(T t) {
        
    }
    有返回值的泛型
    public <T> T test1(T s) {
        System.out.println(.e);
        return s;
    }
    带有可变参数方法的泛型
     test2(T... args) {
        for(T arg:args) {
            System.out.println(arg);
        }
    }
}

 Test9 {
     main(String[] args) {
        Q q =  Q();
        List<String> list1 = new ArrayList<String>();
        q.test(list1);
        List<Integer> list2 = new ArrayList<Integer>();
        q.test(list2);
    }
}
 Q{
    test里面需要传递一个集合List，但是不知道List里面参数的类型
    void test(List<?> list) {
        
    }
}

 Q();
        List<B1> b1 = new ArrayList<B1>();
        List<C1> c1 = new ArrayList<C1>();
        List<D1> d1 = new ArrayList<D1>q.test1(b1);传入b1会报错
        q.test1(c1);
        q.test1(d1);
        q.test2(d1);传入d1会报错
        List<M1Impl> m1Impl = new ArrayList<M1Impl>();
        q.test3(m1Impl);
        
    }
}
 list) {
        
    }
    参数的元素数据类型为C1及其子类
    void test1(List<? extends C1> list) {}
    参数的元素数据类型为C1及其父类
    void test2(List<? super C1>void test3(List<? extends M1> list) {}
}
 A1{
    
}
class B1 extends A1{}
class C1  B1{} 
class D1  C1{}
interface M1{}
class M1Impl implements M1{}