泛型

時間 2019-11-13

原文原文鏈接

1.泛型：參數化類型，即將類型由原來的具體的類型參數化，相似於方法中的變量參數，此時類型也定義成參數形式（類型形參），在使用/調用時傳入具體的類型（類型實參）。可使返回結果不用強制轉換java

2.進一步理解：泛型類型在邏輯上看以當作是多個不一樣的類型，實際上都是相同的基本類型。json

在使用泛型類時，雖然傳入了不一樣的泛型實參，但並無真正意義上生成不一樣的類型，傳入不一樣泛型實參的泛型類在內存上只有一個，即仍是原來的最基本的類型（本實例中爲Box），固然，在邏輯上咱們能夠理解成多個不一樣的泛型類型。數組

究其緣由，在於Java中的泛型這一律念提出的目的，致使其只是做用於代碼編譯階段，在編譯過程當中，對於正確檢驗泛型結果後，會將泛型的相關信息擦出，也就是說，成功編譯事後的class文件中是不包含任何泛型信息的。泛型信息不會進入到運行時階段。ide

3.分類：泛型接口泛型類泛型方法this

泛型接口/泛型類：在接口或類裏使用泛型，得在接口名或類名後面加上<T>spa

 1 class Box<T> {
 2  
 3      private T data;
 4  
 5      public Box() {
 6  
 7      }
 8  
 9      public Box(T data) {
10          this.data = data;
11      }
12  
13      public T getData() {
14          return data;
15      }
16  
17  }

View Code

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

json與pojo轉化的實例，使用了com.ibm.juno包。對象

 1 public class JSONUtil {
 2 
 3     /**
 4      * convert List<Map<String, String>>, POJO to JSON
 5      * @param <T>
 6      * 
 7      * @param <T>
 8      * @param t
 9      * @return
10      * @throws SerializeException
11      */
12     public static  <T> String objectToJSON(T t) {
13         try {
14             return JsonSerializer.DEFAULT.serialize(t);
15         } catch (SerializeException e) {
16             e.printStackTrace();
17             return null;
18         }
19     }
20 
21     public static <T> T jsonToObject(String json, Class<T> clazz) {
22 
23         JsonParser jparser = new JsonParser();
24         try {
25             return jparser.parse(json, clazz);
26         } catch (ParseException e) {
27             e.printStackTrace();
28             return null;
29         }
30     }
31 }

View Code

4.Class<T> T blog

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<具體類型實參>的父類。由此，咱們依然能夠定義泛型方法，來完成此類需求。

 1 public class Box<T> {
 2      private T data;
 3       
 4           public Box() {
 5       
 6           }
 7       
 8           public Box(T data) {
 9               setData(data);
10          }
11       
12           public T getData() {
13               return data;
14           }
15       
16           public void setData(T data) {
17               this.data = data;
18           }
19 
20 }

View Code

 1 public class GenericTest {
 2 
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) {
 7 
 8         Box<String> name = new Box<String>("corn");
 9         Box<Integer> age = new Box<Integer>(712);
10         Box<Number> number = new Box<Number>(314);
11 
12         getData(name);
13         getData(age);
14         getData(number);
15         
16         getData_1(name);
17         getData_1(age);
18         getData_1(number);
19         
20         getData_2(name);
21         getData_2(age);
22         getData_2(number);
23     }
24 
25     public static <T> void getData(Box<T> data) {
26         System.out.println("data :" + data.getData());
27     }
28     
29     public static  void getData_1(Box<?> data) {
30         System.out.println("data :" + data.getData());
31     }
32     
33     public static <T> void getData_2(Box<?> data) {
34         System.out.println("data :" + data.getData());
35     }
36 
37 }