JavaSE-常用的接口

桥桥桥.

已于 2023-11-30 22:26:14 修改

阅读量58

点赞数

文章标签： java 开发语言

于 2023-11-30 22:19:08 首次发布

本文链接：https://blog.csdn.net/QIAO182/article/details/134700002

版权

Comparable接口

和普通的整数不一样，两个整数是可以直接比较的，大小关系明确，而两个学生对象的大小关系怎么确定？

我们需要用到Comparable接口，通过Student类来实现该接口，并实现（重写）其中的compareTo方法。

class Student implements Comparable<Student>{ //Student类实现Comparable接口
    public String name ;
    public int age ;
    public Student(String name ,int age){
        this.name = name ;
        this.age = age ;
    }
    public String toString(){
        return "Student{"+"name=" + name +'\'' + ", age=" + age +'}';
    }

    @Override
    public int compareTo(Student o) {
        //return this.name.compareTo(o.name);//选择返回姓名
        return this.age - o.age;//选择返回年龄
        //上条代码可以理解为：
        /*if(this.age > o.age) {
            return 1;
        }else if(this.age == o.age) {
            return 0;
        }else {
            return -1;
        }*/ //

    }//重写
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",3);
        if(student1.compareTo(student2) > 0) {
            System.out.println("student1 > student2");
        }else {
            System.out.println("student1 <= student2");
        }
    }
}

Comparable的源码：

重写了它的compareTo方法：

运行结果：

按姓名比较

按年龄比较

如果当前对象>参数对象，返回大于零的数
如果当前对象<参数对象，返回小于零的数
如果当前对象=参数对象，返回零

这样，我们就可以使用数组中的sort方法进行对数组的排序了

class Student implements Comparable<Student>{
    public String name ;
    public int age ;
    public Student(String name ,int age){
        this.name = name ;
        this.age = age ;
    }
    public String toString(){
        return "Student{"+"name=" + name +'\'' + ", age=" + age +'}';
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
//        return this.age - o.age;
        /*if(this.age > o.age) {
            return 1;
        }else if(this.age == o.age) {
            return 0;
        }else {
            return -1;
        }*/
    }
}   
public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",50);
        students[1] = new Student("lisi",31);
        students[2] = new Student("abc",59);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
}

在sort方法中，会自动调用compareTo方法，compareTo的参数是Object，其实传入的就是Student类型的对象。

运行结果：

需要注意的是，对于sort方法来说，需要传入的数组的每个对象都是”可比较“的，需要具备compareTo这样的能力。通过重写该方法，就可以自定义比较规则。

🏅拓展

我们可以自己实现一个sort方法来完成刚刚的排序过程（冒泡排序）

    public static void mySort(Comparable[] comparables) {

        for (int i = 0; i < comparables.length-1; i++) {
            for (int j = 0; j < comparables.length-1-i; j++) {
                //if(comparables[j] > comparables[j+1]) {
                if(comparables[j].compareTo(comparables[j+1]) > 0) {
                    //交换
                    Comparable tmp = comparables[j];
                    comparables[j] = comparables[j+1];
                    comparables[j+1] = tmp;
                }
            }
        }
    }

     public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",50);
        students[1] = new Student("lisi",31);
        students[2] = new Student("abc",59);
        mySort(students);
        System.out.println(Arrays.toString(students));
    }

❓那么在实际开发中，突然要用name进行排序而不用age进行排序，这个时候就要改非常多的代码，是很不合理的，这时就引入了Comparator接口来解决这个问题。

Comparator接口

分别定义AgeComparator（按年龄比较）和 NameComparator（按姓名比较）类实现Comparator接口，并重写compare方法。

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);
    }
}

main方法：

    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",31);

        AgeComparator ageComparator = new AgeComparator();//comparator接口用age比较
        System.out.println(ageComparator.compare(student1, student2));

        NameComparator nameComparator = new NameComparator();//comparator接口用name比较
        System.out.println(nameComparator.compare(student1, student2));
        
        System.out.println("=====");

        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",50);
        students[1] = new Student("lisi",31);
        students[2] = new Student("abc",59);

        NameComparator nameComparator2 = new NameComparator();
        AgeComparator ageComparator2 = new AgeComparator();

        Arrays.sort(students,ageComparator2);comparator接口用age比较
        System.out.println(Arrays.toString(students));
    }

定义了一个Students数组，调用Array.sort()默认使用的Compareable接口中的Compare方法，而我们在Cpmpareable接口重写的Compare是对年龄进行比较的方法，所以用数组来排序的时候用的还是默认的方法对年龄进行比较。

可以看出comparator接口是非常灵活的，想重新定义一个比较规则重新写一个就好，再调用这个重新写好的方法就可以了。

总结：需要注意的是，定义类的同时一定要实现这个接口，以及重写里面的方法。

Cloneable接口

Object类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”。

但是我们会发现以下问题

通过观察clone（）的源码发现，它是被protected修饰限定符修饰的，被protected在不同包只能在子类中用super进行访问。

并且如果类不实现cloneable接口，即使编译的时候不报错，运行时也会出现不支持克隆异常：“CloneNotSupportedException”。

Cloneable接口实现后就不报错了，但是发现我们并没有重写Cloneable接口中的抽象方法

进入Cloneale接口的源码--发现这个接口里面的内容空的--它是一个空接口/标记接口（如果一个类实现了接口，说明当前个类是可以克隆的，如果没有就是不支持克隆的）

Java中有许多-able修饰的接口，表示具有某某功能的意思，形容词词性。

所以实现克隆需要·以下几个条件：

代码：

class Person_ implements Cloneable {
    public String name;

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

    public Person_(String name) {
        this.name = name;
    }
}
public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person_ person1 = new Person_("zhangsan");
        Person_ person2 = (Person_) person1.clone();
        System.out.println(person2.name); //通过person这个引用 来克隆一个对象
    }
}

浅拷贝

Cloneable拷贝出来的对象是一份“浅拷贝”。


class Money{
    public double money =12.5 ;
}
class Person implements Cloneable{
    public String name ;
 
    public Money m ;//组合
 
    public Person(String name){
        this.name = name ;
        m = new Money() ;
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("zhangsan");
        //通过person这个引用来克隆一个对象//
        Person person2 = (Person)person1.clone();
        System.out.println("修改之前"+person1.m.money);//12.5
        System.out.println("修改之前"+person2.m.money);//12.5
        person2.m.money = 99.99 ;
        System.out.println("修改之后"+person1.m.money);//？99.99
        System.out.println("修改之后"+person2.m.money);//99.99
    }
}

画图思路：

通过clone，我们只是拷贝了Person对象，但是Person里面的Money对象并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。无论是person1还是克隆person2的money的大小都被修改成了99.99.这里就是发生了浅拷贝。

深拷贝

把所有对象都拷贝了，也就是说完全克隆出一个独立于原来对象的对象。

class Money implements Cloneable{//支持可被克隆
    public double money = 12.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person_ implements Cloneable{//支持可被克隆
    public String name;
    public Money m;//组合
    public Person_(String name) {
        this.name = name;
        m = new Money();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();
        Person_ tmp = (Person_) super.clone();

        tmp.m = (Money) this.m.clone();

        return tmp;
    }
}
public class Test2 {
    public static void main(String[] args)throws CloneNotSupportedException  {
        Person_ person1 = new Person_("zhangsan");
        Person_ person2 = (Person_) person1.clone();
        System.out.println("修改之前："+person1.m.money);//12.5
        System.out.println("修改之前："+person2.m.money);//12.5
        person2.m.money = 99.99;

        System.out.println("修改之后："+person1.m.money);// 12.5
        System.out.println("修改之后："+person2.m.money);// 99.99
    }
}

画图思路：

此时Money也要支持可被克隆，并且重写clone方法。（前期准备工作）

第一步，tmp引用存被克隆过来的对象name和m；第二步，把当前m（即person1的m）所指向的对象money也克隆一份给到 tmp引用的 m对象，并强转为Money。此时tmp就是一个全新的对象，最后return返回tmp，也就是把tmp的值给到了person2。 tmp 是局部变量，最后会被栈回收。

运行结果:

因此，是不是深拷贝就要看程序猿实现的怎么样。

寄语：不要忘了你希望的远方

桥桥桥.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE-常用的接口

定义了一个Students数组，调用Array.sort()默认使用的Compareable接口中的Compare方法，而我们在Cpmpareable接口重写的Compare是对年龄进行比较的方法，所以用数组来排序的时候用的还是默认的方法对年龄进行比较。需要注意的是，对于sort方法来说，需要传入的数组的每个对象都是”可比较“的，需要具备compareTo这样的能力。在sort方法中，会自动调用compareTo方法，compareTo的参数是Object，其实传入的就是Student类型的对象。
复制链接

扫一扫