java中Object类的常用方法总结

一、clone

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
总之深浅克隆都会在堆中新分配一块区域，区别在于对象属性引用的对象是否需要进行克隆（递归性的）。

case:

public class Main {

    public static void main(String[] args) {
        // 创建父亲(LiSi)，儿子(LiWu)，孙子（LiLiu）并关联
        Son father = new Son();
        father.setName("LiSi");
        Son son = new Son();
        son.setName("LiWu");
        Son grandSon = new Son();
        grandSon.setName("LiLiu");
        father.setSon(son);
        son.setSon(grandSon);
        // 调用clone方法
        Son fatherCopy = null;
        try {
            fatherCopy = (Son) father.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        boolean flag1 = fatherCopy==father;
        boolean flag2 = fatherCopy.getSon() == son;
        boolean flag3 = fatherCopy.getSon().getSon() == grandSon;
        // 比较克隆后的地址

        System.out.println(flag1);// false
        System.out.println(flag2);// true
        System.out.println(flag3);// true
        // 比较Name
        flag1= fatherCopy.getName()==father.getName();
        flag2 = fatherCopy.getSon().getName() == son.getName();
        flag3 = fatherCopy.getSon().getSon().getName() == grandSon.getName();
        System.out.println(flag1);// true
        System.out.println(flag2);// true
        System.out.println(flag3);// true
    }
}

如上，如果对象实现Cloneable并重写clone方法不进行任何操作时,调用clone是进行的浅克隆。

既然实现Cloneable接口并重写clone接口只能进行浅克隆。但是如果类的引用类型属性（以及属性的引用类型属性）都进行浅克隆，直到没有引用类型属性或者引用类型属性为null时，整体上就形成了深克隆。既对象的引用类型属性和属性的应用类型属性都实现Coloneable，重写clone方法并在clone方法中进行调用。

protected Object clone() throws CloneNotSupportedException {
      Son result = (Son) super.clone();
    if (son != null) {
        result.son = (Son) son.clone();
    }
    return result;
}

二、equals and hashCode

equals

equals 方法既然是基类 Object 的方法，我们创建的所有的对象都拥有这个方法，并有权利去重写这个方法。该方法返回一个 boolean 值，代表比较的两个对象是否相同，这里的相同的条件由重写 equals 方法的类来解决。

String str1 = "abc";
String str2 = "abc";
str1.equals(str2);//true

显然 String 类一定重写了 equals 方法否则两个 String 对象内存地址肯定不同。


 public boolean equals(Object anObject) {
   //首先判断两个对象的内存地址是否相同
   if (this == anObject) {
       return true;
   }
   // 判断连个对象是否属于同一类型。
   if (anObject instanceof String) {
       String anotherString = (String)anObject;
       int n = value.length;
       //长度相同的情况下逐一比较 char 数组中的每个元素是否相同
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                   return false;
               i++;
           }
           return true;
       }
   }
   return false;}

hashCode

hashCode()定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
hashCode()的作用是获取hash值，也称为散列码；它实际上是返回一个int整数。这个hash值的作用是确定该对象在哈希表中的索引位置。也就是说hash值要在一些数据结构中才能显现作用。hashcode一般用在hashmap、hashset里，判断要把数据放在数组的什么位置。

下面，我们以HashSet为例，来深入说明hashCode()的作用。

假设，HashSet中已经有1000个元素。当插入第1001个元素时，需要怎么处理？因为HashSet是Set集合，它不允许有重复元素。 “将第1001个元素逐个的和前面1000个元素进行比较”？显然，这个效率是相等低下的。散列表很好的解决了这个问题，它根据元素的散列码计算出元素在散列表中的位置，然后将元素插入该位置即可。对于相同的元素，自然是只保存了一个。由此可知，若两个对象相等，它们的散列码一定相等；但反过来不一定。在散列表中，
1、如果两个对象相等，那么它们的hashCode()值一定要相同。这里的相等是指，通过equals()比较两个对象时返回true。
2、如果两个对象hashCode()相等，它们并不一定相等。

转自：https://www.jianshu.com/p/cf164837f8ed

三、getClass

getClass方法是获得Class对象的方法之一

class A{
    public void func(){

    }
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.getClass()); // class A
    }
}

反射学习

所谓反射，可以理解为在运行时期获取对象类型信息的操作。传统的编程方法要求程序员在编译阶段决定使用的类型，但是在反射的帮助下，编程人员可以动态获取这些信息，从而编写更加具有可移植性的代码。严格地说，反射并非编程语言的特性，因为在任何一种语言都可以实现反射机制，但是如果编程语言本身支持反射，那么反射的实现就会方便很多。

Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

补充：获取class对象的三种方式

使用forName()方法：Class<?> clazz = Class.forName(className);
调用属性:Class<?> clazz = Person.class;
利用对象调用Object的getClass方法Person p = new Person(); Class<?> clazz = p.getClass();

四、toString

toString()是Object类的一个公有方法，而所有类都继承自Object类。所以所有类即使不实现toString方法，也会存在从Object类继承来的toString。

类可以实现toString方法，在控制台中打印一个对象会自动调用对象类的toString方法。打印的是对象名 + @换为十六进制的对象的哈希值

public class Test {
    public static void main(String[] args){
        Car car1 = new Car("宝马",300000.00);
        Car car2 = new Car("奔驰",500000.00);

        System.out.println(car1); // Car@4554617c
        System.out.println(car2); // Car@74a14482
    }
}

我们也可以实现自己从写toString方法在控制台中显示关于类的有用信息。

@Override
public String toString() {
    return "Car{" +
            "name='" + name + '\'' +
            ", price=" + price +
            '}';
}
// 再次运行上面的Test代码得
// Car{name='宝马', price=300000.0}
// Car{name='奔驰', price=500000.0}

八种基本数据类型没有toString()方法，只能使用相应的包装类才能使用toString()。