目录
一.Cloneable 接口
二.浅拷贝
三.深拷贝
四.comparable接口、
五.comparator接口
1.Java
中内置了一些很有用的接口
, Cloneable
就是其中之一
.
Object
类中存在一个
clone
方法
,
调用这个方法可以创建一个对象的
"
拷贝
".
2.来说说调用
clone 方法的注意事项：首先要先
实现Cloneable 接口，然后
重写克隆方法，这里我们会发现，
Cloneable 是个空接口，就因为是，空接口才可以被继承。
注意异常，还有向下转型
二.浅拷贝：
如下代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。
代码：
class Money implements Cloneable {
public double m = 10.9;
@Override
protected Object clone()
throws CloneNotSupportedException {
return super.clone();
}
}
public class Person implements Cloneable {
public String name;
public int age;
Money money = new Money();
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() //注：谁调用了clone方法，谁就是this(Test中person1调用了clone)
throws CloneNotSupportedException {
return super.clone();
}
}
public class Test {
public static void main(String[] args)
throws CloneNotSupportedException {
//浅拷贝
Person person1 = new Person("lili", 2);
Person person2 = (Person) person1.clone();
System.out.println(person2);
System.out.println("修改前" + person1.money.m);
System.out.println("修改前" + person2.money.m);
person2.money.m = 20.9;
System.out.println("修改后" + person1.money.m);
System.out.println("修改后" + person2.money.m);
}画了一个图可以这样理解：这里结果反应了浅拷贝
三.深拷贝：我们可以看到，通过clone，我们既拷贝了Person对象。这里注意：（我们通过，persion1对象点money的引用，来克隆（不要忘记向下转型）。
）拷贝Person对象中的Money对象，并没有拷贝。
代码如下：
class Money implements Cloneable {
public double m = 10.9;
@Override
protected Object clone()
throws CloneNotSupportedException {
return super.clone();
}
}
public class Person implements Cloneable {
public String name;
public int age;
Money money = new Money();
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() //注：谁调用了clone方法，谁就是this(Test中person1调用了clone)
throws CloneNotSupportedException {
Person tmp = (Person)super.clone();
tmp.money = (Money)this.money.clone();//通过对象(.)引用(.)克隆（通过引用修改）
return tmp;
}
}
public class Test {
public static void main(String[] args)
throws CloneNotSupportedException {
//深拷贝
Person person1 = new Person("lili", 2);
Person person2 = (Person) person1.clone();
System.out.println(person2);
System.out.println("修改前" + person1.money.m);
System.out.println("修改前" + person2.money.m);
person2.money.m = 20.9;
System.out.println("修改后" + person1.money.m);
System.out.println("修改后" + person2.money.m);
}
}这是我对深拷贝的理解：结果反应深拷贝
四.comparable接口:
1.使用：涉及到自定义类型比较可以用，comparable接口：
2.实现接口并重写compareTo方法，注意：泛型哪里，计较哪个对象就写，哪个对象，还有这里我们自己，写了一个排序方法，通过sort,调用compareTo方法，我们会传入Student对象，这里this和O,是我们，比较的学生对象。
3.这里我们自己模拟了，被调接口里的排序方法（我们默认升序写法）。当然也可以用，接口本来比较，复杂的方法。
通过传入，接口来规范我们，达到，不同对象都可以用的，作用
public static void mySort(Comparable[] comparable) { //这里用接口类型的数组接受，只要接口里有对应的方法，就可以通过实例化，这个接口类型的数组，来调用对应方法
for (int i = 0; i < comparable.length-1; i++) {
for (int j = 0; j < comparable.length-1-i; j++) {
/**
* 注意：数组是引用类型（相当于地址），不可以这样比较(comparable[j] > comparable[j+1])
*/
if (comparable[j].compareTo(comparable[j+1]) > 0) {
Comparable tmp = comparable[j];
comparable[j] = comparable[j+1];
comparable[j+1] = tmp;
}
}
}
}下面给代码现象：
4.这个接口，也有缺陷，比较较为固定（要自己单独更换，重写方法，里的比较方式），接下来我们换一个接口。
五.comparator接口:(这个接口，我们可以单独，自己写一类，构造器)
1.使用：这里排序方法还是用我们自己写的
2.重写compare方法:(这里我们的，NameComparator就是，一个构造器，为什么呢？就是我们这里规定，自定义Name来比较。)
main方法里的代码：
public static void main(String[] args) {
NameComparator nameComparator = new NameComparator();
Student[] student = new Student[3];
student[0] = new Student("wada", 8);
student[1] = new Student("lili", 9);
student[2] = new Student("huahua", 10);
System.out.println("排序前" + Arrays.toString(student));
Arrays.sort(student, nameComparator);//这里要，多传一个，构造器对象
System.out.println("排序后" + Arrays.toString(student));
}结果：
