zoukankan      html  css  js  c++  java
  • 泛型

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

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

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

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

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

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

     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>

    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 

    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 }
    View Code

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

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

    上限:Box<? extends Number>

    下限:Box<? super Number>

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

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

  • 相关阅读:
    assert函数(python)
    局域网内计算机访问FTP服务器时,提示“无法访问服务器名称或地址
    Win10更新故障修复之路!
    对每个人都有用的人生哲理,值得一看!
    如何定制属于自己的个性化win7主题?
    快来看看我的刷机历程,你有同样的经历么?
    今儿个一起来看看安装系统时关于BIOS的那些事儿
    你是如何在DOS中查看这个电脑的硬盘分区的呢?
    这里有搭建本地服务器的方法合集,一起来看一下吧!
    Windows下快速搭建NodeJS本地服务器
  • 原文地址:https://www.cnblogs.com/dobestself-994395/p/4711322.html
Copyright © 2011-2022 走看看