安卓泛型的使用

2023-12-30 19:35:40

文章目录

前言
一、泛型定义的初始化位置
- 1.类
- 2.接口
- 3.方法
二、泛型定义的限制类型（extend）
三、泛型使用时的不确定类型声明（通配符 ' ?'）

前言

我们为什么需要泛型？
在JDK1.5之前是没有泛型的，其实这也并不影响我们的正常功能开发，但是我们需要用到大量的类型强制，运行时一旦强转错误就是导致程序崩溃，那么能不能在编译时就把这些检查做好呢？答案就在泛型中。

所谓“泛型”，就是“宽泛的数据类型”，任意的数据类型。

java中的泛型是语法糖，只存在编译阶段。

泛型最主要的作用就是通过指定参数类型，使编译器可以在编译期间检查程序中是否有类型转换的错误。

一、泛型定义的初始化位置

1.类

定义：


    //1.定义在类中
    static class KeyStore<K, V> {
        private V value;
        private K key;

        public KeyStore(K key, V value) {
            this.key = key;
            this.value = value;
        }


        public K GetKey() {
            return key;
        }

        public <A> ArrayList<A> test(ArrayList<A> parms1) {
            return parms1;
        }

        public <A> A test2(A parms1) {
            return parms1;
        }

    }

使用：


 KeyStore<Integer, String> keyStore = new KeyStore<>(1, "");

2.接口

我们有两种方式来实现这个接口

在定义实现类时不明确类型参数，在创建对象时才明确类型参数
在定义实现类时明确类型参数


    //2.定义在接口中
    interface IKeyStroe<K, V> {
        void printKeyStroe(K key, V value);
    }

    // 2.1 定义实现接口的类时，不确定泛型参数类型，在创建时候才明确
    static class KeyStore1<K, V> implements IKeyStroe<K, V> {

        public KeyStore1(K key, V value) {
        }

        @Override
        public void printKeyStroe(K key, V value) {

        }
    }

    // 2.1 定义实现接口的类时，确定泛型参数类型，可在类定义时候明确
    static class KeyStore2 implements IKeyStroe<Integer, String> {

        public KeyStore2(Integer key, String value) {

        }

        @Override
        public void printKeyStroe(Integer key, String value) {

        }
    }

3.方法

        public <A> ArrayList<A> test(ArrayList<A> parms1) {
            return parms1;
        }

        public <A> A test2(A parms1) {
            return parms1;
        }
        
      public static <K, V> boolean compare(KeyStore<K, V> map1, KeyStore<K, V> map2) {
        return Objects.deepEquals(map1, map2);
    }

二、泛型定义的限制类型（extend）

在类、接口、方法中都可以使用extend关键字限制参数类型
举例：

    //1.定义在类中
    static class KeyStore<K, V extends ArrayList> {
        private V value;
        private K key;

        public KeyStore(K key, V value) {
            this.key = key;
            this.value = value;
        }


        public K GetKey() {
            return key;
        }

        public <A extends Number> ArrayList<A> test(ArrayList<A> parms1) {
            return parms1;
        }

        public <A extends String> A test2(A  parms1) {
            return parms1;
        }

三、泛型使用时的不确定类型声明（通配符 ’ ?’）

我们一般把通配符用在实例化对象时候依然不确定泛型类型上。
我们虽然不确定其具体类型，但是有可能知道其限定条件，因为又
分为有上限的通配符（? extend xxx）有下限的通配符(? super xxx)

        ArrayList<?> test = keyStore.test(new ArrayList<Integer>());
        ArrayList<? extends Number> t1 = keyStore.test(new ArrayList<Integer>());
        ArrayList<? extends Number> t2 = keyStore.test(new ArrayList<Integer>());
        ArrayList<? super Integer>  t3 = keyStore.test(new ArrayList<Number>());
        ArrayList<? super Integer>  t4 = keyStore.test(new ArrayList<Integer>());


  // 通配符
    public static void print1(KeyStore<?, ?> map1) {
        System.out.println(map1.key + ";" + map1.value);
    }

    public static void print2(KeyStore<? extends Number, ?> map1) {
        System.out.println(map1.key + ";" + map1.value);
    }

    public static void print3(KeyStore<? super Number, ?> map1) {
        System.out.println(map1.key + ";" + map1.value);
    }

码农公寓