【大数据】学习笔记 1 Java SE 第13章泛型 13.4 类型变量的上限与泛型的擦除

秒速五厘米 2024-03-22 14:07 68阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第13章 泛型
             *   *  13.4 类型变量的上限与泛型的擦除
                 *   *  13.4.1 类型变量的上限
                     *  13.4.2 泛型擦除

![在这里插入图片描述][766dec8e2ee34665a15291a656ae1741.png_pic_center]

#### 1 Java SE ####

##### 第13章 泛型 #####

###### 13.4 类型变量的上限与泛型的擦除 ######

###### 13.4.1 类型变量的上限 ######

当在声明类型变量时，如果不希望这个类型变量代表任意引用数据类型，而是某个系列的引用数据类型，那么可以设定类型变量的上限。

语法格式：

<类型变量  extends 上限>

如果有多个上限

<类型变量  extends 上限1 & 上限2>

> 如果多个上限中有类有接口，那么只能有一个类，而且必须写在最左边。接口的话，可以多个。
> 
> 如果在声明<类型变量>时没有指定任何上限，默认上限是java.lang.Object。

【1】定义泛型类的类型变量时指定上限

例如：我们要声明一个两个数算术运算的工具类，要求两个数必须是Number数字类型，并且实现Comparable接口。

package com.dingjiaxiong.limmit;
    
    import java.math.BigDecimal;
    import java.math.BigInteger;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: NumberTools
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:34
     */
    
    public class NumberTools<T extends Number & Comparable<T>> {
        
        private T a;
        private T b;
    
        public NumberTools(T a, T b) {
        
            super();
            this.a = a;
            this.b = b;
        }
    
        public T getSum() {
        
            if (a instanceof BigInteger) {
        
                return (T) ((BigInteger) a).add((BigInteger) b);
            } else if (a instanceof BigDecimal) {
        
                return (T) ((BigDecimal) a).add((BigDecimal) b);
            } else if (a instanceof Byte) {
        
                return (T) (Byte.valueOf((byte) ((Byte) a + (Byte) b)));
            } else if (a instanceof Short) {
        
                return (T) (Short.valueOf((short) ((Short) a + (Short) b)));
            } else if (a instanceof Integer) {
        
                return (T) (Integer.valueOf((Integer) a + (Integer) b));
            } else if (a instanceof Long) {
        
                return (T) (Long.valueOf((Long) a + (Long) b));
            } else if (a instanceof Float) {
        
                return (T) (Float.valueOf((Float) a + (Float) b));
            } else if (a instanceof Double) {
        
                return (T) (Double.valueOf((Double) a + (Double) b));
            }
            throw new UnsupportedOperationException("不支持该操作");
        }
    
        public T getSubtract() {
        
            if (a instanceof BigInteger) {
        
                return (T) ((BigInteger) a).subtract((BigInteger) b);
            } else if (a instanceof BigDecimal) {
        
                return (T) ((BigDecimal) a).subtract((BigDecimal) b);
            } else if (a instanceof Byte) {
        
                return (T) (Byte.valueOf((byte) ((Byte) a - (Byte) b)));
            } else if (a instanceof Short) {
        
                return (T) (Short.valueOf((short) ((Short) a - (Short) b)));
            } else if (a instanceof Integer) {
        
                return (T) (Integer.valueOf((Integer) a - (Integer) b));
            } else if (a instanceof Long) {
        
                return (T) (Long.valueOf((Long) a - (Long) b));
            } else if (a instanceof Float) {
        
                return (T) (Float.valueOf((Float) a - (Float) b));
            } else if (a instanceof Double) {
        
                return (T) (Double.valueOf((Double) a - (Double) b));
            }
            throw new UnsupportedOperationException("不支持该操作");
        }
    }

测试类

package com.dingjiaxiong.limmit;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: NumberToolsTest
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:35
     */
    
    public class NumberToolsTest {
        
        public static void main(String[] args) {
        
            NumberTools<Integer> tools = new NumberTools<Integer>(8, 5);
            Integer sum = tools.getSum();
            System.out.println("sum = " + sum);
            Integer subtract = tools.getSubtract();
            System.out.println("subtract = " + subtract);
        }
    }

![在这里插入图片描述][ffad9907833940aaa33c86e3ef6561f0.png_pic_center]

【2】定义泛型方法的类型变量时指定上限

我们编写一个数组工具类，包含可以给任意对象数组进行从小到大排序，调用元素对象的compareTo方法比较元素的大小关系。要求数组的元素类型必须是java.lang.Comparable接口类型。

package com.dingjiaxiong.limmit;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyArrays
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:36
     */
    
    public class MyArrays {
        
        public static <T extends Comparable<T>> void sort(T[] arr) {
        
            for (int i = 1; i < arr.length; i++) {
        
                for (int j = 0; j < arr.length - i; j++) {
        
                    if (arr[j].compareTo(arr[j + 1]) > 0) {
        
                        T temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

测试类：

package com.dingjiaxiong.limmit;
    
    import com.dingjiaxiong.generic.Circle;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyArraysTest
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:36
     */
    
    public class MyArraysTest {
        
        public static void main(String[] args) {
        
            int[] arr = {
        3, 2, 5, 1, 4};
    //		MyArrays.sort(arr);//错误的，因为int[]不是对象数组
    
            String[] strings = {
        "hello", "java", "chai"};
            MyArrays.sort(strings);
            System.out.println(Arrays.toString(strings));
    
            Circle[] circles = {
        new Circle(2.0), new Circle(1.2), new Circle(3.0)};
    //        MyArrays.sort(circles); //编译报错
        }
    }

![在这里插入图片描述][f2298454a8a64d4fb131364a3272da24.png_pic_center]

###### 13.4.2 泛型擦除 ######

当使用参数化类型的类或接口时，如果没有指定泛型，那么会怎么样呢？

会发生泛型擦除，自动按照最左边的第一个上限处理。如果没有指定上限，上限即为Object。

package com.dingjiaxiong.limmit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestErase
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:37
     */
    
    public class TestErase {
        
        public static void main(String[] args) {
        
            NumberTools tools = new NumberTools(8, 5);
            Number sum = tools.getSum();//自动按照Number处理
            System.out.println("sum = " + sum);
            Number subtract = tools.getSubtract();
            System.out.println("subtract = " + subtract);
    
            Collection coll = new ArrayList();
            coll.add("hello");
            coll.add(1);
            for (Object o : coll) {
        //自动按照Object处理
                System.out.println(o);
            }
        }
    }

![在这里插入图片描述][74cfd029a62444b480c705fe23613bcc.png_pic_center]

[766dec8e2ee34665a15291a656ae1741.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b1d3d4949fc3433dbe7b65d5e5e37e71.png
[ffad9907833940aaa33c86e3ef6561f0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/cbe88e3f5a35448e9b7ab2b7824fddb3.png
[f2298454a8a64d4fb131364a3272da24.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6eedc6e57b5944fbb523d593d1afb37a.png
[74cfd029a62444b480c705fe23613bcc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0b5021a908b34a2fb6bd09473eccc164.png