Object类是Java所有类的始祖,在Java中每个类都是由它扩展而来。如果一个类没有指出它的超类,Object就被认为是这个类的超类。JDK文档中这样描述Object类
Object
is the root of the class hierarchy. Every class hasObject
as a superclass. All objects, including arrays, implement the methods of this clas
s.Object类中的方法大部分为native方法,他们非常重要,因为所有类都有这些方法。
1 equals方法
Object类中的equals方法用于检测一个对象是否等于另一个对象。在Object类中,这个方法将判断两个对象是否具有相同的引用,如果具有相同的引用,他们一定是相等的。
public boolean equals(Object obj) {
return (this == obj);
}
它的源码很简单,仅仅用了一个”==“进行判断。
1.1java对equals的规定
java语言规范要求equals方法具有以下的特性
- 自反性:对于任何非空引用x,x.equals(x)应该返回true
- 对称性:对于任何引用x和y,当且仅当y.equals(x)返回true,x.equals(y)也应该返回true
- 传递性:对于任何引用x,y,z,如果x.equals(y)返回true,y.equals(z)返回true,x.equals(z)也应该返回true
- 一致性:如果x和y引用的对象没有发生变化,那么返回调用x.equals(y)应该返回同样的结果。
- 对于任意非空引用x,x.equals(null)返回false。
The equals
method implements an equivalence relation on non-null object references:
- It is reflexive: for any non-null reference value
x
,x.equals(x)
should returntrue
.
- It is symmetric: for any non-null reference values
x
andy
,x.equals(y)
should returntrue
if and only ify.equals(x)
returnstrue
. - It is transitive: for any non-null reference values
x
,y
, andz
, ifx.equals(y)
returnstrue
andy.equals(z)
returnstrue
, thenx.equals(z)
should returntrue
. - It is consistent: for any non-null reference values
x
andy
, multiple invocations ofx.equals(y)
consistently returntrue
or consistently returnfalse
, provided no information used inequals
comparisons on the objects is modified. - For any non-null reference value
x
,x.equals(null)
should returnfalse
.
1.2 重写equals方法
1.2.1 自反性
1.2.2 对称性
public class IgnoreString {
private final String str;
public IgnoreString(String str)
{
this.str=str;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof String)
{
return str.equalsIgnoreCase(obj.toString());
}
return false;
}
public static void main(String[] args) {
String s="abc";
IgnoreString ignoreString=new IgnoreString("ABc");
System.out.println(s.equals(ignoreString));
System.out.println(ignoreString.equals(s));
}
}
正如所料,ignoreString.equals(s)返回了true,然而它显然不满足自反性。
1.2.3编写equals方法的建议
- 显式参数命名为otherObject,稍后需要将它转换成另一个叫做other的变量
- 检测this与otherObject是否引用同一个变量
这条语句只是一个优化。实际上,这是一种经常采用的形式。因为计算这个等式要比一个一个地比较类中的域所付出的代价小得多。<span style="font-size:18px;">if(this==otherObject) return true;</span>
- 检测otherObject是否为null,如果为null,返回false。这项检测是很必要的
<span style="font-size:18px;">if(otherObject==null) return false</span>
- 比较this与otherObject是否属于同一个类。如果equals的寓意在每个子类中有所改变,就是用getClass检测:
如果所有的子类都有统一的语义,就是用instanceof检测<span style="font-size:18px;">if(getClass!=otherObject.getClass())return false;</span>
<span style="font-size:18px;">if(!(otherObject instanceof ClassName)) return false</span>
- 将otherObject转换为对应的类类型变量
<span style="font-size:18px;">ClassName other=(ClassName) otherObject</span>
- 现在开始对所有需要比较的域进行比较。是用==比较基本类型域,是用equals比较对象域。如果所有的域都匹配,就返回true;否则返回false;如果在子类中重新定义equals,就要在其中包含调用super.equals(other)
2 hashCode方法
2.1 散列码的特点
散列码(hash code)是由对象到处的一个整型值。散列码没有规律,如果x和y是两个不同的对象,x.hashCode()和y.hashCode()基本不会相同。Object类每个对象都有一个默认的散列码,其值为对象的储存地址。
- 在Java应用的一次执行过程当中,对于同一个对象的hashCode方法的多次调用,他们应该返回同样的值(前提是该对象的信息没有发生变化)。
- 对于两个对象来说,如果使用equals方法比较返回true,那么这两个对象的hashCode值一定是相同的。
- 对于两个对象来说,如果使用equals方法比较返回false,那么这两个对象hashCode值不要求一定不同(可以相同,可以不同),但是如果不同则可以提高应用的性能。
- 对于Object类来说,不同的Object对象的hashCode值是不同的,因为Object类的hashCode值表示的是对象的地址)。
2.2 重写hashCode方法
下面是String类的hashCode()方法
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
如果重新定义equals方法,就必须重新定义hashcode方法,以便用户可以将对象插入到hashmap等集合中。另外,最好使用null安全的方法。如果其参数为null,这个方法返回0,否则返回对参数调用hashCode的结果。
3 toString方法
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
toString方法,它用于返回表示对象值的字符串。从源码可以看出,这个返回的字符串是对象类的名字@它的16进制地址(散列码)。
随处可见toString方法的原因是:只要对象与一个字符串通过操作符”+“进行连接,Java编译就会自动调用toString方法,以便获得对象的字符串描述。
Java工程师建议程序员为自定义的类增加toString方法。这样可以很好的利用的日志。
4 clone方法
首先要弄懂为什么要clone一个对象,为什么普通的赋值(=)不行?
我们经常遇到这种情况,需要得到一个对象,但是又不想对这个对象产生任何影响,既对克隆对象任何的属性修改都不会影响到原对象。在普通的=赋值的情况下,两个对象引用同一个位置,显然不能满足这种需求,这就需要进行“深拷贝”。
在Object类有这样一个方法,可以产生原对象的一个拷贝。不过这个方法是protected的,也就是说任何一个自定义的类都不能调用clone方法。这里来看一下Object类实现的clone方法,它是一个native的方法。对于这个clone方法,我们希望的是拷贝的时候,对它的各个域都进行拷贝。这对于基本数据类型或者数值来说,这个clone方法显然是没有问题的。但是如果对象中包含了对子对象的引用,拷贝的结果就会出问题。因为默认的克隆操作是浅拷贝。
因此更多的情况,我们需要重新定义clone方法。对于每个类都需要作出如下判断:
- 默认的clone方法是否满足要求。
- 默认的clone方法是否能够通过调用子对象的clone得到修补。
- 是否不应该使用clone。
- 实现Cloneable接口
- 使用public访问修饰符重新定义clone方法
这里的Cloneble是一个mark interface,它没有定义任何方法,仅仅是为了表明类设计者要进行克隆方法的重写。如果没有实现这个接口,又重写了clone方法,就会产生一个checked exception。
所有的数组类型都包含一个clone方法,这个方法被设为public,可以利用这个方法创建一个包含所有数据元素的一个新数组。