Java 인터페이스 사용 사례 분석-java지도 시간-php.cn

Java 인터페이스 사용 사례 분석

Interface

하나의 그림 흐름
Java 인터페이스 사용 사례 분석

인터페이스의 개념과 몇 가지 지식 포인트 요약

Interface(영어: Interface)은 JAVA 프로그래밍의 추상 유형입니다. 언어는 추상 메소드의 모음이며 인터페이스는 일반적으로 인터페이스로 선언됩니다. 클래스는 인터페이스를 상속하여 인터페이스의 추상 메서드를 상속합니다.
인터페이스는 클래스가 아닙니다 인터페이스를 작성하는 방법은 클래스와 매우 유사하지만 서로 다른 개념에 속합니다. 클래스는 개체의 속성과 메서드를 설명합니다. 인터페이스에는 클래스에서 구현할 메서드 가 포함되어 있습니다. 인터페이스를 구현하는 클래스가 추상 클래스가 아닌 한,
그렇지 않은 경우 클래스는 인터페이스의 모든 메서드를 정의해야 합니다 .
인터페이스는 인스턴스화할 수 없지만 구현할 수는 있습니다. 인터페이스를 구현하는 클래스는 인터페이스에 설명된 모든 메서드를 구현해야 하며, 그렇지 않으면 추상 클래스로 선언해야 합니다. 또한 Java에서는 인터페이스 유형을 사용하여 변수를 선언할 수 있습니다. 이 유형은 널 포인터가 될 수도 있고 이 인터페이스를 구현하는 객체에 바인딩될 수도 있습니다. 인터페이스와 클래스의 유사점

인터페이스는 여러 개를 가질 수 있습니다.

인터페이스 파일은 .Java로 끝나는 파일에 저장되며 파일 이름은 인터페이스 이름

바이트 코드를 사용합니다. 인터페이스 파일은 .class

로 끝나는 파일에 저장됩니다. 인터페이스에 해당하는 바이트코드 파일은 패키지 이름과 일치하는 디렉터리 구조에 있어야 합니다

인터페이스와 클래스의 차이점

인터페이스 객체 인스턴스화에는 사용할 수 없습니다

인터페이스에 생성자 메서드가 없습니다

인터페이스의 모든 메서드는 추상 메서드여야 합니다. Java 8 이후에는 default 키워드로 수정된 비추상 메서드를 인터페이스에서 사용할 수 있습니다

인터페이스는 정적 변수와 최종 변수를 제외하고 멤버 변수를 포함할 수 없습니다.

인터페이스가 클래스에 의해 상속된다는 개념은 정확하지 않습니다. 인터페이스는 클래스에 의해 구현되어야 합니다. 다중 상속이 무엇인지 알아보세요

인터페이스의 일부 기능

인터페이스의 모든 메서드는 암시적으로 추상이므로 인터페이스의 메서드는 암시적으로 공용 추상으로 지정됩니다(공용 추상만 가능, 다른 수정자는 오류를 보고합니다.)

인터페이스에는 변수가 포함되어 있지만 인터페이스의 변수는 암시적으로 공용 정적 최종 변수로 지정됩니다(공개만 가능하며 비공개로 수정하면 컴파일 오류가 보고됩니다)

인터페이스의 메소드는 인터페이스에서 구현할 수 없고, 인터페이스의 메소드는 인터페이스를 구현하는 클래스에서만 구현할 수 있습니다.

추상 클래스와 인터페이스의 차이점
JDK1.8 이전에는 다음과 같은 차이점이 있었습니다

추상 클래스의 메서드는 구체적이고 실행 가능합니다. 문, 즉 메서드 본문은 메서드의 특정 기능을 구현할 수 있지만 인터페이스의 메서드는 구현할 수 없습니다(예:

System). .out.println("나는 슈퍼 옥수수입니다!!");

)

Abstract 클래스의 멤버 변수는
다양한 유형
일 수 있지만 인터페이스의 멤버 변수는
public static 유형만 될 수 있습니다. final

인터페이스에는 정적 코드 블록과 정적 메서드 사용(정적 메서드로 수정됨)이 포함될 수 없으며, 추상 클래스는 정적 코드 블록과 정적 메서드를 가질 수 있습니다.
클래스는 하나의 추상 클래스만 상속할 수 있습니다. 하지만 클래스는 여러 인터페이스를 구현할 수 있습니다

여기서 주목해야 할 점은 다음과 같습니다.

JDK1.8 이후에는 인터페이스에 정적 메서드와 메서드 본문이 포함될 수 있으며, 이를 특정 구현 메서드도 포함할 수 있습니다. 메소드는 "기본 메소드"입니다. 이 메소드는 JDK1.9 이후 기본 키워드

로 수정되어 메소드를 비공개로 정의하여 특정 재사용 코드가 메소드를 노출하지 않도록 합니다

추상 클래스의 의미는 다음과 같습니다. 일반적으로 우리는 추상 클래스를 직접 사용하지 않지만, 실수로 추상 클래스를 통해 객체를 생성하면 컴파일러가 시간이 지나면 알려줍니다.

주의 사항: 위 내용을 대략적으로 한 번씩 읽어보시면 이해가 안 되셔도 상관없습니다. 그러면 아래에서 하나씩 설명드리겠습니다. 큰 꿈에서 깨어난 듯한 기분이 들 거예요
실생활에서 인터페이스란 무엇일까요? 노트북의 USB 포트, 전원 소켓 등이 될 수 있습니다.

그런 다음 이러한 인터페이스는 구현 및 사용 표준 측면에서도 다릅니다

컴퓨터의 USB 포트에 플러그를 꽂을 수 있습니다 in: U 디스크, 마우스, 키보드…USB 프로토콜을 준수하는 모든 장치 Java 인터페이스 사용 사례 분석

전원 소켓 잭을 연결할 수 있는 장치: 컴퓨터, TV, 밥솥...사양을 충족하는 모든 장비

위의 예에서 볼 수 있습니다. 인터페이스는 구현 시 공공 행동 표준입니다. 사양 표준을 충족하는 한 보편적으로 사용할 수 있습니다. Java에서 인터페이스는 참조 데이터 유형인 여러 클래스에 대한 공통 사양

문법 규칙

인터페이스의 정의 형식은 기본적으로 클래스 정의 형식과 동일합니다. class 키워드와 인터페이스 키워드는 인터페이스를 정의합니다.

public interface 接口名称{
    //抽象方法
    public abstract void method1();
    //public abstract是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
    
    //注意：在接口中上述的写法都是抽象方法，所以method4这样写代码更整洁}

로그인 후 복사

팁:
인터페이스를 만들 때 일반적으로 인터페이스 이름은 대문자 I(ai로 발음)로 시작합니다.
인터페이스 이름은 일반적으로 형용사 품사가 포함된 단어를 사용합니다.

Alibaba 코딩 표준에 동의한 대로 코드를 깔끔하게 유지하려면 인터페이스의 메서드와 속성에 수정자를 추가하지 마세요.

인터페이스 사용

인터페이스를 직접 인스턴스화하고 사용할 수 없습니다. 이를 구현하려면 클래스가 되어야 하며 인터페이스의 모든 추상화를 구현해야 합니다. 메서드

public class 类名称 implements 接口名称{
    //...}

로그인 후 복사

참고: 하위 클래스와 상위 클래스 간의 상속 관계는 확장되고 클래스와 인터페이스 간의 구현 관계는 구현됩니다.

USB 마우스, USB 키보드 클래스와 노트북의 인터페이스를 사용하여 기능 구현
USB 인터페이스: 기기를 켜고 끄는 기능 포함
노트북 클래스: 켜고 끄는 기능 포함
Mouse 클래스: USB 인터페이스를 구현하고 클릭 기능이 있음
Keyboard 클래스: USB 인터페이스를 구현하고 입력 기능이 있음

//USB接口public interface USB{
    void openDevice();
    void closeDevice();}//鼠标类，实现USB接口public class Mouse implements USB{
    @Override
    public void openDevice(){
        System.out.println("打开鼠标");
    }
    
    @Override
    public void closeDevice(){
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("鼠标点击");
    }}//键盘类，实现USB接口public class KeyBoard implements USB {
    @Override
    public void openDevice(){
        System.out.println("打开键盘");
    }
    
    @Override
    public void closeDevice(){
        System.out.println("关闭键盘");
    }
    
    public void inPut(){
        System.out.println("键盘输入");
    }}//笔记本类：使用USB设备public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
    public void useDevice(USB usb){
        usb.openDevice();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse)usb;
            mouse.click();
        }else if(usb instanceof KeyBoard){
            KeyBoard keyBoard = (KeyBoard)usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }}//测试类：public class TestUSB{
    public static void main(String[] args){
        Computer computer = new Computer();
        computer.powerOn();
   
    //使用鼠标设备
    computer.useDevice(new Mouse());
    
    //使用键盘设备
    computer.useDevice(new KeyBoard());
    
    computer.powerOff();
    }}

로그인 후 복사

출력:
Java 인터페이스 사용 사례 분석

instanceof

위 코드 예시에서, 일부 친구들은 이해하지 못할 수도 있는데, 이전 블로그에서 소개했는데, 다시 설명하겠습니다. Instanceof는 Java에서 예약된 키워드입니다. side는 클래스이고 반환 유형은 Boolean 유형입니다.
구체적인 기능은 왼쪽 개체가 오른쪽 클래스 또는 오른쪽 클래스의 하위 클래스에서 생성된 인스턴스화된 개체인지 테스트하는 것입니다.
그렇다면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

[instanceof 사용에 대한 참고 사항 ] 기존 상속 관계 , 그리고 나서 instanceof 사용이 있습니다(인터페이스 구현 포함)

【instanceof 응용 프로그램 시나리오】 객체의 강제 유형 변환을 사용해야 하는 경우, instanceof를 사용해야 합니다.

인터페이스의 특성

인터페이스 유형은 A 참조 유형이지만 인터페이스의 객체를 직접 새로 만들 수는 없습니다.

public class TestUSB {
    public static void main(String[] args){
        USB usb = new USB();
    }}//编译会出错：USB是抽象的，无法实例化

로그인 후 복사

Java 인터페이스 사용 사례 분석

인터페이스의 모든 메소드는 공개 추상 메소드입니다. 즉, 인터페이스의 메서드는 암시적으로 공개 추상으로 지정됩니다(공개 추상일 뿐이고 다른 수정자는 오류를 보고합니다)

public interface USB {
    //编译出错：此处不允许使用修饰符private
    //或者是java: 缺少方法主体, 或声明抽象
    private void openDevice();
    void closeDevice();
    //不同JDK版本编译器的标准是不一样的，报错也是不一样的}

로그인 후 복사

인터페이스의 메서드는 인터페이스에서 구현할 수 없습니다. 인터페이스를 구현하는 클래스에서만 구현할 수 있습니다

public interface USB {
    void openDevice();
    
    //编译失败：因为接口中的方法默认为抽象方法
    //Error：接口抽象方法不能带有主体}

로그인 후 복사

Java 인터페이스 사용 사례 분석 하지만 여기에 이전 기본값을 추가하면 메소드 본문을 구현할 수 있습니다.

인터페이스에서 메서드를 재정의하는 경우 기본값을 액세스 권한 수정으로 사용할 수 없습니다.

public interface USB {void openDevice();//默认为publicvoid closeDevice();//默认为public}public class Mouse implements USB {
    @Override
    void openDevice(){
        System.out.println("打开鼠标");
    }
    
    //...}//这里编译会报错，重写USB中的openDevice方法时，不能使用默认修饰符

로그인 후 복사

Java 인터페이스 사용 사례 분석 이 인터페이스를 구현하려면 이 인터페이스를 재정의하는 메서드의 액세스 제한 수정자 범위가 다음보다 넓습니다. 인터페이스의 대형

인터페이스는 변수를 포함할 수 있지만 인터페이스의 변수는 컴파일러에 의해 자동 및 암시적으로
public static finalvariables

public interface USB {
    double brand = 3.0;//默认为：final public static修饰
    void openDevice();
    void closeDevice();}public class TestUSB {
    public static void main(String[] args){
        System.out.println(USB.brand);
        //可以直接通过接口名访问，说明变量时静态的
        
        //下面写法会报错 Java：无法为最终变量brand分配值
        USB.brand = 2.0;
        //说明brand具有final属性
    }}

로그인 후 복사

Java 인터페이스 사용 사례 분석

정적으로 지정될 수 없습니다. 인터페이스 Method

public interface USB {
    public USB(){
    
    }//编译失败
    
    {
    
    }//编译失败
    
    void openDevice();
    void closeDevice();}

로그인 후 복사

Java 인터페이스 사용 사례 분석

인터페이스가 클래스는 아니지만 인터페이스가 컴파일된 후 바이트코드 파일의 접미사 형식도 .class
입니다. 인터페이스에 모든 추상 메서드를 구현하는 것이 아니라 클래스를 추상 클래스로 설정해야 합니다
JDK8에서는 인터페이스가 위에서 언급한 기본 메서드를 포함할 수 있다고 규정합니다

다중 인터페이스 구현

Java에는 단일 상속이 있습니다. 클래스 간, 클래스 간만 상위 클래스에서 파생될 수 있습니다. 즉,

Java에서는 다중 상속이 지원되지 않지만, 클래스는 다중 인터페이스를 구현할 수 있습니다. 코드를 사용하여

public class Animal {
    protected String name;
    
    public Animal(String name){
        this.name = name;
    }}

로그인 후 복사

를 시연해 보겠습니다. 그런 다음 "날 수 있는 것", "달릴 수 있는 것" 및 "헤엄칠 수 있는 것"을 나타내는 인터페이스 세트를 작성합니다.

public interface IFlying {
    void fly();}public interface IRunning {
    void run();}public interface ISwimming {
    void swim();}

로그인 후 복사

Java 인터페이스 사용 사례 분석
那么接下来我们创建几个具体的动物类来接受并实现这些接口
比如，猫会跑

public class Cat extends Animal implements IRunning{
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("小猫"+this.name+"正在跑");
    }}

로그인 후 복사

鱼会游泳

public class Fish extends Animal implements ISwimming{
    public Fish(String name){
     super(name);   
    }
    
    @Override
    public void swim() {
        System.out.println("小鱼"+this.name+"正在游泳");
    }}

로그인 후 복사

而青蛙即会跑又会游泳

public class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name){
        super(name);
    }
    
    @Override
    public void run() {
        System.out.println("青蛙"+this.name+"正在跑");
    }

    @Override
    public void swim() {
        System.out.println("青蛙"+this.name+"正在游泳");
    }}

로그인 후 복사

注意：一个类实现多个接口的时候，每个接口中的抽象方法都要去实现，除非类用abstract修饰，为抽象类

提示IDEA中使用ctrl + i 可以快速实现接口

还有一种动物水陆空三栖，它是大白鹅

public class Goose extends Animal implements IRunning,ISwimming,IFlying{
    public Goose(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(this.name+"正在飞");
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"正在漂在水上");
    }}

로그인 후 복사

这段代码展现了Java面向对象编程中最常见的用法：一个类继承了一个父类，然后同时实现多个接口
继承表达的含义是is-a,而接口表达的含义是具有xxx的特性

猫是一种动物，具有会跑的特性
青蛙是一种动物，即能跑也能有用
大白鹅也是一种动物，技能跑，也能游，还能飞

有了接口之后，类的使用者就不需要去关注具体的类的属性是否符合，而只需要关心某个类是否具有某个特性/功能，如果有，就可以实现对应的接口
那么我们现在实现一个走路的方法

public class TestDemo1 {
    public static void walk(IRunning iRunning){
        System.out.println("我带着小伙伴去散步");
        iRunning.run();
    }

    public static void main(String[] args) {
        Cat cat = new Cat("小猫");
        walk(cat);
        
        Frog frog = new Frog("小青蛙");
        walk(frog);
    }}

로그인 후 복사

输出结果
Java 인터페이스 사용 사례 분석
只要是会跑的，带有跑这个属性特征的，都可以接受相应的对象

public class Robot implements IRunning{
    private String name;
    public Robot(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在用轮子跑");
    }

    public static void main(String[] args) {
        Robot robot = new Robot("机器人");
        walk(robot);
    }}

로그인 후 복사

Java 인터페이스 사용 사례 분석

故输出结果为

接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。
即：用接口可以达到多继承的目的
接口可以继承一个接口，达到复用的效果。这里使用extends关键字

interface IRunning {
    void run();}interface ISwimming {
    void swim();}//两栖的动物，即能跑，也能游泳interface IAmphibious extends IRunning ISwimming {}class Frog implements IAmphibious {
    ...}

로그인 후 복사

通过接口继承创建一个新的接口IAmphibious表示“两栖的”。
创建的Frog类就实现了这个两栖的接口

接口之间的继承就相当于把多个接口合并到了一起

接口使用的例子

我们在之前的数组中讲解过给数组排序，那么我们该如何给对象数组排序呢？
首先我们定义一个Student的类，然后重写一下String方法

public class Student {
    private String name;
    private int score;
    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", score=" + score +
                &#39;}&#39;;
    }}

로그인 후 복사

我们再给定一个学生对象数组，根据这个对象数组中的元素进行排序
这里我们按照分数降序排序

public class Student {
    private String name;
    private int score;
    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", score=" + score +
                &#39;}&#39;;
    }

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("A",95),
                new Student("B",96), 
                new Student("C",97),
                new Student("D",98),
        };
    }}

로그인 후 복사

那么按照我们之前的理解，数组中有一个可以供我们使用的sort方法，我们能否直接使用呢？

Arrays.sort(students);System.out.println(students);//运行结果：Exception in thread "main" java.lang.ClassCastException: class ClassArray.Student cannot be cast to class java.lang.Comparable (ClassArray.Student is in unnamed module of loader &#39;app&#39;; java.lang.Comparable is in module java.base of loader &#39;bootstrap&#39;)
	at java.base/java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
	at java.base/java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
	at java.base/java.util.Arrays.sort(Arrays.java:1041)
	at ClassArray.Student.main(Student.java:36)

로그인 후 복사

Java 인터페이스 사용 사례 분석
我们可以看到这里程序报错了，这里的意思是Student并没有实现Comparable的接口
那么这里的sort是进行普通数字的比较，大小关系明确，而我们指定的是两个学生对象的引用变量，这样的大小关系的指定是错误的，我们需要额外去人为规定对象中的比较元素
那么怎么实现呢？

我们可以用Student类实现Comparable接口，并实现其中的compareTo方法

public class Student implements Comparable<Student>{
    private String name;
    private int score;

    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", score=" + score +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Student o) {
        if (this.score>o.score){
            return -1;//      如果当前对象应排在参数对象之前，则返回小于0的数字
        } else if(this.score<o.score){
            return 1;//      如果当前对象应排在参数对象之后，则返回大于0的数字
        } else{
            return 0;//      如果当前对象和参数对象不分先后，则返回0      
        }
        
    }}

로그인 후 복사

那么我们在这里重写了compareTo的方法，自己定义了比较的规则，我们就自己再去写一个sort的方法，去调用这个compareTo方法，真正意义上实现对对象数组的排序
我们使用冒泡排序法

    public static void sort(Comparable[] array){//        这里要注意，虽然接口不能实例化对象，//        但是接口类型的引用变量可以指向它的实现类对象//        这里的实现类对象就是实现了这个接口的对象//        例如Comparable[] comparable = new Student[3];//        所以这里的参数就可以用Comparable[] array来接收
        for (int bound = 0;bound<array.length;bound++){
            for (int cur = array.length-1;cur>bound;cur--){
                if (array[cur-1].compareTo(array[cur])>0){
                    //这里就说明顺序不符合要求，交换两个变量的位置
                    Comparable tmp = array[cur-1];
                    array[cur-1] = array[cur];
                    array[cur] = tmp;
                }
            }
    }}

로그인 후 복사

sort方法写好了，我们写一个main函数来测试一下

    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("A",95),
                new Student("B",91),
                new Student("C",97),
                new Student("D",95),
        };
        System.out.println("sort前："+Arrays.toString(students));
        sort(students);
        System.out.println("sort后："+Arrays.toString(students));
    }

로그인 후 복사

运行结果

E:\develop\Java\jdk-11\bin\java.exe "-javaagent:E:\IDEA\IntelliJ IDEA Community Edition 2021.3.2\lib\idea_rt.jar=65257:E:\IDEA\IntelliJ IDEA Community Edition 2021.3.2\bin" -Dfile.encoding=UTF-8 -classpath E:\JAVAcode\gyljava\Interface\out\production\Interface ClassArray.Studentsort前：[Student{name=&#39;A&#39;, score=95}, Student{name=&#39;B&#39;, score=91}, Student{name=&#39;C&#39;, score=97}, Student{name=&#39;D&#39;, score=95}]sort后：[Student{name=&#39;C&#39;, score=97}, Student{name=&#39;A&#39;, score=95}, Student{name=&#39;D&#39;, score=95}, Student{name=&#39;B&#39;, score=91}]

로그인 후 복사

那么我们如果想要按照名字排序呢？也是可以的

import java.util.Arrays;import java.util.Comparator;/**
 * Created with IntelliJ IDEA.
 * Description: Hello,I would appreciate your comments~
 * User:Gremmie
 * Date: -04-13
 * Destination:利用Comparable的接口实现对 对象数组 选择性排序的功能
 */class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name=&#39;" + name + &#39;\&#39;&#39; +
                ", age=" + age +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }}class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;
    }}class NameComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }}public class TestDemo {

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",19);
        students[1] = new Student("lisi",8);
        students[2] = new Student("abc",78);
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();
        
        
        //这里的方法sort是Array里面自带的，非常方便，
        //只需将我们写好的比较器传过去就好了
        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students,nameComparator);
        System.out.println("排序后："+Arrays.toString(students));
        Comparable<Student>[] studentComparable =students;
    }

    public static void main2(String[] args) {
        /*Student students1 = new Student("zhangsan",19);
        Student students2 = new Student("abc",78);
        if(students2.compareTo(students1) > 0) {
            System.out.println("fafaa");
        }*/


    }
    public static void main1(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",19);
        students[1] = new Student("lisi",8);
        students[2] = new Student("abc",78);
        System.out.println("排序前："+Arrays.toString(students));
        Arrays.sort(students);
        System.out.println("排序后："+Arrays.toString(students));
    }}

로그인 후 복사

Clonable接口以及深拷贝

其作用如其名，是用来进行克隆的，Clonable是个很有用的接口。
Object类中存在一个clone方法，调用这个方法可以创建出一个对象，实现“拷贝”。
但是我们想要合法调用clone方法，就要先实现Clonable接口，
否则就会抛出CloneNotSupportedException异常

/**
 * Created with IntelliJ IDEA.
 * Description: Hello,I would appreciate your comments~
 * User:Gremmie
 * Date: -04-13
 * Destination:利用Clonable的接口实现clone方法，克隆含对象的对象
 */class Money implements Cloneable{
    public double money = 19.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }}class Person implements Cloneable{
    public int id = 1234;
    public Money m = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "id=&#39;" + id + &#39;\&#39;&#39; +
                &#39;}&#39;;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.m = (Money) this.m.clone();
        return tmp;
        //return super.clone();
    }}public class TestDemo {

    public static void main(String[] args) {
        Object o = new Person();

        Object o2 = new Money();


    }

    public static void main1(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("=========================");
        person2.m.money = 99.99;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }}

로그인 후 복사