day14 JavaSe之Object类

第一章 Object类
1.1 概述
所有类的父类
如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
  	// ...
}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天主要学习其中的2个：

• public String toString()：返回该对象的字符串表示。
• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

1.2 toString方法

• public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

覆盖重写

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}

在这里插入代码片

1.3 equals方法

方法摘要

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
• 调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

import java.util.Objects;

public class Person {	
	private String name;
	private int age;
	
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

1.4 Objects类

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

• public static boolean equals(Object a, Object b):判断两个对象是否相等。

查看一下源码：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

Object类的成员方法
public int hashCode()
public final Class getClass()
public String toString()
public boolean equals(Object obj)
protected void finalize()
protected Object clone()

//public int hashCode()
//public final Class getClass()
//public String toString()
public class StudentTest2 {
    public static void main(String[] args) {

        Student2 s1 = new Student2();

        System.out.println(s1.hashCode());//打印hash值
        System.out.println(s1.getClass().getName()); //com.shujia.java.day14.Student2
        System.out.println("***************************");
        System.out.println(s1.toString()); // com.shujia.java.day14.Student2@4554617c
        System.out.println("***********");
        //toString()方法等价于以下内容：
        //getClass().getName() + '@' + Integer.toHexString(hashCode())
        //this.getClass().getName()+"@"+Integer.toHexString(this.hashCode)
//        com.shujia.java.day14.Student2@4554617c

        System.out.println(s1.getClass().getName()+"@"+Integer.toHexString(s1.hashCode()));

        s1.setName("AAA");
        s1.setAge(18);
        System.out.println(s1.toString());
        //打印对象本身，默认调用toString()方法
        System.out.println(s1);



    }

}

public boolean equals(Object obj)
Student3类

public class Student3 {
    private String name;
    private int age;

    public Student3() {
    }

    public Student3(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 "Student3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) { //Object obj = new Student3();
//        return true;

        //s1 -- this
        //s4 -- obj
        //想要访问父类中成员，就要向下转型

        if (this == obj){
            return true;
        }

        Student3 s = (Student3)obj;
        return this.name.equals(s.getName()) && this.age == s.getAge();
    }


//    @Override
//    public boolean equals(Object obj) {
//        return super.equals(obj);
//    }
}

Student3测试类

/*
        public boolean equals(Object obj)指示一些其他对象是否等于此。
        这个方法默认比较的是地址值。通过观察源码发现，底层默认调用的是==比较两个对象，
        而==比较的是地址值是否相同，所以System.out.println(s1.equals(s2)); //false

        但是呢，比较地址值是没有任何意义的，更多情况下，我们应该比较的是对象中成员变量
        的值是否一样。


        ==:
           基本数据类型：比较的是值是否相同
           引用数据类型：比较的是地址值是否相同

       equals:
        因为equals是属于Object类中的方法，只有对象可以去调用，而基本数据类型不属于对象
        引用类型：默认情况下比较的是地址值，需要根据情况去重写，而重写的时候不需要我们自己去重写
        可以自动生成,但是里面的实现逻辑需要自己去写

 */
public class StudentTest3 {
    public static void main(String[] args) {
        Student3 s1 = new Student3("AA", 18);
        Student3 s2 = new Student3("AA", 18);

        System.out.println(s1 == s2);//false

        Student3 s3 = s1;
        System.out.println(s1 == s3); // true
        System.out.println("***********************");

        System.out.println(s1.equals(s2)); //false
        System.out.println(s1.equals(s1)); //true
        System.out.println(s1.equals(s3)); //true

        Student3 s4 = new Student3("BBB", 18);
        System.out.println(s1.equals(s4));
    }
}

protected void finalize()
protected Object clone()

public class Student4 implements Cloneable{
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(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 "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

/*
        protected void finalize()
                 throws Throwable
                 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
                 简单来说，它就是用于垃圾回收的。
                 什么时候回收不确定。

        protected Object clone()
                throws CloneNotSupportedException创建并返回此对象的副本。
                返回的是这个实例的一个克隆，被Object类接收

                clone会创建一个新的对象出来。


        Interface Cloneable使用clone方法必须实现这个杰奎
        但是我们通过观察API发现，该接口没有任何抽象方法，那么实现这个接口有什么意义呢？
        如果没有重写该接口就直接调用，会报错CloneNotSupportedException
        像这样没有任何方法的接口我们称之为标记接口

 */
public class StudentTest4 {
    public static void main(String[] args) throws CloneNotSupportedException {

        Student4 s1 = new Student4();
        s1.setName("小花");
        s1.setAge(18);
        System.out.println(s1.toString());

        Object s1Clone = s1.clone();
        //向下转型
        Student4 sClone = (Student4) s1Clone;
        System.out.println(s1.getName()+"---"+s1.getAge());
        System.out.println(sClone.getName()+"---"+sClone.getAge());

        Student4 s2 = s1; //堆内存中始终只有一个对象
        System.out.println(s2.getName()+"---"+s2.getAge());

        s2.setName("小白");
        s2.setAge(20);
        System.out.println(s1.getName()+"---"+s1.getAge());
        System.out.println(sClone.getName()+"---"+sClone.getAge());


    }
}