Object类

一:Object类的作用

1.Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。

2.Object类的常见方法

toString() 返回对象的字符串表示形式。存在意义：让子类重写，以便返回子类对象的内容。

equals(Object o) 判断两个对象是否相等。存在意义：让子类重写，以便于比较对象的内容是否相同。注意：默认判断的是两个对象的地址。

import java.util.Objects;

public class Student {
    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.
    // 比较者：s2 == this
    // 被比较者：s1 == o
    @Override
    public boolean equals(Object o) {
        // 1.判断两个对象的地址是否一样 一样就直接返回true.
        if (this == o) return true;
        // 2.判断 o 是null就直接返回false，或者比较者的类型与被比较者的类型不一样，返回false.
        if (o == null || getClass() != o.getClass()) return false;
        // 3.o不是null且o一定是比较者类型的对象。开始比较内容了！
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("王凯",18);
        System.out.println(s1.toString());
        Student s2 = new Student("王凯",18);
        System.out.println(s2.equals(s1));

    }
}

对于两种方法toString没修改前输出的为对象的地址 修改后为对象的内容

equals没修改前比较的为两个对象的地址修改后比较的是内容

clone() 对象克隆。当对象调用这个方法时，这个方法会复制一个一模一样的新对象返回。

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

// Cloneable是一个标记接口。
// 规则。
public class User implements Cloneable{
    private int id;
    private String username;
    private String password;
    private double[] score;

    public User() {
    }

    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[] getScore() {
        return score;
    }

    public void setScore(double[] score) {
        this.score = score;
    }

    public User(int id, String username, String password, double[] score) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.score = score;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // super去调用父类的Object中的clone方法
        return super.clone();
    }
}

public class Tset2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        // protected Object clone():对象克隆
        User u1 = new User(1,"王凯","123456",new double[]{99.5,87.0});
        u1.clone();
        System.out.println(u1.getId());
        System.out.println(u1.getUsername());
        System.out.println(u1.getPassword());
        System.out.println(u1.getScore());
        User u2 = (User) u1.clone();
        System.out.println(u2.getId());
        System.out.println(u2.getUsername());
        System.out.println(u2.getPassword());
        System.out.println(u2.getScore());
    }
}

深克隆：对象中基本类型的数据直接拷贝。

对象中的字符串数据拷贝的还是地址。

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

@Override
protected Object clone() throws CloneNotSupportedException {
// super去调用父类的Object中的clone方法
User u2 = (User) super.clone();
u2.score = u2.score.clone();
return u2;
}

修改后用于深度克隆的方法。

结果会发现数组类型的数据的地址发生了改变。