本期目录
- 前言
- 一、初识Object类
- 🍑1、toString()
- 🍑2、hashCode()
- 🍑3、equals()
- 🍑4、clone()
- 三、对象的深浅拷贝
- 🍑1、浅拷贝
- 🍑2、深拷贝
- 🍑3、深浅拷贝的特点
- 二、对象数组排序
- 🍑1、通过Comparable接口排序
- 🍑2、通过Comparator接口排序
- 小结
前言
上期我们深入探讨了Java中的接口，其实Java中内置了很多非常有用的接口，为了能够进一步加深对接口的认识，也为能够灵活掌握这些常见接口的使用，我们就这期单独谈谈接口的实例。
一、初识Object类
在后面介绍接口的使用时，我们绕不开要使用Object类，为了后面能够更好的理解，我们这里就将Object类放到前面讲解。
Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收；所有的类都可以重写Object的方法。
Object类中方法都特别重要，由于这里我们还没学习多线程，所以就目前介绍一下如下四种：
🍑1、toString()
toString方法的作用是将对象转换为字符串形式。通常为了方便输出对象的内容，需要重写toString方法。
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//重写toString
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student("张三",18);
System.out.println(student);
}
🍑2、hashCode()
如果不重写Object类的toString方法，默认会调用Object类的toString方法，源码如下：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
假如不重写toString方法，这次我们再来运行：
这次我们并没有输出对象的内容，而是输出了一串数字，观察源码（我们先不理解@前的部分）显然这是Integer.toHexString(hashCode())搞的鬼，那么hashCode究竟是什么呢？
加上这段代码System.out.println(student.hashCode());我们再来测试一下：
我们暂且将其理解为计算对象的位置，暂将这段地址看做对象的地址。其实hashcode这个方法对于我们目前来说是用不上的，这里先埋个伏笔，之后学了Hashmap再来详细介绍它的用法。
🍑3、equals()
equals方法在Object类中的源码：
public boolean equals(Object obj) {
return (this == obj);
}
源码中的
equals比较的是对象的引用是否相同，显然这样默认的equals方法在对象的比较中是几乎用不到的，所以一般我们会对这个equals方法进行重写以满足实际的比较需求。
比如如果我们将两个名字一样的学生看作相同的对象，我们就可以这样重写equals方法：
public boolean equals(Object obj) {
if ( obj == null ) {//空对象和任何非空对象不同
return false;
}
if ( this == obj ) {//引用相同对象必相同
return true;
}
if(! (obj instanceof Student)) {//如果obj不是Student类的实例
return false; //那么必然不可能等于this
}
Student student = (Student)obj;
if(this.name.equals(student.name)) {//这里利用了String类中重写的equals方法
return true;
}
return false;
}
测试：
//……
public class Test {
public static void main(String[] args) {
Student student1 = new Student("张三",18);
Student student2 = new Student("张三",25);
if(student1.equals(student2)) {
System.out.println(student1+"和"+student2+"是同一个人！");
}
}
}
🍑4、clone()
clone()方法是用来复制一个对象，关于如何复制，这里涉及到了接口的知识，下面来详细介绍：👇
三、对象的深浅拷贝
1、Clonable接口
Clonable接口源码：
public interface Cloneable {
}
注：Clonable是一个空接口，也叫标记接口，只要一个类实现了这个接口就标志这个类是可以克隆的，否则不可以克隆。
2、重写clone方法
clone方法是Object类下protected修饰的一个native方法，如果希望提供从类（被克隆的类）外部复制其对象的功能，则可以覆盖Object.clone()作为公共对象，只需在内部调用super.clone()仍使用默认实现即可。（这里不太好理解，大家简单了解，主要是clone()的使用）
//浅拷贝实现方式
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
//深拷贝实现方式不唯一，需要具体情况具体分析。
完成了上面两个步骤我们就可以开始进行对象的拷贝了，根据重写方法的实现方式，我们将拷贝分为浅拷贝和深拷贝，下面分别详细介绍：
🍑1、浅拷贝
浅拷贝： 按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址（引用） ，因此如果其中一个对象改变了这个引用下的数据，就会影响到另一个对象。（浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。）
理论太过枯燥，下面我们直接测试代码：
//--------------浅拷贝----------------
class Money implements Cloneable{
public double m = 15.3;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Money{" +
"m=" + m +
'}';
}
}
class Student implements Cloneable{
public String name;
public int age;
public Money money = new Money();
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//浅拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
//测试浅拷贝
public class Test {
//throws CloneNotSupportedException先记忆固定格式，后期讲解
public static void main(String[] args) throws CloneNotSupportedException {
Student student1 = new Student("张三",18);
Student student2 = (Student) student1.clone();
System.out.println("修改前："+student1);
System.out.println("修改前："+student2);
System.out.print("\n");
student1.money.m=10.0;
System.out.println("修改后："+student1);
System.out.println("修改后："+student2);
}
}
🍑2、深拷贝
深拷贝： 在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。（深拷贝把要复制的对象所引用的对象都复制了一遍。）
实现深拷贝的核心就是对clone方法重写的实现，下面我们还以上面的Student-Money为例，重写一下深拷贝的方法：
@Override
protected Object clone() throws CloneNotSupportedException {
//1.先克隆student对象
Student stutclone = (Student) super.clone();
//2.克隆student对象中的money引用对象，并将克隆的新引用赋值给stuclone
stutclone.money = (Money) this.money.clone();
//3.将得到的深拷贝对象引用返回
return stutclone;
}
同样的测试用例，测试结果：
🍑3、深浅拷贝的特点
通过上面的例子，相信大家对深浅拷贝已经渐入佳境，下面就针对上面观察到的现象对深浅拷贝做一个简单的小结，加深一下印象。
浅拷贝特点 ：
(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
(2) 对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。
深拷贝特点 ：
(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
(3) 对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
(4) 深拷贝相比于浅拷贝速度较慢并且花销较大。
二、对象数组排序
在设计程序时我们会经常遇到给对象数组排序的问题，此时我们就可以用到Java为我们提供的两个比较接口对对象数组进行排序。
🍑1、通过Comparable接口排序
当我们使用Arrays.sort(数组名)排序对象数组时，内部用到Comparable接口，所以我们进行排序时也要对排序类实现Comparable接口。
Comparable接口源码：
public interface Comparable<T> {
public int compareTo(T o);
}
注意事项：
- 源码中的代表泛型，这里我们写成比较对象的类名，先不理解会用即可。
- 对于一个对象可能会有多个成员属性，所以排序时我们要重写Comparable中的compareTo方法用来指定排序规则。
compareTo比较时返回值对于不同的情况可能会五花八门，这就给我们重写方法带来了障碍，所以这里有一种简单的技巧：
- 当我们比较的是整形家族的成员时，升序写成
this.成员名-o.成员名;。 降序写成o.成员名-this.成员名;。- 当我们比较的是字符串类型的成员时，升序写成
this.成员名.compareTo(o.成员名);。降序写成o.成员名.compareTo(this.成员名);
比如下面对一个学生对象的数组进行排序：
class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//按年龄排序
@Override
public int compareTo(Student o) {
return this.age-o.age;
}
public class Test {
//按年龄排序
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("zhangsan",18);
students[1] = new Student("lisi",39);
students[2] = new Student("wangwu",26);
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
按姓名排序：（重写compareTO方法即可）
@Override
public int compareTo(Student o) {
return this.name.compareTo(o.name);
}
🍑2、通过Comparator接口排序
我们通常将实现Comparator接口的类称为一个比较器，通过Arrays.sort(数组名,比较器类名)实现对对象数组的排序。
下面仍以学生对象为例，这次通过实现Comparator接口实现对其排序：
import java.util.Arrays;
import java.util.Comparator;
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//姓名比较器
class NameCompare implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
}
//年龄比较器
class AgeCompare implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()- o2.getAge();
}
}
//测试用例
public class Test {
public static void main(String[] args) {
Student[] students = new Student[3];
NameCompare nameCompare = new NameCompare();
AgeCompare ageCompare = new AgeCompare();
students[0] = new Student("zhangsan",18);
students[1] = new Student("lisi",39);
students[2] = new Student("wangwu",26);
Arrays.sort(students,nameCompare);//按姓名排序
System.out.println(Arrays.toString(students));
Arrays.sort(students,ageCompare);//按年龄排序
System.out.println(Arrays.toString(students));
}
}
实现Comparable接口就可以实现对象的比较，那么为什么还要引出Comparator接口呢？
其实，实现
Comparable接口的方式比实现Comparator接口的耦合性更强，也就是说，如果要修改比较算法，要修改Comparable接口的实现类，而实现Comparator的类是在外部进行比较的，不需要对实现类有任何修改。从这个角度说，通过实现Comparator接口的比较，使用起来会更加灵活。
小结
本章浅浅介绍了Object类中的四种方法，另外本期重点：
重点一： 是能够理解并且灵活的使用Clonable接口搭配clone方法进行深浅拷贝。
重点二： 是能够灵活应用Comparator和Comparable给对象数组进行排序。
重点三： 通过这些例子再次加深对接口的理解。
