Object类:
Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。
所有类都是Object类的子孙类。
API文档：
Object类的成员方法：
Object类的常见方法：
Student类：
package cn.ensource.d13_object;
import java.util.Objects;
public class Student { // 默认继承Object类
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
// 重写equals方法，比较两个对象的内容一样，就返回true
@Override
public boolean equals(Object obj) {
// 1. 两个对象的地址一样，直接返回true
if(this == obj) return true;
// 2. 判断Obj是null，直接返回false
// 比较者类型跟被比较者类型不一样，例如：Student.class != Pig.class
if(obj == null || getClass() != obj.getClass()) return false;
// 3. obj不是null，obj一定是学生类型的对象，开始比较内容了
// 强制类型转换到Student
Student student = (Student) obj;
return Objects.equals(this.name, student.name) && this.age == student.age;
}
}测试类：
package cn.ensource.d13_object;
public class Test {
public static void main(String[] args) {
// 目标：掌握Object类的常用方法
Student s1 = new Student("赵敏", 23);
System.out.println(s1);
Student s2 = new Student("赵敏", 23);
System.out.println(s2.equals(s1)); // 默认比较两个对象的地址,String类是帮我们重写了equals方法
System.out.println(s1 == s2); // 默认比较两个对象的地址
}
}clone方法：对象克隆：
当某个对象调用这个方法的时候，这个方法会复制一个一模一样的新对象返回。
这个新对象：里面的内容一样的，但是地址不一样。
package cn.ensource.d13_object;
// Cloneable标志接口，理解是一种规则。
public class User implements Cloneable {
private int id;
private String username;
private String password;
private double[] scores;
public User() {
}
public User(int id, String username, String password, double[] scores) {
this.id = id;
this.username = username;
this.password = password;
this.scores = scores;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public double[] getScores() {
return scores;
}
public void setScores(double[] scores) {
this.scores = scores;
}
@Override
protected Object clone() throws CloneNotSupportedException {
// super 去调用父类Object中的clone方法
return super.clone();
}
}package cn.ensource.d13_object;
public class Test2 {
public static void main(String[] args) throws CloneNotSupportedException {
// 目标；掌握Object类的对象克隆方法
// 1. protected Object clone(): 对象克隆
User user1 = new User(1, "chang", "123456", new double[]{99.0, 99.5});
System.out.println(user1.getId());
System.out.println(user1.getUsername());
System.out.println(user1.getPassword());
System.out.println(user1.getScores());
System.out.println("-----------");
User user2 = (User) user1.clone();
System.out.println(user2.getId());
System.out.println(user2.getUsername());
System.out.println(user2.getPassword());
System.out.println(user2.getScores());
}
}
protected只能在这个lang包下，访问这个clone方法。或者是在Object的子类中才能调用这个方法。
protected 是指可以在子类中访问，而不是在子类对象中访问。
User是Object的不同包的子类，可以在User类中访问clone，但是不能在Test类中访问。
protected修饰的只能在本类，同一包下，继承它的子类中使用，只能在User这个类中使用clone，在new出来的对象中确实使用不了，如果一定要使用，重写或者在方法中使用。
protected只能自己的儿子用，不让让儿子的朋友以儿子的名义用。
实现对象克隆方法：
1）方法重写clone();
2）实现Cloneable接口；
3）main函数throw 异常处理；
输出结果：
1
chang
123456
[D@3b07d329
-----------
1
chang
123456
[D@3b07d329getscores()函数返回的是数组的地址，克隆的对象中的地址是一样的，都是指向堆内存中的数组对象，所以地址相同。
浅克隆：
拷出来的新对象，与原来对象中的数据是一模一样的（引用类型拷贝的只是地址。）
深克隆：
对象中基本类型的数据直接拷贝。
对象中的字符串数据拷贝的还是地址。String是放在堆内存的常量池中。
对象中还包含的其他对象，不会拷贝地址，会创建新对象。
深克隆的实现：
对数组对象进行克隆。
