public class Test {
    public static void main(String[] args) {
        A a1 = new A();//在new A对象指定泛型的类型String
        a1.setKey("aa");
//        a1.setKey(1);//这个是编译器发现的问题
        System.out.println(a1.getKey());
        
        A a2 = new A();//在new A对象指定泛型的类型Integer
        a2.setKey(5);//对象使用setKey(T key)方法，中的key形参类型就是Integer
        System.out.println(a2.getKey());//T getKey(),返回值就由new对象确定返回值是Integer
        
        //没有定义泛型类型，默认Object,可以存储任何类型
        A a3 = new A();//等同于   A
        a3.setKey("a");//setKey(value)，value的类型已经是Object
        a3.setKey(32);
        a3.setKey(true);
        System.out.println(a3.getKey());//new A对象时就已经确定泛型的类型了
        
        //同样的类，但是在new对象时泛型指定不同的数据类型，这些对象不能互相赋值
//        a1 = a2;//会报错，a1的泛型是String,a2的泛型是Integer
        
    }
}
/**
 * @author leak
 *    泛型类
 *    此次的泛型T可以任意的取名，A,B,V
 *    一般使用T，意为Type
 */
class A{
    private T key;
    // T类型由new对象时指定泛型，如果没有指定泛型，默认Object
    //如果指定了,比如泛型指定String,那么setKet/getKey返回值/形参类型是String
    public void setKey(T key) {
        this.key = key;
    }
    
    public T getKey() {
        return this.key;
    }
}

public class Test2 {
    public static void main(String[] args) {
        //当new对象时指定泛型，泛型类里面的泛型类型也会全部跟着改变
        B1

/**
 * 泛型方法
 * @param args
 */
public class Test3 {
    public static void main(String[] args) {
        Cc

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

public class Test4 {
    public static void main(String[] args) {
        List l1 = new ArrayList();
        Dd d = new Dd();
        d.test(l1);
        
        List l2 = new ArrayList();
        d.test(l2);
        
        List l3 = new ArrayList();
        List l4 = new ArrayList();
        List l5 = new ArrayList();
        //l6的泛型是IA接口
        List l6 = new ArrayList();
        //l7的泛型是IA接口的实现类
        List l7 = new ArrayList();
        
        //test1()方法都是约束了泛型为C及其子类
//        d.test1(l2);//这里会报错，因为test1已经用通配符约束了泛型的类型范围，只能使用C及其子类的泛型
        d.test1(l4);//l4为C类泛型的子类
        d.test1(l3);//C类
        
        //test2()方法约束了泛型为C及其父类
//        d.test2(l4);//这里报错，因为l4的泛型类型不是C类的父类
        d.test2(l3);//这里是C类
        d.test2(l5);//l5的泛型是C类的父类
        
        //test3()方法约束了泛型为：必须是实现了IA接口的实现类/AI接口，泛型指定其他类无效
        d.test3(l6);//l6是IA接口泛型
        d.test3(l7);//l7的泛型是实现IA接口的实现类
//        d.test3(l5);
//        d.test3(l3);l5和l3都会报错，以为这两个集合的泛型都没有实现IA接口，也不是IA接口的泛型
    }
}

class Dd{
    //test方法需要一个list集合的参数，不确定list集合到底是存的类型是什么
    //补充为什么不直接在形参定义List list泛型呢，注意，在方法定义泛型和形参定义泛型是不同的概念
    //如果你只需要定义形参的泛型，就使用通配符？，如果定义泛型方法，就在方法定义泛型
    public void test(List> list) {}
    
    //约束泛型范围为C类及其子类
    public void test1(List extends C> list) {
        System.out.println(list);
    }
    
    //约束泛型范围为C及其父类，也就是形参的泛型范围
    public void test2(List super C>list) {
        System.out.println(list);
    }
    
    //约束接口/实现类 的泛型范围
    public void test3(List extends IA> list) {
        System.out.println(list);
    }
}

class A1{}
class B3 extends A1{}
class C extends B3{}
class D extends C{}

//指定泛型为必须实现接口的实现类或者泛型是接口也行
interface IA{}
class IAimpl implements IA{}