Object类：equals(); hashCode(); getClass(); toString(); clone();方法的使用与重写

Object类

一、Object类概述

	类层次结构的根类，即所有类都直接或者间接的继承自该类。

二、Object类的常用方法

1、Object类的equals()方法

	A：功能：指示其他某个对象是否与此对象“相等”。
	B：源代码：
			public boolean equals(Object obj) {
    			return (this == obj);
			}
	C：注意：默认情况下比较的是对象的引用是否相同。
	D：使用：由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等。

举例：

	要求：在Student类中重写equals()方法，重写后的功能：如果两个对象成员变量的值相等，就认为这两个对象相同，即
equals()方法返回ture。并定义测试类进行测试。

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

    public Student() {
    }
    //有参构造方法，传入成员变量值
    public Student(String name, int age) {
        this.name=name;
        this.age=age;
    }

    @Override
    //两个对象的成员变量一摸一样，就认为两个对象一样
    public boolean equals(Object obj) {
        //优化比较效率（比较的两个对象本来就是一个对象）
        if(this==obj){
            return true;
        }

        //instanceof 可以判断一个引用或者对象，是不是该类型的一个引用
        if(!(obj instanceof Student)){
            return false;
        }
        //向下转型
        Student stu= (Student) obj;
        //"张三"=="张三"，有可能返回false，String 类认为父类Object中的 equals()方法默认比较方式意义不大，String类就重写了equals方法，去比较两个字符串字面内容是否相同
        return this.name.equals(stu.name)&&this.age==stu.age;
    }
}
class Test{
    public static void main(String[] args) {
        Student student3 = new Student("张三", 23);
        Student student4 = new Student("张三", 23);

        System.out.println(student3.equals(student4));
    }
}
运行结果：
true

Process finished with exit code 0

2、Object类的hashCode()方法

	public int hashCode()
		a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算,即把对象的地址值换算成一个整数值。
		b:不同对象的哈希码值一般来说不会相同。
	  	   但是，同一个对象的哈希码值肯定相同。
		c:不是对象的实际地址值，可以理解为逻辑地址值。	

示例：

public class MyTest extends Object{
    public static void main(String[] args) {
        //Object 是我们所有类的顶层父类，所有类都是直接或间接继承自他
        //创建Object类的对象
        Object obj = new Object();
        //Object类中常用的方法
        //hashCode() 返回一个对象的哈希码值(把对象的地址值换算成一个整数值)
        int code = obj.hashCode(); 
        System.out.println(code);
        
        Object obj2 = new Object();
        int code1 = obj2.hashCode();
        System.out.println(code1);
        //不同的对象的哈希码值不一样
    }
}
运行结果：
356573597
1735600054

Process finished with exit code 0

3、Object类的getClass()方法

	public final Class getClass()
		a:返回此 Object 的运行时类，即 类名.class文件加载进内存后，JVM就会为 类名.class文件创建一个对象，getClass()方法会返回该对象。
		b:可以通过Class类中的一个方法，获取对象的真实类的全名称。	
		public String getName()
		getClass().getName()代表返回对象所属类的类名。

示例：

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        System.out.println(animal.getClass());
        System.out.println(animal.getClass().getName());
    }
}
class Animal{

}
运行结果：
class Animal
Animal

Process finished with exit code 0

4、Object类的toString()方法

	public String toString()
	a:返回该对象的字符串表示。
		源代码:
		 	public String toString() {
   					 return getClass().getName() + "@" + Integer.toHexString(hashCode());
				}
	b:它的值等于： 
		getClass().getName() + '@' + Integer.toHexString(hashCode()) 
	c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法，即将该类的所有的成员变量组成返回即可

示例：

public class Test {
    public static void main(String[] args) {
        //未重写的toString()
        System.out.println(new Student1("小明", 21).toString());
        System.out.println("--------------------------------");
        //重写的toString() 方法
        Student stu = new Student("小明", 20);
        System.out.println(stu.toString());
    }
}
class Student{
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Student1{
    String name;
    int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
运行结果：
Student1@1540e19d
--------------------------------
Student{name='小明', age=20}

Process finished with exit code 0

5、Object类的clone() 方法

A：使用：clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public，使用clone()方法采用的是浅克隆的方式。

B：对象浅克隆要注意的细节： 
	1. 如果一个对象需要调用clone()方法克隆，那么该对象所属的类必须要实现Cloneable接口。
	2. Cloneable接口是一个标识接口，没有任何方法。
	3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
	4. 对象的浅克隆也不会调用到构造方法的。

示例：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person("张三", 23);
        Person p2 = (Person) p1.clone();
        //克隆会将成员变量的值也克隆，不对其重新赋值，则克隆的对象的成员变量的值等于被克隆对象的成员变量的值
        System.out.println(p1);
        System.out.println(p2);
        System.out.println("---------------------------");;
        Person p3 = new Person("王五", 25);
        Person p4 = (Person) p3.clone();
        p4.name = "赵六";
        p4.age = 36;
        System.out.println(p3);
        System.out.println(p4);
    }
}

class Person implements Cloneable {  //必须实现Cloneable接口，否则不能克隆
    public String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    //重写 clone()方法 修改权限修饰符，将private改为public
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
Person{name='张三', age=23}
Person{name='张三', age=23}
---------------------------
Person{name='王五', age=25}
Person{name='赵六', age=36}

Process finished with exit code 0