【Java SE】比较器和克隆

目录

1.比较器

1.1 实现comparable接口

1.2 实现Comparator接口

2.实现克隆Cloneable接口

2.1 浅拷贝

2.2 深拷贝

---

1.比较器

在Java中，说到引用类型之间的比较，我们不能使用基本的数据类型比较的方法，比如==、！=等

所以就有现在的比较器，来比较引用对象内部某个成员的大小

1.1 实现comparable接口

把将要比较的类实现comparable接口，重写compareTo方法

然后在重写的compareTo方法中实现你想比较对象成员

下面实现一个Student类，比较age的比较器

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 int compareTo(Student o) {
        //return this.name.compareTo(o.name);比较年龄
        return this.age-o.age;
    }
}
class Money implements Cloneable{
    public double money=19.99;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemo{
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1=new Student("bit",14);
        Student student2=new Student("abc",15);
        if(student1.compareTo(student2)>0)){
            System.out.println("student1>student2");
        }else{
            System.out.println("student1<=student2");
        }
    }
}

当然这个代码也能实现name的比较，只需要将

   return this.age-o.age;

换成

return this.name.compareTo(o.name);

但是问题是如果既想实现age的比较的同时，实现这个年龄的比较怎么办呢？

再次实现一个类？显然是变得麻烦一些，所以就有了后面的Comparator比较器

1.2 实现Comparator接口

实现自己的比较器

comparator接口的比较器的优点就是可以同时实现nameComparator和ageComparator

在比较age和name时，首先创建相应的类对象，调用重写的compare方法即可

class NameComparator implements Comparator<Student> {

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

2.实现克隆Cloneable接口

在Java中支持克隆接口，所谓克隆就是将某个对象

首先需要了解一下，拷贝与克隆的区别

对于一个引用类型来所，拷贝其实两者公用的还是同一个对象，也就是所，当改变某个对象的值，另一个也发生了改变

克隆就是，在原有对象的基础上，创建出一个新的对象，有自己新的地址，只不过这两个对象中的成员值时相等的，改变某个对象的内部的值，对另一个对象不会产生影响

要实现克隆，离不开cloneable接口

在这个cloneable接口中，没有具体的方法，但是不意味着，不需要cloneable接口，如果不实现这个接口，程序就会出现异常

克隆一个person对象

class Person implements Cloneable{
    public int age=19;
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//父类Object中的方法clone，通过c语言实现
    }
}
public class TestDemo{
   public static void main(String[] args) throws CloneNotSupportedException {
    Person person1=new Person();//通过person1克隆出person2
    Person person2=(Person)person1.clone();
   }

2.1 浅拷贝

当存在一个的类时，而这个类里存在一个引用对象

所谓浅拷贝，就是虽然将这个对象实现了拷贝，但是这个对象中的m引用的对象没有实现克隆，也就是他们共用了同一个Money对象，通过m创建的是同一个对象，地址也相等

当改变m对象中的money的值时，这两个Person创建的对象内部同时发生了改变

2.2 深拷贝

所谓深拷贝，其实跟浅拷贝差不多，无非就是在原有的基础上，对m对象也实现了克隆

这样改变某个m对象的值，另一个m创建的对象中的money值不发生改变

这两个对象的地址也不相等

class Person implements Cloneable{
    public int age=19;
    public Money m=new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person temp=(Person)super.clone();
        temp.m=(Money) this.m.clone();  //修改引用类型的值
        return temp;
        //return super.clone();//父类的clone 看不见
    }
}
public class TestDemo{
    public static void main(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);
        person2.m.money=99;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }
}