Java中常用API---Object

Object是Java中的顶级父类，所有的类都直接或间接的继承于Object类

Object类中的方法可以被所有子类访问，所以我们要学习Object类和其中的方法

public Pbject()--------->空参构造

一、Object的成员方法：

public String toString()------------->返回对象的字符串表示形式

public boolean equals(Object obj)-------------->比较两个对象是否相等

protected Object clone(int a)---------------->对象克隆

1.toString方法：

package a04Objectdemo;

public class ObjectDmeo1 {
    public static void main(String[] args) {
        Object obj=new Object();
        String str1 = obj.toString();//ctrl+alt+V自动生成左边
        System.out.println(str1);//java.lang.Object@4eec7777--------->地址值
        //细节：
        //System:类名
        //out:静态变量
        //System.out:获取打印的对象
        //println():方法
        //参数：表示打印的内容
        //核心逻辑：
        //当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串
        //然后再打印在控制台上，打印完毕换行处理

        //默认情况下，因为Object类中的toString方法返回的是地址值
        //所以默认情况下打印一个对象打印的就是地址值
        //但地址值对我们没什么用，想要看到对象内部的属性值
        //就需要重写父类Object类中的toString方法
        Student stu = new Student();
        System.out.println(stu);//null, 0
    }
}

运行结果：

toString方法的结论:如果打印一个对象，想要看到属性值的话，那么就重写toString方法就可以了

                                  在重写的方法中，把对象的属性值进行拼接

快捷键的方法：右键Ptg to JavaBean就可以自动生成了

2.equals方法：

Student类：alt+insert快捷键有一个equals() and hashCode()可以自动生成重写equals方法

package a04Objectdemo;

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 name+", "+age;
    }

    //重写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);
    }

}

测试类：

package a04Objectdemo;

public class ObjectDmeo2 {
    public static void main(String[] args) {
        //equals:比较两个对象是否相等
//        Student s1=new Student();
//        Student s2=new Student();
//        boolean result1 = s1.equals(s2);
//        System.out.println(result1);//重写equals方法前结果：false
        //s1是Student类型，调用equals方法时调用的Student中的，但Student中我们没写equals方法，所以是继承父类Object中的
        //而父类Object使用的==号比较，==号在比较引用数据类型时比较的是地址值
        //所以相比较内容时，需要重写equals方法

        Student s1=new Student("zhangsan",23);
        Student s2=new Student("zhangsan",23);
        boolean result1 = s1.equals(s2);
        System.out.println(result1);//重写equals方法后结果：true
    }
}

equals方法的结论：

①：如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等

②：一般地址值对我们意义不大，所以会重写，重写之后比较的就是对象内部的属性值了 

3.clone方法：

对象克隆：把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制

代码演示：

JavaBean类:

package a04Objectdemo;

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;//游戏进度
    }

    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 String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }
    public String toString(){
        return "角色编号为："+id+",用户名："+username+",密码："+password+",游戏图片："+path+",进度："+arrToString();
    }
    public String arrToString(){
        StringJoiner sj=new StringJoiner(", ","[","]");
        for (int i = 0; i < data.length; i++) {
            sj.add(data[i]+"");
        }
        return sj.toString();
    }
    //重写clone方法
    //因为Object中的clone方法时protected修饰的，不能用包外的子类对象直接调用，需要子类重写clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类中的clone方法
        //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去
        return super.clone();
    }
}

测试类：

package a04Objectdemo;

public class Objectdemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //clone  对象克隆
        //1.创建对象
        int[] data={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0};
        User u1=new User(1,"zhangsan","1234qwer","girl11",data);
        //2.克隆对象
        //细节：方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去
        //书写细节：
        //1.重写Object中的clone方法
        //2.让JavaBean类实现Cloneable接口
        //3.创建原对象并调用clone方法就可以了
        User u2=(User)u1.clone();
        System.out.println(u1);
        System.out.println(u2);
    }
}

运行结果：

//细节：方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去
//书写细节：
//1.重写Object中的clone方法
//2.让JavaBean类实现Cloneable接口
//3.创建原对象并调用clone方法就可以了

对象克隆方式1：浅克隆，浅拷贝：不管对象内部属性是基本数据类型还是引用数据类型完全拷贝

基本数据类型直接拷贝变量记录的数据值

引用数据类型直接拷贝变量记录的地址值，包括数组

但这样，原对象和克隆的对象都能通过地址值找到数组，通过其中一个就改变数组中的值

对象克隆方式1：深克隆，深拷贝：基本数据类型拷贝,字符串复用,引用数据类型会重新创建新的

基本数据类型直接拷贝变量记录的数据值

引用数据类型不会直接拷贝地址值了，数组而是会再创建一个对象，把原来里面的数据拷贝过来

新data记录的就是新地址值，所以两个数组操作数据互相之间不影响

但字符串类型会记录在串池中，由于没有new一个新的对象，所以串池中的会复用，字符串拷贝的仍是原来的地址

clone():默认浅克隆，如果需要深克隆需要重写方法或使用第三方工具类

二、Objects的成员方法：

public static boolean equals(Object a,Object b)---------->先做非空判断，比较两个对象 

public static boolean isNull(Object obj)------->判断对象是否为null，为null返回true，反之返回false

public static boolean nonNull(Object obj)---------->判断对象是否为null，跟isNulgfan

代码演示：

package a04Objectdemo;

import com.google.gson.Gson;

import java.util.Objects;

public class Objectdemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1=null;
        Student s2=new Student("zhangsan",23);
        boolean result = Objects.equals(s1, s2);
        System.out.println(result);//false
        //细节：
        //1.方法的底层会判s1是否为null，如果为null，直接返回false
        //2.如果s1不为null，那么就利用s1再次调用equals方法
        //3.此时s1还是Student类型的，所以最终还是会调用Student中的equals方法
        //如果没有重写，比较地址值，如果重写了，就比较属性值

        Student s3=new Student();
        Student s4=null;
        System.out.println(Objects.isNull(s3));//false
        System.out.println(Objects.isNull(s4));//true
        System.out.println(Objects.nonNull(s3));//true
        System.out.println(Objects.nonNull(s4));//false
        


    }
}

 运行结果：