零基础Java第十六期：抽象类接口（二）

目录

一、接口（补）

[1.1. 数组对象排序](#1.1. 数组对象排序)

[1.2. 克隆接口](#1.2. 克隆接口)

[1.3. 浅拷贝和深拷贝](#1.3. 浅拷贝和深拷贝)

[1.4. 抽象类和接口的区别](#1.4. 抽象类和接口的区别)

---

一、接口（补）

1.1. 数组对象排序

我们在讲一维数组的时候，使用到冒泡排序来对数组里的元素进行从小到大或从大到小的排序。上一期里面我们通过Comparable接口来比较Student对象里面的成员变量，如果Student对象实例化一个数组，并且数组里面有多个元素，我们也是可以通过冒泡排序来实现。

//定义Student类

public class Student implements Comparable<Student>{
    public int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return o.age - this.age;
    }
}

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void BubbleSort(Comparable[] compare){
        for (int i = 0; i < compare.length-1; i++) {//表示比较的趟数
            for (int j = 0; j < compare.length-1-i; j++) {
                if(compare[j].compareTo(compare[j+1]) > 0){
                    Comparable temp = compare[j];
                    compare[j] = compare[j+1];
                    compare[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        Student[] stu = new Student[3];
        stu[0] = new Student(10);
        stu[1] = new Student(8);
        stu[2] = new Student(11);

        BubbleSort(stu);
        System.out.println(Arrays.toString(stu));
    }
}

以上代码可以参考博主之前的博客，这里就不做过多讲解了。以下为运行结果：

1.2. 克隆接口

public class Person {
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}、

public class Main {
    public static void main(String[] args) {
        Person one = new Person("Paul",17);
        Person two = one.clone();//报错：'clone()' has protected access in 'java.lang.Object'
    }
}

我们如果想把one这个对象克隆到two这个对象，就可以使用clone这个方法，但是会报错，我们可以查看一下源码。双击shift，勾选"include non-project items"，在搜素框里面输入Object，点击Object java.lang，就可以看源码了。可以看到被protected关键字修饰Main类与clone方法不在同一个包路径下，所以在Main类里面无法通过Person类来访问。

package java.lang;

import jdk.internal.vm.annotation.IntrinsicCandidate;

@IntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

既然不能直接访问，那我们只能进行间接访问。此时我们还需要再重写一个方法，重写之后依然会报错。我们来看一下Object里面的源码，把"throws CloneNotSupportedException"复制粘贴到main方法后面，可以看到等号左边是子类Person，右面却是父类Object，此时就需要向下转型并强转来对父类进行赋值。

但光有这些还是不够的，我们还差最后一步，实现克隆接口。Cloneable接口里面没有任何实现，所以就是一个空接口。

public class Person implements Cloneable

//Cloneable的源码
public interface Cloneable {
}

以下是完整代码和运行结果：

public class Person implements Cloneable{
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person one = new Person("Paul",17);
        Person two = (Person) one.clone();
        System.out.println(two);
    }
}

下面我们来画图讲一下克隆是如何在栈和堆上工作的： one对象先在栈上开辟一块内存空间，指向堆上的地址，调用clone方法之后，直接又在堆上创建出一块，而two对象也指向了新克隆的空间。

1.3. 浅拷贝和深拷贝

（1）浅拷贝

看下面一段代码，我们在上面的代码基础上新增了一个Money类，在Main，我们先访问并打印两个对象的成员变量Money，然后修改two对象中的money的值，然后再打印，可以看到我明明只修改了two对象的成员变量，但one对象也被修改了。

class Money{
    public double money = 93.5;
}

public class Person implements Cloneable{
    public String name;
    public int age;
    public Money m;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.m = new Money();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person one = new Person("Paul",19);
        Person two = (Person) one.clone();

        System.out.println(one.m.money);
        System.out.println(two.m.money);
        System.out.println("===============");

        two.m.money = 86.4;
        System.out.println(one.m.money);
        System.out.println(two.m.money);
    }
}

相信老铁们看到这个图之后，就一目了然了。虽然说one所指向的对象被拷贝克隆了一份，但m所指向的money对象却没有被克隆，one和two所指向的是同一个money对象，这就会导致我们修改了money对象的值，两个变量都会被修改。这就是浅拷贝。那么老铁们想一下如何实现深拷贝呢？

（2）深拷贝

我们给Money这个类后面也来上接口Cloneable，也需要对Money类里面进行方法重写，与上面的浅拷贝不同的是，我们对Person类里面的克隆重写进行了改动。

class Money implements Cloneable{
    public double money = 93.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Person implements Cloneable{
    public String name;
    public int age;
    public Money m;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.m = new Money();
    }

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

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person one = new Person("Paul",19);
        Person two = (Person) one.clone();

        System.out.println(one.m.money);
        System.out.println(two.m.money);
        System.out.println("===============");

        two.m.money = 86.4;
        System.out.println(one.m.money);
        System.out.println(two.m.money);
    }
}

1.4. 抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式，都需要重点掌握，同时又要认清两者的区别。

核心区别: 抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用(不必重写)，而接口中 不能包含普通方法, 子类必须重写所有的抽象方法。

再次提醒，抽象类存在的意义是为了让编译器更好的校验，像 Animal 这样的类我们并不会直接使用，而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。