API-Object成员方法

demo1：

重写equals方法后的Student类：

package Object1;

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;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
    //在javaBean中按alt+insert 重写equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

}

测试1：

package Object1;

public class demo1 {
    public static void main(String[] args) {
        Student s1 = new Student("sunshine", 23);
        Student s2 = new Student("九色鹿", 24);
        //tostring方法的结论:
        //如果我们打印一个对象，想要看到属性值的话，那么就重写tostring方法就可以了。
        //在重写的方法中，把对象的属性值进行拼接。
        System.out.println(s1.toString());
        if (s1.equals(s2)) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
        //结论:
        //1.如果没有重写equals方法，那么默认使用object中的方法进行比较，比较的是地址值是否相等
        //2.一般来讲地址值对于我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了
        //tips:在javaBean中按alt+insert 重写equals
    }
}

测试2：

package Object1;

public class Test {
    public static void main(String[] args) {
        String s = "abc";
        StringBuilder sb = new StringBuilder("abc");
        System.out.println(s.equals(sb));//false
        //因为equals方法是被s调用的，而s是字符串
        // 所以equals要看string类中的
        // 字符串中的equals方法，先判断参数是否为字符串
        // 如果是字符串，再比较内部的属性
        // 但是如果参数不是字符串，直接返回fa1se
        System.out.println(sb.equals(s));//false
        //因为equals方法是被sb调用的，而sb是stringBuilder
        // 所以这里的equals方法要看stringBuilder中的equals方法
        // 那么在stringBuilder当中，没有重写equals方法
        // 使用的是obiect中的
        //在object当中默认是使用==号比较两个对象的地址值
        // 而这里的s和sb记录的地址值是不一样的，所以结果返回false
    }
}

demo2：

User类：

package Object2;

import java.util.StringJoiner;

//Cloneable
//如果一个接口里面没有抽象方法
//表示当前的接口是一个标记性接口
//现在Cloneable表示一旦了实现，那么当前类的对象就可以被克降
//如果没有实现，当前类的对象就不能克降

public class User implements Cloneable{
    private int id;//游戏角色
    private String username;//用户名
    private String password;//密码
    private String path;//游戏图片
    private int[] data;//游戏进度

    public User() {
    }

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

    /**
     * 获取
     *
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     *
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     *
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     *
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     *
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     *
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     *
     * @return path
     */
    public String getPath() {
        return path;
    }

    /**
     * 设置
     *
     * @param path
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * 获取
     *
     * @return data
     */
    public int[] getData() {
        return data;
    }

    /**
     * 设置
     *
     * @param data
     */
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "User{id = " + id + ", username = " + username + ", password = " + password + ", path = " + path + ", data = " + arrTostring();
    }

    public String arrTostring() {
        StringJoiner sj = new StringJoiner(",", "[", "]");
        for (int i = 0; i < data.length; i++) {
            sj.add(data[i] + "");
        }
        return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去。
        return super.clone();
    }

}

测试类：

package Object2;

import com.google.gson.Gson;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
        //先创建一个对象
        User u1 = new User(001, "sunshine", "123456", "guet", data);
        //2.克隆对象
        //细节:
        //方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去。
        // 书写细节:
        //1.重写object中的c1one方法
        //2.让javabean类实现Cloneable接口
        //3.创建原对象并调用clone就可以了。

        System.out.println(u1);
        u1.setUsername("九色鹿");
        //clone()方法返回的是一个Object类型的引用，因此，需要进行类型转换 (User) 将这个Object引用强制转换为User类型
        User u2 = (User) u1.clone();
        System.out.println(u2);

        //继承过来的Object是浅克隆
        //若想进行深克隆，则需要第三方工具
        //1.第三方写的代码导入到项目中
        //2.编写代码
        Gson gson = new Gson();
        //把对象变成一个字符串
        String s= gson.toJson(u1);
        //再把字符串变回对象就可以了
        User user =gson.fromJson(s,User.class);
        int[] arr = u1.getData();
        arr[0]= 100;
        //打印对象
        System.out.println(user);
    }
}

demo3：

package Objects;

import javax.naming.Name;
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;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

}

测试类：

package Objects;

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("sunshine", 24);
        Student s2 = new Student("sunshine", 23);

        //boolean flag = s1.equals(s2);
        //System.out.println(flag);

        //它会调用这两个对象的equals()方法来比较它们的内容。
        //和上面注释掉的效果一样，比较的都是值（重写后）
        boolean equals = Objects.equals(s1, s2);
        System.out.println(equals);
        //细节:
        //1.方法的底层会判断s1是否为nu11，如果为nu11，直接返回false
        //2.如果s1不为nu11，那么就利用s1再次调用equals方法
        //3.此时s1是student类型，所以最终还是会调用student中的equals方法。
        //如果没有重写，比较地址值，如果重写了，就比较属性值。

        Student s3 = new Student();
        System.out.println(Objects.isNull(s3));
        System.out.println(Objects.nonNull(s3));
    }
}