泛型

1.泛型：参数化类型，即将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（类型形参），在使用/调用时传入具体的类型（类型实参）。    可以使返回结果不用强制转换

2.进一步理解：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

3.分类： 泛型接口  泛型类  泛型方法

泛型接口/泛型类：在接口或类里使用泛型，得在接口名或类名后面加上<T>

class Box<T> {
 
     private T data;
 
     public Box() {
 
     }
 
     public Box(T data) {
         this.data = data;
     }
 
     public T getData() {
         return data;
     }
 
 } 

泛型方法：前提是此方法所在的类/接口没有使用泛型，在方法中使用泛型，得在返回类型前加<T>

json与pojo转化的实例，使用了com.ibm.juno包。

public class JSONUtil {

    /**
     * convert List<Map<String, String>>, POJO to JSON
     * @param <T>
     * 
     * @param <T>
     * @param t
     * @return
     * @throws SerializeException
     */
    public static  <T> String objectToJSON(T t) {
        try {
            return JsonSerializer.DEFAULT.serialize(t);
        } catch (SerializeException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static <T> T jsonToObject(String json, Class<T> clazz) {

        JsonParser jparser = new JsonParser();
        try {
            return jparser.parse(json, clazz);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }
}

4.Class<T> T 

private T product;

private Class<T> product; 

单独的T代表一个类型 而 Class<T>代表这个类型所对应的类

public T find(Class<T> clazz, int id);
根据类来反射生成一个实例，而单独用T没法做到。

T jsonString= JSON.parseObject(String text, Class<T> clazz);
等于
Map jsonString = JSON.parseObject("[21,21,21]", Map.class);
把json字符串转成特定的对象

第一句是demo，把类型也标注出来了，实际使用是下面这个

5.类型通配符

使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

public class Box<T> {
     private T data;
      
          public Box() {
      
          }
      
          public Box(T data) {
              setData(data);
         }
      
          public T getData() {
              return data;
          }
      
          public void setData(T data) {
              this.data = data;
          }

}

public class GenericTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
        
        getData_1(name);
        getData_1(age);
        getData_1(number);
        
        getData_2(name);
        getData_2(age);
        getData_2(number);
    }

    public static <T> void getData(Box<T> data) {
        System.out.println("data :" + data.getData());
    }
    
    public static  void getData_1(Box<?> data) {
        System.out.println("data :" + data.getData());
    }
    
    public static <T> void getData_2(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

}

第二段代码中的三个泛型方法的写法军师正确的，但是只有后面两个是使用的通配符，只有使用通配符的才可以使用类型通配符上限，类型通配符下限

6.类型通配符上限和类型通配符下限

上限：Box<? extends Number>

下限：Box<? super Number>

7.泛型用的最多的是在集合中。

8.java中没有泛型数组一说