【大数据】学习笔记 1 Java SE 第13章泛型 13.2 泛型类与泛型接口

川长思鸟来 2024-03-22 14:07 82阅读 0赞

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

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

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第13章 泛型
             *   *  13.2 泛型类与泛型接口
                 *   *  13.2.1 使用核心类库中的泛型类/接口
                     *  13.2.2 自定义泛型类与泛型接口
                     *  13.2.3 使用泛型类与泛型接口小结

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

#### 1 Java SE ####

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

###### 13.2 泛型类与泛型接口 ######

###### 13.2.1 使用核心类库中的泛型类/接口 ######

自从JDK1.5引入泛型的概念之后，对之前核心类库中的API做了很大的修改，例如：集合框架集中的相关接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等等。

下面以Collection、ArrayList集合以及Iterator迭代器为例演示，泛型类与泛型接口的使用。

**案例一：Collection集合相关类型**

（1）创建一个Collection集合（暂时创建ArrayList集合对象），并指定泛型为<Integer>

（2）添加5个\[0,100)以内的整数到集合中，

（3）使用foreach遍历输出5个整数，

（4）使用集合的removeIf方法删除偶数，为Predicate接口指定泛型<Ineteger>

（5）再使用Iterator迭代器输出剩下的元素，为Iterator接口指定泛型<Integer>。

package com.dingjiaxiong.genericclass.use;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    import java.util.Random;
    import java.util.function.Predicate;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestNumber
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:24
     */
    
    public class TestNumber {
        
        public static void main(String[] args) {
        
            Collection<Integer> coll = new ArrayList<Integer>();
            Random random = new Random();
            for (int i = 1; i <= 5; i++) {
        
                coll.add(random.nextInt(100));
            }
    
            System.out.println("coll中5个随机数是：");
            for (Integer integer : coll) {
        
                System.out.println(integer);
            }
    
            coll.removeIf(new Predicate<Integer>() {
        
                @Override
                public boolean test(Integer integer) {
        
                    return integer % 2 == 0;
                }
            });
    
            System.out.println("coll中删除偶数后：");
            Iterator<Integer> iterator = coll.iterator();
            while (iterator.hasNext()) {
        
                Integer number = iterator.next();
                System.out.println(number);
            }
    
        }
    }

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

**案例二：Comparable接口**

（1）声明矩形类Rectangle，包含属性长和宽，属性私有化，提供有参构造、get/set方法、重写toString方法，提供求面积和周长的方法。

（2）矩形类Rectangle实现java.lang.Comparable接口，并指定泛型为<Rectangle>，重写int compareTo(T t)方法，按照矩形面积比较大小，面积相等的，按照周长比较大小。

（3）在测试类中，创建Rectangle数组，并创建5个矩形对象

（4）调用Arrays的sort方法，给矩形数组排序，并显示排序前后的结果。

package com.dingjiaxiong.genericclass.use;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Rectangle
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:26
     */
    
    public class Rectangle implements Comparable<Rectangle> {
        
        private double length;
        private double width;
    
        public Rectangle(double length, double width) {
        
            this.length = length;
            this.width = width;
        }
    
        public double getLength() {
        
            return length;
        }
    
        public void setLength(double length) {
        
            this.length = length;
        }
    
        public double getWidth() {
        
            return width;
        }
    
        public void setWidth(double width) {
        
            this.width = width;
        }
    
        public double area() {
        
            return length * width;
        }
    
        public double perimeter() {
        
            return 2 * (length + width);
        }
    
        @Override
        public String toString() {
        
            return "Rectangle{" +
                    "length=" + length +
                    ", width=" + width +
                    ",area =" + area() +
                    ",perimeter = " + perimeter() +
                    '}';
        }
    
        @Override
        public int compareTo(Rectangle o) {
        
            int compare = Double.compare(area(), o.area());
            return compare != 0 ? compare : Double.compare(perimeter(), o.perimeter());
        }
    }

测试类：

package com.dingjiaxiong.genericclass.use;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestRectangle
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:26
     */
    
    public class TestRectangle {
        
        public static void main(String[] args) {
        
            Rectangle[] arr = new Rectangle[4];
            arr[0] = new Rectangle(6, 2);
            arr[1] = new Rectangle(4, 3);
            arr[2] = new Rectangle(13, 1);
            arr[3] = new Rectangle(5, 4);
    
            System.out.println("排序之前：");
            for (Rectangle rectangle : arr) {
        
                System.out.println(rectangle);
            }
    
            Arrays.sort(arr);
    
            System.out.println("排序之后：");
            for (Rectangle rectangle : arr) {
        
                System.out.println(rectangle);
            }
        }
    }

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

###### 13.2.2 自定义泛型类与泛型接口 ######

当我们在类或接口中定义某个成员时，该成员的相关类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定，那么我们可以使用泛型。

*  当某个类/接口的非静态实例变量的类型不确定，需要在创建对象或子类继承时才能确定
 *  当某个（些）类/接口的非静态方法的形参类型不确定，需要在创建对象或子类继承时才能确定

语法格式：

【修饰符】 class 类名<类型变量列表> 【extends 父类】 【implements 父接口们】{
        
        
    }
    【修饰符】 interface 接口名<类型变量列表> 【extends 父接口们】{
        
        
    }

注意：

*  <类型变量列表>：可以是一个或多个类型变量，一般都是使用单个的大写字母表示。例如：<T>、<K,V>等。
 *  <类型变量列表>中的类型变量不能用于静态成员上。

示例代码：

例如：我们要声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，因为，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。

package com.dingjiaxiong.genericclass.define;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Student
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:27
     */
    
    public class Student<T> {
        
        private String name;
        private T score;
    
        public Student() {
        
            super();
        }
    
        public Student(String name, T score) {
        
            super();
            this.name = name;
            this.score = score;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public T getScore() {
        
            return score;
        }
    
        public void setScore(T score) {
        
            this.score = score;
        }
    
        @Override
        public String toString() {
        
            return "姓名：" + name + ", 成绩：" + score;
        }
    }

###### 13.2.3 使用泛型类与泛型接口小结 ######

在使用这种参数化的类与接口时，我们需要指定泛型变量的实际类型参数：

（1）实际类型参数必须是引用数据类型，不能是基本数据类型

（2）子类继承泛型父类时，子接口继承泛型父接口、或实现类实现泛型父接口时，

*  指定类型变量对应的实际类型参数，此时子类或实现类不再是泛型类

package com.dingjiaxiong.genericclass.define;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: ChineseStudent
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 20:28
     */
    
    //ChineseStudent不再是泛型类
    public class ChineseStudent extends Student<String> {
        
    
        public ChineseStudent() {
        
            super();
        }
    
        public ChineseStudent(String name, String score) {
        
            super(name, score);
        }
    
    }

public class Rectangle implements Comparable<Rectangle>

*  指定类型变量（该类型变量可以和原来字母一样，也可以换一个字母），此时子类、子接口、实现类仍然是泛型类或泛型接口

public interface Iterable<T>

public interface Collection<E>extends Iterable<E>

public interface List<E>extends Collection<E>

public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

（3）在创建泛型类的对象时指定类型变量对应的实际类型参数

package com.atguigu.genericclass.define;
    
    public class TestStudent {
        
        public static void main(String[] args) {
        
            //语文老师使用时：
            Student<String> stu1 = new Student<String>("张三", "良好");
            ChineseStudent chineseStudent = new ChineseStudent("张三", "良好");
    
            //数学老师使用时：
            //Student<double> stu2 = new Student<double>("张三", 90.5);//错误，必须是引用数据类型
            Student<Double> stu2 = new Student<Double>("张三", 90.5);
    
            //英语老师使用时：
            Student<Character> stu3 = new Student<Character>("张三", 'C');
    
            //错误的指定
            //Student<Object> stu = new Student<String>();//错误的
        }
    }

> JDK1.7支持简写形式：Student<String> stu1 = new Student<>(“张三”, “良好”);
> 
> 指定泛型实参时，必须左右两边一致，不存在多态现象

[2953f39da94a4752be3b7de1d5b8d485.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b1ebb363377941b7aed239a58f654386.png
[b67a2cedc59e43f9a5133b751328075b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/10bce4f6f68e4e9cba96b549c80acc0a.png
[3d6eb11b3cfe46b7889e1162d2ec338e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/953a94e90c4d43428faf410c3df46b99.png