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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}// 重写equals方法，比较两个对象的内容一样，就返回true@Overridepublic boolean equals(Object obj) {// 1. 两个对象的地址一样，直接返回trueif(this == obj) return true;// 2. 判断Obj是null，直接返回false// 比较者类型跟被比较者类型不一样，例如：Student.class != Pig.classif(obj == null || getClass() != obj.getClass()) return false;// 3. obj不是null，obj一定是学生类型的对象，开始比较内容了// 强制类型转换到StudentStudent 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;}@Overrideprotected 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@3b07d329

getscores()函数返回的是数组的地址，克隆的对象中的地址是一样的，都是指向堆内存中的数组对象，所以地址相同。

浅克隆：

拷出来的新对象，与原来对象中的数据是一模一样的（引用类型拷贝的只是地址。）

深克隆：

对象中基本类型的数据直接拷贝。

对象中的字符串数据拷贝的还是地址。String是放在堆内存的常量池中。

对象中还包含的其他对象，不会拷贝地址，会创建新对象。

深克隆的实现：

对数组对象进行克隆。