泛型类的定义格式：
修饰符class类名<代表泛型的变量>{ }
简单的泛型类：
    
@param <T> 这里解释下<T>中的T：
    此处的T可以随便写为任意标识，常见的有T、E等形式的参数表示泛型
    泛型在定义的时候不具体，使用的时候才变得具体
    在使用的时候确定泛型的具体数据类型，即在创建对象的时候确定泛型
public class GenericsClassDemo<T>{
    //t这个成员变量的类型为T，T的类型由外部指定
    private T t;
    
    //泛型构造方法形参t的类型也为T，T的类型由外部指定
    public GenericsClassDemo(T t){
        this.t = t;
    }
    
    //泛型方法getT的返回值类型为T，T的类型由外部指定
    public T getT(){
        return t;
    }
}
泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。即：在创建对象的时候确定泛型
例如：Generic<String> genericString = new Generic<String>("helloGenerics");

定义格式：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

例如：
/**
*
* @param t 传入泛型的参数
* @param <T> 泛型的类型
* @return T 返回值为T类型
* 说明：
*	1)public与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
*	2)只有声明了<T>的方法次才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
*	3)<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
*	4)与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
*/
public <T> T genercMethod(T t){
    System.out.println(t.getClass());
    System.out.println(t);
    return t;
}
泛型方法随着我们的传入参数类型不同，他得到的类型也不同。泛型方法能使方法独立于类而产生变化。

定义格式
修饰符interface接口名<代表泛型的变量>{}
//定义一个泛型接口
public interface GenericsInterface<T>{
    public abstract void add(T t);
}

1、定义类时确定泛型的类型
public class GenericsImp implements GenericsInterface<String>{
    @Override
    public void add(String s){
        System.out,println("设置了泛型为String类型");
    }
} 
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class GenericsImp<T> implements GenericsInterface<T>{
    @Override
    public void add(T t){
        System.out.println("没有设置类型");
    }
}
确定泛型：
public class GenericsTest{
    public static void main(String[] args){
        GenericsImp<Integer> gi = new GenericsImp<>();
        gi.add(66)
    }
}

//example
//泛型通配符？：左边<?>,右边泛型可以是任意类型
ArrayList<?> list1 = new ArrayList<Object>();
ArrayList<?> list2 = new ArrayList<String>();
ArrayList<?> list3 = new ArrayList<Integer>();

public static void test(ArrayList<?> coll){
}

class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

//泛型的上限<? extends 类>：
//ArrayList<? extends Animal> list = new ArrayList<Object>();//报错
 ArrayList<? extends Animal> list2 = new ArrayList<Animal>();
 ArrayList<? extends Animal> list3 = new ArrayList<Dog>();
 ArrayList<? extends Animal> list4 = new ArrayList<Cat>();
可以看出，泛型的上限只能是该类型的类型及其子类。

//泛型的下限<? super 类 >：
 ArrayList<? super Animal> list5 = new ArrayList<Object>();
 ArrayList<? super Animal> list6 = new ArrayList<Animal>();
//        ArrayList<? super Animal> list7 = new ArrayList<Dog>();//报错
//        ArrayList<? super Animal> list8 = new ArrayList<Cat>();//报错
可以看出，泛型的下限只能是该类型的类型及其父类。