【大数据】学习笔记 1 Java SE 第6章面向对象基础(中) 6.5 接口

灰太狼 2024-03-22 11:24 8阅读 0赞

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

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

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第6章 面向对象基础(中)
             *   *  6.5 接口
                 *   *  6.5.1 概述
                     *  6.5.2 定义格式
                     *  6.5.3 接口的使用
                     *  6.5.4 冲突问题
                     *  6.5.5 接口的特点总结
                     *  6.5.6 经典接口介绍

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

#### 1 Java SE ####

##### 第6章 面向对象基础(中) #####

###### 6.5 接口 ######

###### 6.5.1 概述 ######

生活中大家每天都在用USB接口，那么USB接口与我们今天要学习的接口有什么相同点呢？

USB是通用串行总线的英文缩写，是Intel公司开发的总线架构，使得在计算机上添加串行设备（鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等）非常容易。只须将设备插入计算机的USB端口中，系统会自动识别和配置。 有了USB，我们电脑需要提供的各种插槽的口越来越少，而能支持的其他设备的连接却越来越多。

那么我们平时看到的电脑上的USB插口、以及其他设备上的USB插口是什么呢？

其实，不管是电脑上的USB插口，还是其他设备上的USB插口都只是遵循了USB规范的一种具体设备而已。

根据时代发展，USB接口标准经历了一代USB、第二代USB 2.0和第三代USB 3.0 。

USB规格第一次是于1995年，由Intel、IBM、Compaq、Microsoft、NEC、Digital、North Telecom等七家公司组成的USBIF(USB Implement Forum)共同提出，USBIF于1996年1月正式提出USB1.0规格，频宽为1.5Mbps。

USB2.0技术规范是有由Compaq、Hewlett Packard、Intel、Lucent、Microsoft、NEC、Philips共同制定、发布的，规范把外设数据传输速度提高到了480Mbps，被称为USB 2.0的高速(High-speed)版本.

USB 3.0是最新的USB规范，该规范由英特尔等公司发起,USB3.0的最大传输带宽高达5.0Gbps(640MB/s),USB3.0 引入全双工数据传输。5根线路中2根用来发送数据，另2根用来接收数据，还有1根是地线。也就是说，USB 3.0可以同步全速地进行读写操作。

<table> 
 <thead> 
  <tr> 
   <th><strong>USB版本</strong></th> 
   <th><strong>最大传输速率</strong></th> 
   <th><strong>速率称号</strong></th> 
   <th><strong>最大输出电流</strong></th> 
   <th><strong>推出时间</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>USB1.0</td> 
   <td>1.5Mbps(192KB/s)</td> 
   <td>低速(Low-Speed)</td> 
   <td>5V/500mA</td> 
   <td>1996年1月</td> 
  </tr> 
  <tr> 
   <td>USB1.1</td> 
   <td>12Mbps(1.5MB/s)</td> 
   <td>全速(Full-Speed)</td> 
   <td>5V/500mA</td> 
   <td>1998年9月</td> 
  </tr> 
  <tr> 
   <td>USB2.0</td> 
   <td>480Mbps(60MB/s)</td> 
   <td>高速(High-Speed)</td> 
   <td>5V/500mA</td> 
   <td>2000年4月</td> 
  </tr> 
  <tr> 
   <td>USB3.0</td> 
   <td>5Gbps(500MB/s)</td> 
   <td>超高速(Super-Speed)</td> 
   <td>5V/900mA</td> 
   <td>2008年11月</td> 
  </tr> 
  <tr> 
   <td>USB 3.1</td> 
   <td>10Gbps(1280MB/s)</td> 
   <td>超高速+(Super-speed+)</td> 
   <td>20V/5A</td> 
   <td>2013年12月</td> 
  </tr> 
 </tbody> 
</table>

电脑边上提供了USB插槽，这个插槽遵循了USB的规范，只要其他设备也是遵循USB规范的，那么就可以互联，并正常通信。至于这个电脑、以及其他设备是哪个厂家制造的，内部是如何实现的，我们都无需关心。

这种设计是将规范和实现分离，这也正是Java接口的好处。Java的软件系统会有很多模块组成，那么各个模块之间也应该采用这种面相接口的低耦合，为系统提供更好的可扩展性和可维护性。

*  **接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的has-a关系。**
    
     *  例如：你能不能用USB进行连接，或是否具备USB通信功能，就看你是否遵循USB接口规范
     *  例如：Java程序是否能够连接使用某种数据库产品，那么要看该数据库产品有没有实现Java设计的JDBC规范

###### 6.5.2 定义格式 ######

接口的定义，它与定义类方式相似，但是使用 `interface` 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

> 引用数据类型：数组，类，枚举，接口，注解。

【1】接口的声明格式

【修饰符】 interface 接口名{
        
        //接口的成员列表：
        // 公共的静态常量
        // 公共的抽象方法
        // 公共的默认方法（JDK1.8以上）
        // 公共的静态方法（JDK1.8以上）
        // 私有方法（JDK1.9以上）
    }

示例代码：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Usb3
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:42
     */
    
    public interface Usb3 {
        
        //静态常量
        long MAX_SPEED = 500 * 1024 * 1024;//500MB/s
    
        //抽象方法
        void in();
    
        void out();
    
        //默认方法
        default void start() {
        
            System.out.println("开始");
        }
    
        default void stop() {
        
            System.out.println("结束");
        }
    
        //静态方法
        static void show() {
        
            System.out.println("USB 3.0可以同步全速地进行读写操作");
        }
    }

【2】接口的成员说明

接口定义的是多个类共同的公共行为规范，这些行为规范是与外部交流的通道，这就意味着接口里通常是定义一组公共方法。

在JDK8之前，接口中只允许出现：

（1）公共的静态的常量：其中public static final可以省略

（2）公共的抽象的方法：其中public abstract可以省略

> 理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现

在JDK1.8时，接口中允许声明默认方法和静态方法：

（3）公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略

（4）公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略

在JDK1.9时，接口又增加了：

（5）私有方法

除此之外，接口中不能有其他成员，没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化。

###### 6.5.3 接口的使用 ######

【1】使用接口的静态成员

接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量。

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestUsb3
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:44
     */
    
    public class TestUsb3 {
        
        public static void main(String[] args) {
        
            //通过“接口名.”调用接口的静态方法
            Usb3.show();
            //通过“接口名.”直接使用接口的静态常量
            System.out.println(Usb3.MAX_SPEED);
        }
    }

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

【2】类实现接口(implements)

接口**不能创建对象**，但是可以被类实现（`implements` ，类似于被继承）。

类与接口的关系为实现关系，即**类实现接口**，该类可以称为接口的实现类，**也可以称为接口的子类**。

实现的动作类似继承，格式相仿，只是关键字不同，实现使用 `implements`关键字。

【修饰符】 class 实现类  implements 接口{
        
    	// 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      	// 重写接口中默认方法【可选】
    }
    
    【修饰符】 class 实现类 extends 父类 implements 接口{
        
        // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      	// 重写接口中默认方法【可选】
    }

注意：

1.  如果接口的实现类是非抽象类，那么必须重写接口中所有抽象方法。
2.  默认方法可以选择保留，也可以重写。
    
    > 重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了
3.  **接口中的静态方法不能被继承也不能被重写**

示例代码：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MobileHDD
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:45
     */
    
    public class MobileHDD implements Usb3 {
        
        //重写/实现接口的抽象方法，【必选】
        public void out() {
        
            System.out.println("读取数据并发送");
        }
    
        public void in() {
        
            System.out.println("接收数据并写入");
        }
    
        //重写接口的默认方法，【可选】
        //重写默认方法时，default单词去掉
        public void end() {
        
            System.out.println("清理硬盘中的隐藏回收站中的东西，再结束");
        }
    }

【3】使用接口的非静态方法

*  对于接口的静态方法，直接使用“接口名.”进行调用即可
    
     *  也只能使用“接口名."进行调用，不能通过实现类的对象进行调用
 *  对于接口的抽象方法、默认方法，只能通过实现类对象才可以调用
    
     *  接口不能直接创建对象，只能创建实现类的对象

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestMobileHDD
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:46
     */
    
    public class TestMobileHDD {
        
        public static void main(String[] args) {
        
            //创建实现类对象
            MobileHDD b = new MobileHDD();
    
            //通过实现类对象调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就执行重写的默认方法，如果没有重写，就执行接口中的默认方法
            b.start();
            b.in();
            b.stop();
    
            //通过接口名调用接口的静态方法
    //        MobileHDD.show();
    //        b.show();
            Usb3.show();
        }
    }

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

【4】接口的多实现(implements)

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的**多实现**。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

【修饰符】 class 实现类  implements 接口1，接口2，接口3。。。{
        
    	// 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      	// 重写接口中默认方法【可选】
    }
    
    【修饰符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。。。{
        
        // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
      	// 重写接口中默认方法【可选】
    }

> 接口中，有多个抽象方法时，实现类必须重写所有抽象方法。**如果抽象方法有重名的，只需要重写一次**。

定义多个接口：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: A
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:47
     */
    
    public interface A {
        
        void showA();
    
        void show();
    }

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: B
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:48
     */
    
    public interface B extends A {
        
        void showB();
    
        void show();
    }

定义实现类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: C
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:48
     */
    
    public class C implements A, B {
        
        @Override
        public void showA() {
        
            System.out.println("showA");
        }
    
        @Override
        public void showB() {
        
            System.out.println("showB");
        }
    
        @Override
        public void show() {
        
            System.out.println("show");
        }
    }

测试类

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestC
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:48
     */
    
    public class TestC {
        
        public static void main(String[] args) {
        
            C c = new C();
            c.showA();
            c.showB();
            c.show();
        }
    }

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

【5】接口的多继承(extends)

一个接口能继承另一个或者多个接口，接口的继承也使用 `extends` 关键字，子接口继承父接口的方法。

定义父接口：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Chargeable
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:49
     */
    
    public interface Chargeable {
        
        void charge();
    
        void in();
    
        void out();
    }

定义子接口：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: UsbC
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:50
     */
    
    public interface UsbC extends Chargeable, Usb3 {
        
        void reverse();
    }

定义子接口的实现类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TypeCConverter
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:50
     */
    
    public class TypeCConverter implements UsbC {
        
        @Override
        public void reverse() {
        
            System.out.println("正反面都支持");
        }
    
        @Override
        public void charge() {
        
            System.out.println("可充电");
        }
    
        @Override
        public void in() {
        
            System.out.println("接收数据");
        }
    
        @Override
        public void out() {
        
            System.out.println("输出数据");
        }
    }

> 所有父接口的抽象方法都有重写。
> 
> 方法签名相同的抽象方法只需要实现一次。

【6】接口与实现类对象构成多态引用

实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是你new的实现类对象实现的方法体。

接口的不同实现类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Mouse
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:50
     */
    
    public class Mouse implements Usb3 {
        
        @Override
        public void out() {
        
            System.out.println("发送脉冲信号");
        }
    
        @Override
        public void in() {
        
            System.out.println("不接收信号");
        }
    }

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: KeyBoard
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:51
     */
    
    public class KeyBoard implements Usb3 {
        
        @Override
        public void in() {
        
            System.out.println("不接收信号");
        }
    
        @Override
        public void out() {
        
            System.out.println("发送按键信号");
        }
    }

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Computer
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:53
     */
    
    public class Computer {
        
    
        private Usb3 usb3;
    
        public Usb3 getUsb() {
        
            return usb3;
        }
    
        public void setUsb(Usb3 usb3) {
        
            this.usb3 = usb3;
        }
    }

测试类

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestComputer
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:51
     */
    
    public class TestComputer {
        
        public static void main(String[] args) {
        
            Computer computer = new Computer();
            Usb3 usb = new Mouse();
            computer.setUsb(usb);
            usb.start();
            usb.out();
            usb.in();
            usb.stop();
            System.out.println("--------------------------");
    
            usb = new KeyBoard();
            computer.setUsb(usb);
            usb.start();
            usb.out();
            usb.in();
            usb.stop();
            System.out.println("--------------------------");
    
            usb = new MobileHDD();
            computer.setUsb(usb);
            usb.start();
            usb.out();
            usb.in();
            usb.stop();
        }
    }

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

###### 6.5.4 冲突问题 ######

【1】默认方法冲突问题

**（1）亲爹优先原则**

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的抽象方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Friend
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:55
     */
    
    public interface Friend {
        
        default void date() {
        //约会
            System.out.println("吃喝玩乐");
        }
    }

定义父类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Father
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:56
     */
    
    public class Father {
        
        public void date() {
        //约会
            System.out.println("爸爸约吃饭");
        }
    }

定义子类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Son
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:56
     */
    
    public class Son extends Father implements Friend {
        
        @Override
        public void date() {
        
            //(1)不重写默认保留父类的
            //(2)调用父类被重写的
    //        super.date();
            //(3)保留父接口的
    //        Friend.super.date();
            //(4)完全重写
            System.out.println("学Java");
        }
    }

定义测试类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestSon
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:57
     */
    
    public class TestSon {
        
        public static void main(String[] args) {
        
            Son s = new Son();
            s.date();
        }
    }

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

**（2）左右为难**

*  当一个类同时实现了多个父接口，而多个父接口中包含方法签名相同的默认方法时，怎么办呢？

无论你多难抉择，最终都是要做出选择的。

声明接口：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: BoyFriend
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:57
     */
    
    public interface BoyFriend {
        
        default void date() {
        //约会
            System.out.println("神秘约会");
        }
    }

选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法。

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Girl
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:58
     */
    
    public class Girl implements Friend, BoyFriend {
        
    
        @Override
        public void date() {
        
            //(1)保留其中一个父接口的
    //        Friend.super.date();
    //        BoyFriend.super.date();
            //(2)完全重写
            System.out.println("学Java");
        }
    
    }

测试类：

package com.dingjiaxiong.interfacetype;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestGirl
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:58
     */
    
    public class TestGirl {
        
        public static void main(String[] args) {
        
            Girl girl = new Girl();
            girl.date();
        }
    }

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

###### 6.5.5 接口的特点总结 ######

*  接口本身不能创建对象，只能创建接口的实现类对象，接口类型的变量可以与实现类对象构成多态引用。
 *  声明接口用interface，接口的成员声明有限制：（1）公共的静态常量（2）公共的抽象方法（3）公共的默认方法（4）公共的静态方法（5）私有方法（JDK1.9以上）
 *  类可以实现接口，关键字是implements，而且支持多实现。如果实现类不是抽象类，就必须实现接口中所有的抽象方法。如果实现类既要继承父类又要实现父接口，那么继承（extends）在前，实现（implements）在后。
 *  接口可以继承接口，关键字是extends，而且支持多继承。
 *  接口的默认方法可以选择重写或不重写。如果有冲突问题，另行处理。子类重写父接口的默认方法，要去掉default，子接口重写父接口的默认方法，不要去掉default。
 *  接口的静态方法不能被继承，也不能被重写。接口的静态方法只能通过“接口名.静态方法名”进行调用。

###### 6.5.6 经典接口介绍 ######

【1】java.lang.Comparable

我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？

Java给所有引用数据类型的大小比较，指定了一个标准接口，就是java.lang.Comparable接口：

package java.lang;
    
    public interface Comparable{
        
        int compareTo(Object obj);
    }

那么我们想要使得我们某个类的对象可以比较大小，怎么做呢？步骤：

第一步：哪个类的对象要比较大小，哪个类就实现java.lang.Comparable接口，并重写方法

*  方法体就是你要如何比较当前对象和指定的另一个对象的大小

第二步：对象比较大小时，通过对象调用compareTo方法，根据方法的返回值决定谁大谁小。

*  this对象（调用compareTo方法的对象）大于指定对象（传入compareTo()的参数对象）返回正整数
 *  this对象（调用compareTo方法的对象）小于指定对象（传入compareTo()的参数对象）返回负整数
 *  this对象（调用compareTo方法的对象）等于指定对象（传入compareTo()的参数对象）返回零

代码示例：

package com.dingjiaxiong.api;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Student
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 21:00
     */
    
    public class Student implements Comparable {
        
        private int id;
        private String name;
        private int score;
        private int age;
    
        public Student(int id, String name, int score, int age) {
        
            this.id = id;
            this.name = name;
            this.score = score;
            this.age = age;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getScore() {
        
            return score;
        }
    
        public void setScore(int score) {
        
            this.score = score;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", score=" + score +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Object o) {
        
            //这些需要强制，将o对象向下转型为Student类型的变量，才能调用Student类中的属性
            //默认按照学号比较大小
            Student stu = (Student) o;
            return this.id - stu.id;
        }
    }

测试类：

package com.dingjiaxiong.api;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestStudent
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 21:01
     */
    
    public class TestStudent {
        
        public static void main(String[] args) {
        
            Student[] arr = new Student[5];
            arr[0] = new Student(3, "张三", 90, 23);
            arr[1] = new Student(1, "熊大", 100, 22);
            arr[2] = new Student(5, "王五", 75, 25);
            arr[3] = new Student(4, "李四", 85, 24);
            arr[4] = new Student(2, "熊二", 85, 18);
    
            //单独比较两个对象
            System.out.println(arr[0].compareTo(arr[1]));
            System.out.println(arr[1].compareTo(arr[2]));
            System.out.println(arr[2].compareTo(arr[2]));
    
            System.out.println("所有学生：");
            for (int i = 0; i < arr.length; i++) {
        
                System.out.println(arr[i]);
            }
            System.out.println("按照学号排序：");
            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) {
        
                        Student temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < arr.length; i++) {
        
                System.out.println(arr[i]);
            }
        }
    }

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

【2】java.util.Comparator

思考：

（1）如果一个类，没有实现Comparable接口，而这个类你又不方便修改（例如：一些第三方的类，你只有.class文件，没有源文件），那么这样类的对象也要比较大小怎么办？

（2）如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？

JDK在设计类库之初，也考虑到这种情况了，所以又增加了一个java.util.Comparator接口。

package java.util;
    
    public interface Comparator{
        
        int compare(Object o1,Object o2);
    }

那么我们想要比较某个类的两个对象的大小，怎么做呢？步骤：

第一步：编写一个类，我们称之为比较器类型，实现java.util.Comparator接口，并重写方法

*  方法体就是你要如何指定的两个对象的大小

第二步：比较大小时，通过比较器类型的对象调用compare()方法，将要比较大小的两个对象作为compare方法的实参传入，根据方法的返回值决定谁大谁小。

*  o1对象大于o2返回正整数
 *  o1对象小于o2返回负整数
 *  o1对象等于o2返回零

代码示例：定义定制比较器类

package com.dingjiaxiong.api;
    
    import java.util.Comparator;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StudentScoreComparator
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 21:02
     */
    
    public class StudentScoreComparator implements Comparator {
        
        @Override
        public int compare(Object o1, Object o2) {
        
            Student s1 = (Student) o1;
            Student s2 = (Student) o2;
            int result = s1.getScore() - s2.getScore();
            return result != 0 ? result : s1.getId() - s2.getId();
        }
    }

代码示例：测试类

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

[e6d13cd83ff841abbfb0f504a2a8f569.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/abfd3fc6b8174bf8885da96bd610d07c.png
[beaa43b55c8c453a85cf79158ebc68d8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/eb3726ba1a534eb9ae0a12c419235eae.png
[c3efd01e7a93472892f7a640289348ec.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d0afcb14862e4e5fadd4a03fc88f3cae.png
[7b51a74eeb4a409ab0130bf755d64b36.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4175bc90854d41d8a22e29ad9c786d2a.png
[b7185295785a44888440eee628815964.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7d53609528bc40868d5855af4b513993.png
[85470d34966049da87affa6f912c3345.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ba556885ff92488ab8ff99e03ed5a50e.png
[3aa96f532af74c80a746e75a53aef50f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2ce03516f08c47b49db5dd47800511af.png
[933efbcc839e4a27ad95e29888424278.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e656d0bbc0e94892b8837f783cf956ab.png
[d8e46e5a79b2452a88c96af460443daa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d4d0103bfb9e4f71a637b450fec76598.png