Java温故而知新（7）Object类及其方法讲解

Java温故而知新（7）Object类及其方法讲解
一、java.lang.Object

　　java.lang包在使用的时候无需显示导入，编译时由编译器自动导入。

　　Object类是类层次结构的根，Java中所有的类从根本上都继承自这个类。

　　Object类是Java中唯一没有父类的类。

　　其他所有的类，包括标准容器类，比如数组，都继承了Object类中的方法。

二、Object类中的方法

　　构造方法：public Object()

　　文档中的类概览：

　　Java中的每个类都具有定义在Object类中的这些方法。

1、protected Object clone()

　　Creates and returns a copy of this object.

　　Object类中的说明是：

　　protected Object clone()

　　throws CloneNotSupportedException

　　这个方法比较特殊：

　　首先，使用这个方法的类必须实现java.lang.Cloneable接口，否则会抛出CloneNotSupportedException异常。

　　Cloneable接口中不包含任何方法，所以实现它时只要在类声明中加上implements语句即可。

　　第二个比较特殊的地方在于这个方法是protected修饰的，覆写clone()方法的时候需要写成public，才能让类外部的代码调用。

1.1.什么是"clone"？

在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B 任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用 new操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。

1.2.怎样应用clone()方法？

一个很典型的调用clone()代码如下：
```
class CloneClass implements Cloneable{ 
public int aInt; 
public Object clone(){ 
CloneClass o = null; 
try{ 
o = (CloneClass)super.clone(); 
}catch(CloneNotSupportedException e){ 
e.printStackTrace(); 
} 
return o; 
} 
｝ 
```
有三个值得注意的地方，

一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang包， java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。

另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。

应该说第三点是最重要的，仔细观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非 native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了 clone功能。对于第二点，也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为public。、

那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出 CloneNotSupportedException异常。

以上是clone的最基本的步骤，想要完成一个成功的clone，还要了解什么是"影子clone"和"深度clone"。

1.3什么是影子clone？

下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个int类型变量，并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1，然后调用clone()方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：
```
package clone; 
class UnCloneA { 
private int i; 
public UnCloneA(int ii) { i = ii; } 
public void doublevalue() { i *= 2; } 
public String toString() { 
return Integer.toString(i); 
} 
} 
class CloneB implements Cloneable{ 
public int aInt; 
public UnCloneA unCA = new UnCloneA(111); 
public Object clone(){ 
CloneB o = null; 
try{ 
o = (CloneB)super.clone(); 
}catch(CloneNotSupportedException e){ 
e.printStackTrace(); 
} 
return o; 
} 
} 
public class CloneMain { 
public static void main(String[] a){ 
CloneB b1 = new CloneB(); 
b1.aInt = 11; 
System.out.println("before clone,b1.aInt = "+ b1.aInt); 
System.out.println("before clone,b1.unCA = "+ b1.unCA); 

CloneB b2 = (CloneB)b1.clone(); 
b2.aInt = 22; 
b2.unCA.doublevalue(); 
System.out.println("================================="); 
System.out.println("after clone,b1.aInt = "+ b1.aInt); 
System.out.println("after clone,b1.unCA = "+ b1.unCA); 
System.out.println("================================="); 
System.out.println("after clone,b2.aInt = "+ b2.aInt); 
System.out.println("after clone,b2.unCA = "+ b2.unCA); 
} 
} 


/** RUN RESULT: 
before clone,b1.aInt = 11 
before clone,b1.unCA = 111 
================================= 
after clone,b1.aInt = 11 
after clone,b1.unCA = 222 
================================= 
after clone,b2.aInt = 22 
after clone,b2.unCA = 222 
*/ 
```
输出的结果说明int类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，int类型是真正的被clone了，因为改变了 b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是 b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。

大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。

1.4怎么进行深度clone？

把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();

程序如下：
```
package clone.ext; 
class UnCloneA implements Cloneable{ 
private int i; 
public UnCloneA(int ii) { i = ii; } 
public void doublevalue() { i *= 2; } 
public String toString() { 
return Integer.toString(i); 
} 
public Object clone(){ 
UnCloneA o = null; 
try{ 
o = (UnCloneA)super.clone(); 
}catch(CloneNotSupportedException e){ 
e.printStackTrace(); 
} 
return o; 
} 
} 
class CloneB implements Cloneable{ 
public int aInt; 
public UnCloneA unCA = new UnCloneA(111); 
public Object clone(){ 
CloneB o = null; 
try{ 
o = (CloneB)super.clone(); 
}catch(CloneNotSupportedException e){ 
e.printStackTrace(); 
} 
o.unCA = (UnCloneA)unCA.clone(); 
return o; 
} 
} 
public class CloneMain { 
public static void main(String[] a){ 
CloneB b1 = new CloneB(); 
b1.aInt = 11; 
System.out.println("before clone,b1.aInt = "+ b1.aInt); 
System.out.println("before clone,b1.unCA = "+ b1.unCA); 

CloneB b2 = (CloneB)b1.clone(); 
b2.aInt = 22; 
b2.unCA.doublevalue(); 
System.out.println("================================="); 
System.out.println("after clone,b1.aInt = "+ b1.aInt); 
System.out.println("after clone,b1.unCA = "+ b1.unCA); 
System.out.println("================================="); 
System.out.println("after clone,b2.aInt = "+ b2.aInt); 
System.out.println("after clone,b2.unCA = "+ b2.unCA); 
} 
} 

/** RUN RESULT: 
before clone,b1.aInt = 11 
before clone,b1.unCA = 111 
================================= 
after clone,b1.aInt = 11 
after clone,b1.unCA = 111 
================================= 
after clone,b2.aInt = 22 
after clone,b2.unCA = 222 
*/ 
```
可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在 CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。

要知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下 JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个 final类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和 StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是 SringBuffer对象，而且变量名仍是unCA）： o.unCA = new StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone();

还要知道的是除了基本数据类型能自动实现深度clone以外，String对象，Integer，Double等是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。

Clone中String和StringBuffer的区别

应该说明的是，这里不是着重说明String和StringBuffer的区别，但从这个例子里也能看出String类的一些与众不同的地方。

下面的例子中包括两个类，CloneC类包含一个String类型变量和一个StringBuffer类型变量，并且实现了clone()方法。在 StrClone类中声明了CloneC类型变量c1，然后调用c1的clone()方法生成c1的拷贝c2，在对c2中的String和 StringBuffer类型变量用相应的方法改动之后打印结果：
```
package clone; 
class CloneC implements Cloneable{ 
public String str; 
public StringBuffer strBuff; 
public Object clone(){ 
CloneC o = null; 
try{ 
o = (CloneC)super.clone(); 
}catch(CloneNotSupportedException e){ 
e.printStackTrace(); 
} 
return o; 
} 

} 
public class StrClone { 
public static void main(String[] a){ 
CloneC c1 = new CloneC(); 
c1.str = new String("initializeStr"); 
c1.strBuff = new StringBuffer("initializeStrBuff"); 
System.out.println("before clone,c1.str = "+ c1.str); 
System.out.println("before clone,c1.strBuff = "+ c1.strBuff); 

CloneC c2 = (CloneC)c1.clone(); 
c2.str = c2.str.substring(0,5); 
c2.strBuff = c2.strBuff.append(" change strBuff clone"); 
System.out.println("================================="); 
System.out.println("after clone,c1.str = "+ c1.str); 
System.out.println("after clone,c1.strBuff = "+ c1.strBuff); 
System.out.println("================================="); 
System.out.println("after clone,c2.str = "+ c2.str); 
System.out.println("after clone,c2.strBuff = "+ c2.strBuff); 
} 
} 
/* RUN RESULT 
before clone,c1.str = initializeStr 
before clone,c1.strBuff = initializeStrBuff 
================================= 
after clone,c1.str = initializeStr 
after clone,c1.strBuff = initializeStrBuff change strBuff clone 
================================= 
after clone,c2.str = initi 
after clone,c2.strBuff = initializeStrBuff change strBuff clone 
* 
*/ 
```
打印的结果可以看出，String类型的变量好象已经实现了深度clone，因为对c2.str的改动并没有影响到c1.str！难道Java把 Sring类看成了基本数据类型？其实不然，这里有一个小小的把戏，秘密就在于c2.str = c2.str.substring(0,5)这一语句！实质上，在clone的时候c1.str与c2.str仍然是引用，而且都指向了同一个 String对象。但在执行c2.str = c2.str.substring(0,5)的时候，它作用相当于生成了一个新的String类型，然后又赋回给c2.str。这是因为String被 Sun公司的工程师写成了一个不可更改的类（immutable class），在所有String类中的函数都不能更改自身的值。下面给出很简单的一个例子：
```
package clone; 
public class StrTest { 
public static void main(String[] args) { 
String str1 = "This is a test for immutable"; 
String str2 = str1.substring(0,8); 
System.out.println("print str1 : " + str1); 
System.out.println("print str2 : " + str2); 
} 
}
 /* RUN RESULT print str1 : This is a test for immutable print str2 : This is */ 
```
例子中，虽然str1调用了substring()方法，但str1的值并没有改变。类似的，String类中的其它方法也是如此。当然如果我们把最上面的例子中的这两条语句
```
c2.str = c2.str.substring(0,5); 
c2.strBuff = c2.strBuff.append(" change strBuff clone"); 
```
改成下面这样：
```
c2.str.substring(0,5); 
c2.strBuff.append(" change strBuff clone"); 
```
去掉了重新赋值的过程，c2.str也就不能有变化了，我们的把戏也就露馅了。但在编程过程中只调用
c2.str.substring(0,5); 语句是没有任何意义的。

应该知道的是在Java中所有的基本数据类型都有一个相对应的类，象Integer类对应int类型，Double类对应double类型等等，这些类也与String类相同，都是不可以改变的类。也就是说，这些的类中的所有方法都是不能改变其自身的值的。这也让我们在编clone类的时候有了一个更多的选择。同时我们也可以把自己的类编成不可更改的类。

2、boolean equals(Object obj)

　　Indicates whether some other object is "equal to" this one.

　　“==”运算符判断两个引用是否指向同一个对象。

　　对于Object类的equals()方法来说，它判断调用equals()方法的引用于传进来的引用是否一致，即这两个引用是否指向的是同一个对象。

　　Object类中的equals()方法如下：
```
public boolean equals(Object obj)

{

    return (this == obj);

}
```
　　即Object类中的equals()方法等价于==。

　　只有当继承Object的类覆写（override）了equals()方法之后，继承类实现了用equals()方法比较两个对象是否相等，才可以说equals()方法与==的不同。

　

　　equals()方法需要具有如下特点：

　　自反性（reflexive）：任何非空引用x，x.equals(x)返回为true。

　　对称性（symmetric）：任何非空引用x和y，x.equals(y)返回true当且仅当y.equals(x)返回true。

　　传递性（transitive）：任何非空引用x和y，如果x.equals(y)返回true，并且y.equals(z)返回true，那么x.equals(z)返回true。

　　一致性（consistent）：两个非空引用x和y，x.equals(y)的多次调用应该保持一致的结果，（前提条件是在多次比较之间没有修改x和y用于比较的相关信息）。

　　约定：对于任何非空引用x，x.equals(null)应该返回为false。

并且覆写equals()方法时，应该同时覆写hashCode()方法，反之亦然。

Object类和String类equals方法的区别

相信很多学习过Java的同学都知道，在比较两个String对象的内容是否相同时是使用equals方法的

如：
```
    String str1=new String（“A”）;

    String str2=new String（“B”）;

    String str3=new String（“B”）;

    boolean result1= str1.equals(str2);

    boolean result2= str2.equals(str3);

    System.out.println(result1);

    System.out.println(result2);
```
则输入的result1为false，result2为true。因为str1与str2的内容不相同，而str2与str3内容相同都是“B”。

而在String类中使用“==”时，比较的是两个String对象的引用是否指向同一个对象，如
```
    String str4=new String（“B”）;

    String str5=new String（“B”）;

    String str6=str5;

    boolean result3=（str4==str5）;

    boolean result4= (str5==str6);

    System.out.println(result3);

    System.out.println(result4);
```
则输入的result3为false，result4为true。因为str4、str5虽然内容相同但它们是不同的对象，就像两个同样的杯子装着同样多的水，可它们是不同的，result3为false。而str5、str6是指向同一个String对象的，所以result4为true。

再说明一点，String str = new String("abc")和String str ="abc"是有一点小区别的，对于new出来的String对象，是每new一个内存里生成一个，也就是说其允许存在内容相同的重复对象。而String str ="abc"这种形式是不允许存在内容相同的重复对象，只要内存已经存在了，就不再新生成，而是把新的引用指向原来的对象。

以上是String类equals方法和"=="的区别和联系。下面再说说Object类的equals方法。

大家首先要明确一点Object类是所有Java类的父类，所有的Java类都要继承Object类，所以通常我们写程序的时候不显式声明继承Object类，而是默认继承Object类。

在Object类的equals方法的本质其实是和“==”一样的，都是比较两个对象引用是否指向同一个对象（即两个对象是否为同一对象）。那为什么String类的equals方法却又是比较两个String对象的内容是否相同呢？

原来是这样的，String类继承Object类后，也继承了equals方法，但String类对equals方法进行了重写，改变了equals方法的比较形式。其实很多其他类继承Object类后也对equals方法进行了重写。

3、int hashCode()

　　Returns a hash code value for the object.

　　当你覆写（override）了equals()方法之后，必须也覆写hashCode()方法，反之亦然。

　　这个方法返回一个整型值（hash code value），如果两个对象被equals()方法判断为相等，那么它们就应该拥有同样的hash code。

　　Object类的hashCode()方法为不同的对象返回不同的值，Object类的hashCode值表示的是对象的地址。

　　hashCode的一般性契约（需要满足的条件）如下：

　　1.在Java应用的一次执行过程中，如果对象用于equals比较的信息没有被修改，那么同一个对象多次调用hashCode()方法应该返回同一个整型值。应用的多次执行中，这个值不需要保持一致，即每次执行都是保持着各自不同的值。

　　2.如果equals()判断两个对象相等，那么它们的hashCode()方法应该返回同样的值。

　　3.并没有强制要求如果equals()判断两个对象不相等，那么它们的hashCode()方法就应该返回不同的值。即两个对象用equals()方法比较返回false，它们的hashCode可以相同也可以不同。但是应该意识到，为两个不相等的对象产生两个不同的hashCode可以改善哈希表的性能。

4、String toString()

　　Returns a string representation of the object.

　　当打印引用，如调用System.out.println()时，会自动调用对象的toString()方法，打印出引用所指的对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，因此每个类都有toString()方法。

　　Object类中的toString()方法定义如下：
```
public String toString()

{

    return getClass().getName() + "@" + Integer.toHexString(hashCode());

}
```
通过重写toString()方法实现自定义的描述输出。

参考资料推荐

　　官方文档和jdk中的源代码src。

　　帮助格式的文档下载：http://www.allimant.org/javadoc/index.php
相关阅读:
C++ 函数返回数组指针的问题
 cmake 静态调用 c++ dll 的类的一个例子（Clion IDE）[更新1：增加1.模版的应用，2.ma 的算法]
一月5日
 一月5日
 一月5日
 一月5日
 一月5日
 一月5日
 一月5日
 一月5日
原文地址：https://www.cnblogs.com/sdgf/p/4931201.html