Java泛型03 : 泛型类、泛型方法、泛型接口

最新推荐文章于 2021-09-12 22:51:13 发布

hanchao5272

最新推荐文章于 2021-09-12 22:51:13 发布

阅读量2k

点赞数 2

分类专栏： Java泛型 Java泛型学习实例文章标签： java泛型泛型类泛型方法泛型接口可变参数

本文链接：https://blog.csdn.net/hanchao5272/article/details/79347234

版权

Java泛型学习实例同时被 2 个专栏收录

8 篇文章 9 订阅

订阅专栏

Java泛型

7 篇文章 2 订阅

订阅专栏

超级通道： Java泛型学习系列-绪论

关于泛型类、泛型方法和泛型接口，之前的章节已经或多或少涉及到，本章主要对这三种使用方法进行更为详细的学习。

1.泛型接口

泛型接口的使用较为简单，这里给出一个示例。

假设场景：某个演示程序需要开发一个能够生成演示数据的生成器，可以生成指定数据类型的数据。
示例展示：下面的例子中定义了一个演示数据生成器接口IDemoDataGenerator，并实现了两个类：字符串演示数据生成器StringDDG和用户演示数据生成器UserDDG。

/**
 * 泛型接口示例：实现多继承
 * Created by 韩超 on 2018/2/22.
 */
public class GenericInterfaceDemo {
    private final static Logger LOGGER = Logger.getLogger(GenericInterfaceDemo.class);

    /**
     * <p>Title: 演示数据生成器接口</p>
     * @author 韩超 2018/2/22 14:08
     */
    interface IDemoDataGenerator<T>{
        List<T> generateDemoData();
    }

    /**
     * <p>Title: 字符串类型的演示数据生成器</p>
     * @author 韩超 2018/2/22 14:08
     */
    static class StringDDG implements IDemoDataGenerator<String> {
        @Override
        public List<String> generateDemoData() {
            return Arrays.asList("Hello!","Worker","test","tomorrow");
        }
    }

    static class User{
        private Integer id;
        private String name;

        public User(Integer id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }

    }

    /**
     * <p>Title: 用户 演示数据生成器</p>
     * @author 韩超 2018/2/22 14:11
     */
    static class UserDDG implements IDemoDataGenerator<User>{

        @Override
        public List<User> generateDemoData() {
            return Arrays.asList(new User(1,"张三"),new User(2,"李四"),new User(3,"王五"));
        }
    }

    /**
     * <p>Title: 泛型接口示例</p>
     * @author 韩超 2018/2/22 14:05
     */
    public static void main(String[] args){
        StringDDG stringDDG = new StringDDG();
        LOGGER.info(stringDDG.generateDemoData());

        UserDDG userDDG = new UserDDG();
        LOGGER.info(userDDG.generateDemoData());
    }
}

运行结果：

2018-02-22 14:13:39 INFO  GenericInterfaceDemo:72 - [Hello!, Worker, test, tomorrow]
2018-02-22 14:13:39 INFO  GenericInterfaceDemo:75 - [User{id=1, name='张三'}, User{id=2, name='李四'}, User{id=3, name='王五'}]

泛型接口最典型的应用就是各种类的生成器。

2.泛型类

泛型类的使用方法在之前的章节中已经较多次的涉及，这里不再进行过多解释，只给出示例。

假设场景：自定义一个泛型类，除了记录键值对，还需要记录赋值时间戳
示例展示：下面的例子中定义了一个泛型类MyTimeMap，通过K和V标识键值对，通过T标识时间戳。

/**
 * 泛型类示例
 * Created by 韩超 on 2018/2/22.
 */
public class GenericClassDemo {
    private final static Logger LOGGER = Logger.getLogger(GenericClassDemo.class);

    /**
     * <p>Title: 泛型类示例（键，值，时间）</p>
     * @author 韩超 2018/2/22 14:35
     */
    static class MyTimeMap<K,V,T>{
        private K key;
        private V value;
        private T time;

        @Override
        public String toString() {
            return "MyTimeMap{" +
                    "key=" + key +
                    ", value=" + value +
                    ", time=" + time +
                    '}';
        }

        public MyTimeMap(K key, V value, T time) {
            this.key = key;
            this.value = value;
            this.time = time;
        }
        //setter and getter 
    }

    /**
     * <p>Title: 泛型类示例</p>
     * @author 韩超 2018/2/22 14:26
     */
    public static void main(String[] args) throws InterruptedException {
        List<MyTimeMap<Integer,String,Long>> myContainerList = new ArrayList<MyTimeMap<Integer,String,Long>>();
        myContainerList.add(new MyTimeMap(1,"张三",System.currentTimeMillis()));
        Thread.sleep(500);
        myContainerList.add(new MyTimeMap(2,"李四",System.currentTimeMillis()));
        Thread.sleep(500);
        myContainerList.add(new MyTimeMap(3,"王五",System.currentTimeMillis()));
        LOGGER.info(myContainerList);
    }

运行结果：

2018-02-22 14:43:28 INFO  GenericClassDemo:75 - [MyTimeMap{key=1, value=张三, time=1519281807840}, MyTimeMap{key=2, value=李四, time=1519281808353}, MyTimeMap{key=3, value=王五, time=1519281808855}]

泛型类最典型的应用就是容器类：List、Set、Map等等。

3.泛型方法

泛型方法的使用较为复杂，下面进行介绍。

3.1.泛型类与泛型方法

首先看一个泛型类：

/**
 * <p>Title: 泛型类</p>
 * @author 韩超 2018/2/22 14:56
 */
static class NotGenericMehtod<T>{
    private T t;
    /**
     * <p>Title: 这不是一个泛型方法</p>
     * @author 韩超 2018/2/22 14:56
     */
    void print(T t){
        LOGGER.info(t);
    }
}
public static void main(String[] args){
    //非泛型方示例
    NotGenericMehtod<Integer> notGenericMehtod = new NotGenericMehtod<Integer>();
    notGenericMehtod.print(1);
}

void print(T t)是一个泛型方法吗？答案是否定的。
为什么？
因为在NotGenericMehtod类型实例化的时候，已经指明了此泛型类的具体类型为Integer。所以此对象实际调用方式时，调用的是void print(Integer t)方法。

泛型类和泛型方法最大的区别在于：泛型类是通过实例化确定具体类型，泛型方式通过方法调用确定具体类型。

3.2.泛型方法

泛型方法语法如下

[作用域修饰符] <泛型类型标识> [返回类型] 方法名称(参数列表){}

特别注意：

参数列表中用到的泛型类型，需要在返回类型之前通过<>定义。
泛型方法中的泛型类型与泛型类中的泛型类型没有关系。

下面通过一系列示例，加深对这些概念的理解：

/**
 * 泛型方法示例
 * Created by 韩超 on 2018/2/22.
 */
public class GenericMethodDemo {
    private final static Logger LOGGER = Logger.getLogger(GenericMethodDemo.class);

    /**
     * <p>Title: 泛型类</p>
     * @author 韩超 2018/2/22 14:56
     */
    static class NotGenericMehtod<T>{
        private T t;
        /**
         * <p>Title: 这不是一个泛型方法</p>
         * @author 韩超 2018/2/22 14:56
         */
        void print(T t){
        }
    }

    /**
     * <p>Title: 泛型方法：注意参数列表中的泛型一定要在返回类型之前定义</p>
     * @author 韩超 2018/2/22 15:09
     */
    public static <E> void printList(List<E> list){
        if (null == list || list.size() == 0){
            LOGGER.info("无记录！");
        }else {
            for (E e : list){
                LOGGER.info(e.toString());
            }
        }
    }

    /**
     * <p>Title: 泛型方法：注意参数列表中的泛型一定要在返回类型之前定义，如果不定义，则类型检查不通过 </p>
     * @author 韩超 2018/2/22 15:27
     */
//    public static <T> void printList2(List<E> list){
//        if (null == list || list.size() == 0){
//            LOGGER.info("无记录！");
//        }else {
//            for (E e : list){
//                LOGGER.info(e.toString());
//            }
//        }
//    }

        /**
         * <p>Title: 泛型类+泛型方法</p>
         * @author 韩超 2018/2/22 15:28
         */
    static class GenericMehtod<T>{
        private T t;

            public T getT() {
                return t;
            }

            public void setT(T t) {
                this.t = t;
            }

            /**
         * <p>Title: 这是一个普通方法</p>
         * @author 韩超 2018/2/22 15:32
         */
        void print(T t){
            //这里的t是传递过来的参数，只能是泛型类实例化时指明的泛型类型
            LOGGER.info(t.getClass().toString());
        }

        /**
         * <p>Title: 泛型方法1：泛型类与泛型方法中的泛型并无关系</p>
         * @author 韩超 2018/2/22 15:29
         */
        <T> void out(T t){
            //这里的t是传递过来的参数，与类定义的泛型类型无关系
            LOGGER.info(t.getClass().toString());
        }
        /**
         * <p>Title: 泛型方法2：泛型类与泛型方法中的泛型并无关系</p>
         * @author 韩超 2018/2/22 15:29
         */
        <E> void out2(){
            //这里的t是类中的泛型的实例化对象
            //这个泛型方法没有意义：因为虽然在返回方法之前定义了泛型类型<E>，但是在参数列表中并没有使用这个泛型类型
            LOGGER.info(t.getClass().toString());
        }

        /**
         * <p>Title: 泛型方法3：可变参数</p>
         * @author 韩超 2018/2/22 15:44
         */
        <T> void out3(T... args){
            for (T t : args){
                LOGGER.info(t.getClass().toString() + ":" + t);
            }
        }

    }
    /**
     * <p>Title: 泛型方法示例</p>
     * @author 韩超 2018/2/22 14:55
     */
    public static void main(String[] args){
        //非泛型方示例
        NotGenericMehtod<Integer> notGenericMehtod = new NotGenericMehtod<Integer>();
        notGenericMehtod.print(1);

        LOGGER.info("泛型方法示例：主要参数列表中的泛型一定要在返回类型之前定义");
        //泛型方法示例：主要参数列表中的泛型一定要在返回类型之前定义
        List<User> userList = new ArrayList<User>();
        userList.add(new User(1,"张三"));
        userList.add(new User(2,"李四"));
        ListPrintUtils.printList(userList);

        LOGGER.info("=============================================");
        LOGGER.info("泛型方法示例：泛型类与泛型方法中的泛型并无关系");
        //泛型方法示例：泛型类与泛型方法中的泛型并无关系
        GenericMehtod<Integer> integerGM = new GenericMehtod<Integer>();
        LOGGER.info("---------------------------------------------");
        LOGGER.info("泛型类实例化成Integer，泛型方法却处理的String类型。泛型方法的泛型是在调用时被确定为具体类型的，与泛型类的泛型类型并无关系。");
        integerGM.out("1".toString());

        LOGGER.info("---------------------------------------------");
        LOGGER.info("泛型方法可以调用泛型类的实例化对象");
        integerGM.setT(1);
        integerGM.out2();

        LOGGER.info("---------------------------------------------");
        LOGGER.info("泛型类的普通方法中泛型变量的类型必须与泛型类实例化时指定的泛型变量类类型一致");
        //报错，因为必须与类的泛型类型一致 ，即Integer
        //integerGM.print(2L);
        integerGM.print(new Integer(1));

        LOGGER.info("---------------------------------------------");
        LOGGER.info("泛型方法中可以使用可变泛型参数");
        integerGM.out3(1,2L,3F,"4");
    }
}

运行结果：

2018-02-22 15:46:28 INFO  GenericMethodDemo:119 - 泛型方法示例：主要参数列表中的泛型一定要在返回类型之前定义
2018-02-22 15:46:28 INFO  ListPrintUtils:20 - User{id=1, name='张三'}
2018-02-22 15:46:28 INFO  ListPrintUtils:20 - User{id=2, name='李四'}
2018-02-22 15:46:28 INFO  GenericMethodDemo:126 - =============================================
2018-02-22 15:46:28 INFO  GenericMethodDemo:127 - 泛型方法示例：泛型类与泛型方法中的泛型并无关系
2018-02-22 15:46:28 INFO  GenericMethodDemo:130 - ---------------------------------------------
2018-02-22 15:46:28 INFO  GenericMethodDemo:131 - 泛型类实例化成Integer，泛型方法却处理的String类型。泛型方法的泛型是在调用时被确定为具体类型的，与泛型类的泛型类型并无关系。
2018-02-22 15:46:28 INFO  GenericMethodDemo:87 - class java.lang.String
2018-02-22 15:46:28 INFO  GenericMethodDemo:134 - ---------------------------------------------
2018-02-22 15:46:28 INFO  GenericMethodDemo:135 - 泛型方法可以调用泛型类的实例化对象
2018-02-22 15:46:28 INFO  GenericMethodDemo:96 - class java.lang.Integer
2018-02-22 15:46:28 INFO  GenericMethodDemo:139 - ---------------------------------------------
2018-02-22 15:46:28 INFO  GenericMethodDemo:140 - 泛型类的普通方法中泛型变量的类型必须与泛型类实例化时指定的泛型变量类类型一致
2018-02-22 15:46:28 INFO  GenericMethodDemo:78 - class java.lang.Integer
2018-02-22 15:46:28 INFO  GenericMethodDemo:145 - ---------------------------------------------
2018-02-22 15:46:28 INFO  GenericMethodDemo:146 - 泛型方法中可以使用可变泛型参数
2018-02-22 15:46:28 INFO  GenericMethodDemo:105 - class java.lang.Integer:1
2018-02-22 15:46:28 INFO  GenericMethodDemo:105 - class java.lang.Long:2
2018-02-22 15:46:28 INFO  GenericMethodDemo:105 - class java.lang.Float:3.0
2018-02-22 15:46:28 INFO  GenericMethodDemo:105 - class java.lang.String:4

hanchao5272

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java泛型03 : 泛型类、泛型方法、泛型接口

超级通道： Java泛型学习系列-绪论关于泛型类、泛型方法和泛型接口，之前的章节已经或多或少涉及到，本章主要对这三种使用方法进行更为详细的学习。1.泛型接口泛型接口的使用较为简单，这里给出一个示例。假设场景：某个演示程序需要开发一个能够生成演示数据的生成器，可以生成指定数据类型的数据。示例展示：下面的例子中定义了一个演示数据生成器接口IDemoDataGenerator，并...
复制链接

扫一扫