【Java高级编程】泛型

╰半橙微兮° 2023-10-12 23:14 22阅读 0赞

![在这里插入图片描述][a234d2c12317450abab9be7eb1f9f04a.png_pic_center]  
[【Java核心技术】Java基本语法][Java_Java]  
[【Java核心技术】Java面向对象编程][Java_Java 1]  
[【Java核心技术】Java异常处理][Java_Java 2]  
[【Java高级编程】Java多线程][Java_Java 3]  
[【Java高级编程】Java常用类][Java_Java 4]  
[【Java高级编程】Java枚举类&注解][Java_Java 5]  
[【Java高级编程】Java集合][Java_Java 6]  
[【Java高级编程】Java泛型][Java_Java 7]  
[【Java高级编程】JavaIO流][Java_JavaIO]  
[【Java高级编程】Java网络编程][Java_Java 8]  
[【Java高级编程】Java反射机制][Java_Java 9]  
[【Java高级编程】Java8的新特性][Java_Java8]

#### 泛型 ####

*   *   *  1、为什么要有泛型
         *   *  1.1、泛型的概念
             *  1.2、泛型的引入背景
         *  2、在集合中使用泛型
         *  3、自定义泛型结构
         *  4、泛型在继承上的体现
         *  5、通配符的使用

#### 1、为什么要有泛型 ####

##### 1.1、泛型的概念 #####

*  所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

##### 1.2、泛型的引入背景 #####

*  集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。

#### 2、在集合中使用泛型 ####

*  集合接口或集合类在JDK5.0时都修改为带泛型的结构
 *  在实例化集合类时，可以指明具体的泛型类型
 *  指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型
    
     *  比如：add(E e) —> 实例化以后：add(Integer e)
 *  注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
 *  如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型

#### 3、自定义泛型结构 ####

*  泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
 *  泛型类的构造器如下：public GenericClass()\{\}
 *  实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
 *  泛型不同的引用不能相互赋值
    
     *  尽管在编译时`ArrayList<String>`和`ArrayList<Interger>`是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
 *  泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
 *  如果泛型结构是一个接口或抽象类，则不可以创建泛型类的对象
 *  JDK1.7，泛型的简化操作：`ArrayList<Fruit> flist = new ArrayList<>();`
 *  泛型的指定中不能使用基本数据类型，可以使用包装类替换
 *  在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
 *  异常类不能是泛型的
 *  不能使用`new E[]`。但是可以：`E[] elements = (E[])new Object[capacity];`
 *  父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
    
     *  子类不保留父类的泛型：按需实现
        
         *  没有类型，擦除
         *  具体类型
     *  子类保留父类的泛型：泛型子类
        
         *  全部保留
         *  部分保留

/**
     * 自定义泛型类
     * @param <T>
     */
    public class Order<T> {
        private String orderName;
        private int orderId;
    
        //类的内部结构就可以使用类的泛型
        private T orderT;
    
        public Order() {}
    
        public Order(String orderName, int orderId, T orderT) {
            this.orderName = orderName;
            this.orderId = orderId;
            this.orderT = orderT;
        }
    
        public T getOrderT() {
            return orderT;
        }
    
        public void setOrderT(T orderT) {
            this.orderT = orderT;
        }
    
        // 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
        // 换句话说，泛型方法所属的类是不是泛型类都没有关系
        public <E> List<E> copyFormArrayToList(E[] arr) {
          ArrayList<E> list = new ArrayList<>();
    
          for (E e : arr) {
            list.add(e);
          }
    
          return list;
        } 
        // 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定的。
        public static <E> List<E> copyFormArrayToList1(E[] arr) {}
    }

class Fatherr<T1, T2> {
    
    }
    // 子类不保留父类的泛型
    // 1、没有类型，擦除
    class Son1<A, B> extends Father {
      //等价于 class Son extends Father<Object, Object>
    }
    // 2、具体类型
    class Son2<A, B> extends Father<Ineger, String> {
    
    }
    // 子类保留父类的泛型
    // 1、全部保留
    class Son3<T1, T2, A, B> extends Father<T1, T2> {
    
    }
    // 2、部分保留
    class Son4<T2, A, B> extends Father<T1, T2> {
    
    }

#### 4、泛型在继承上的体现 ####

*  虽然类A是类B的父类，但是`G<A>`和`G<B>`二者不具备子父类关系，二者是并列关系
    
     *  补充：类A是类B的父类，`A<G>`是`B<G>`的父类

#### 5、通配符的使用 ####

*  使用类型通配符：`?`
    
     *  `List<?>`是`List<String>`、`List<Object>`等各种泛型List的父类
 *  读取`List<?>`的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object
 *  写入list中的元素时，不行。因为我们不知道元素类型，不能向其中添加对象。
    
     *  唯一的例外是null，它是所有类型的成员

@Test
    public void test() {
        List<?> list = null;
        List<String> list1 = new ArrayList<>();
        list1.add("AA");
        list1.add("BB");
        list1.add("CC");
        print(list1);
        
        list = list1;
        // 添加：对于List<?>不能向其内部添加数据
        // list.add("AA");
        // list.add("?");
        // 除了添加null
        list.add(null);
        //获取（读取）：允许读取数据，读取的数据类型为Object
        Object o = list.get(0);
        System.out.println(o);
    }
    
    public void print(List<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

*  `<? extentds A>` (无穷小, A\]
    
     *  只允许泛型为A及A子类的引用调用
 *  `<? super A>` \[A, 无穷大)
    
     *  只允许泛型为A及A父类的引用调用

[a234d2c12317450abab9be7eb1f9f04a.png_pic_center]: https://img-blog.csdnimg.cn/a234d2c12317450abab9be7eb1f9f04a.png#pic_center
[Java_Java]: https://jumper.blog.csdn.net/article/details/131418978
[Java_Java 1]: https://jumper.blog.csdn.net/article/details/131425785
[Java_Java 2]: https://jumper.blog.csdn.net/article/details/131428791
[Java_Java 3]: https://jumper.blog.csdn.net/article/details/131436162
[Java_Java 4]: https://jumper.blog.csdn.net/article/details/131443038
[Java_Java 5]: https://jumper.blog.csdn.net/article/details/131443124
[Java_Java 6]: https://jumper.blog.csdn.net/article/details/131443179
[Java_Java 7]: https://jumper.blog.csdn.net/article/details/131443217
[Java_JavaIO]: https://jumper.blog.csdn.net/article/details/131443242
[Java_Java 8]: https://jumper.blog.csdn.net/article/details/131448537
[Java_Java 9]: https://jumper.blog.csdn.net/article/details/131448541
[Java_Java8]: https://jumper.blog.csdn.net/article/details/131448546