【Java基础语法】内置接口-CSDN博客

本文链接：https://blog.csdn.net/ggbond778/article/details/140638478

前言：

小编紧接着上期抽象类与接口进行了拓展，介绍了一些Java内置有用的接口，希望能够对大家有所帮助。上期博客http://t.csdnimg.cn/0MoDe

1. Comparable 接口

1.1Comparable 接口

在如下代码中：

 public static void main(String[] args) {
        Student[] student=new Student[]{
                new Student("zhangsan",12),
                new Student("lisi",11),
                new Student("wangwu",13),
        };
       
        System.out.println(Arrays.toString(student));
    }
}
class Student {
    public String name;
    public int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String toString(){
        return "["+this.name+":"+this.age+"]";
    }
  
}

我们能进行打印，但是如果我们想进行按年龄进行排序直接进行

Arrays.sort(student);

我们能进行排序吗，显然是不可以的，应为student数组包含了string类。

此时我们就要用到 Comparable接口，让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

代码实例：

class Student2 implements Comparable{
    public String name;
    public int age;
    public Student2(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String toString(){
        return "["+this.name+":"+this.age+"]";
    }
    @Override
    public int compareTo(Object o) {
        Student student=(Student) o;
        return this.age-student.age;
    }
}

实现comparable后要进行重写compareTo方法

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.然后比较当前对象和参数对象的大小关系。

1.2.comparator接口

在上述代码中存在一个问题，就是无法通过名字进行比较，那么此时我们就要用到comparator接口

代码如下：

class Agecompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age- o2.age;
    }
}

理解：设置一个年龄比较类去实现comparaor接口规定为学生类进行比较，重写compare方法，传入比较的学生对象，如果按年龄比较（对象.age），若前者更大，即返回负值。

当然我们也可以规定名字比较

代码如下：

class Namecompare implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }

原理：和上述年龄比较几乎一样,但是在用对像调用时，名字为string类不能够相减，此时string引用类型的compareto方法进行比较。

因为string实现了comparable接口，重写了compareto方法。

内置原码：

1.3总结

两种写法都叫做比较器，但是后者更加灵活，可以根据所需进行编写，而且两者可以共同存在。

2.Clonable 接口和深拷贝

2.1clone的语法

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

例如以下代码

public class test1 {
    public static void main(String[] args) {
        Person person1=new Person(10);
        Person person2=person1.clone();   //代码报错
    }
}
class Person{
    public int age;
    public Person(int age){
        this.age=age;
    }


    @Override
    public String toString() {
        return "Preson="+this.age;
    }
}

代码在clone关键词下面报错

当我们点开object类的clone方法时可以发现clone方法是protect方法

此时我们要在子类重写

class Person{
    public int age;
    public Person(int age){
        this.age=age;
    }

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

    @Override
    public String toString() {
        return "Preson="+this.age;
    }

此时克隆的就是person类
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

那么我们就要实现接口;

class Person implements Cloneable

并且处理异常

但是此时又再次报错，此时就要注意，object是父类，要完成向下转型，那么我们就要强转

Person person2= (Person) person1.clone();

此时我们就不会报错了。

总体代码如下：

public class test1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person(10);
        Person person2= (Person) person1.clone();
        System.out.println(person2);
        System.out.println(person1);
    }
}
class Person implements Cloneable{
    public int age;
    public Person(int age){
        this.age=age;
    }

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

    @Override
    public String toString() {
        return "Preson="+this.age;
    }
}

2.2总结处理

处理的异常：

1.object类的clone是protect方法，要实现子类重写

2.解决抛出异常问题

3.实现clone是父类方法，父类给子类要实现向下转型见http://t.csdnimg.cn/kIt7l

4.实现接口cloneable

2.3 浅拷贝

当我们重新设置一个类定义一个变量，并进行引用时，在person2实现更改值，但是输出时person1也会改变，这叫浅拷贝

代码如下：

 public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person(10);
        Person person2= (Person) person1.clone();
        System.out.println(person2.m.money);
        System.out.println(person1.m.money);
        System.out.println("---------------");
        person2.m.money=99.9;
        System.out.println(person2.m.money);
        System.out.println(person1.m.money);


    }
}
class Money{
    public double money=19.9;
}
class Person implements Cloneable{
    public int age;
    public Money m;
    public Person(int age){
        this.age=age;
        this.m=new Money();
    }

我们希望person2输出99.9，person1输出19.9；

但是两者都是99.9；

原因：在实现克隆时，并没有将对象里面的对象进行拷贝

如图：

所以两个还是调用同一个对象里面对象的地址。

2.4深拷贝

在上述中，我们就要拷贝一个内部对象

所以代码如下：

class Money implements Cloneable{
    public double money=19.9;

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

那么此时就要接收克隆出来的地址

protected Object clone() throws CloneNotSupportedException {
        Person temp=(Person) super.clone();

然后克隆内部的对象存在temp里，就有了内部对象的克隆

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

this时person1调用所以就是person1的内部对象进行克隆，最后将temp传给person2实现深拷贝。