public class Dog extends Object{
}
与
public class Dog{
}
完全等价。那么Object有什么样的作用?为什么每个类要去继承Object呢?首先来看一下Object中包含的方法。
1. equals(Object obj)
2. finalize()
3. getClass
4. hashCode()
5. notify
6. notifyAll();
7. wait()
8. Clone()
9. toString()
其中的方法会被高频率的使用,为了实现代码复用,java 设计者就把这些常用的方法集中的放到了一个类中,这个类就是Object.
//toString
看equals之前需要先看下“==”,因为“==”是判断相等,equals也是判断相等,只是”==”主要用于判断基本数据类型的相等性,当然也可以直接判断两个对象。而equals主要判断对象内容。其中有很多细节,下面逐个说明:
先看“==”判断基本数据类型
public static void main(String[] args) {
int i = 1;
int j = 1;
boolean flag0 = true;
boolean flag1 = false;
System.out.println("i==j:"+(i==j));
System.out.println("flag0==flag1:"+(flag0==flag1));
}
运行结果:
i==j:true
flag0==flag1:false
以上实例非常简单,不多说明。
下面看一下对象的比较:
public static void main(String[] args) {
Dog dog0 = new Dog();
Dog dog1 = new Dog();
System.out.println(("dog0==dog1:")+(dog0==dog1));
}
运行结果:dog0==dog1:false
以上实例中的“==”,比较的是dog0的内存首地址和dog1 的内存首地址,由于dog0和dog1所指向的对象是在内存中开辟的两个空间,所以首地址是不一样的,此处打印输出false.
那么有没有办法看到内存首地址是多少呢?
有句话是说“办法总比问题多”,如果想看到内存首地址,我们需要再认识另外一个函数toString(),当我们直接打印某个对象引用的时候,该方法就会得到调用,看一个实例:
public static void main(String[] args) {
Dog dog0 = new Dog();
System.out.println(("dog0:")+dog0);
System.out.println(("dog0.toString():")+dog0.toString());
打印输出:
dog0:Dog@6b97fd
dog0.toString():Dog@6b97fd
两者完全等价,也就是说当我们直接打印输出引用与在引用上调用toString方法两者完全等价。
目前看到的Dog@6b97fd对我们来说没有任何的意义,为了让其变得有意义,我们可以对它进行重写。比如以上实例打印dog引用时,把dog的dogName打印输出,修改以上实例如下:
public class Dog{
private String dogName;
public String getDogName() {
return dogName;
}
public void setDogName(String dogName) {
this.dogName = dogName;
}
public String toString() {
return "dog's name is:"+dogName;
}
}
入口函数:
public class EqualsDemo {
public static void main(String[] args) {
Dog dog0 = new Dog();
dog0.setDogName("xiaobai");
System.out.println(("dog0:")+dog0);
}
}
打印输出:dog0:dog's name is:xiaobai
在此有个特殊情况,如果直接定义两个内容相同的String常量,两者会指向同样一个对象:
public static void main(String[] args) {
String str0 = "Hello";
String str1 = "Hello";
System.out.println("str0==str1"+(str0==str1));
}
打印输出:str0==str1:true
但是如果通过new的方式产生了String常量,则不会指向同样的对象,如一下实例:
public static void main(String[] args) {
String str0 = "Hello";
String str1 = new String("Hello");
System.out.println("str0==str1:"+(str0==str1));
}
运行程序,打印输出:str0==str1:false
Equals 方法时常和hashCode 结合使用,主要是比较对象内容,但是在默认情况下,比较的是内存首地址。看个实例:
创建两个类:
public class Dog{
}
另外一个类:
public class EqualsDemo {
public static void main(String[] args) {
Dog dog0 = new Dog();
Dog dog1 = new Dog();
System.out.println(("dog0.equals(dog1):")+dog0.equals(dog1));
}
}
打印输出:dog0.equals(dog1):false
可以通过覆盖equals方法来比较两个对象的内容,为了提高比较效率,java底层会先判断hashCode是否相等,如果hashCode相等,在来判断equals是否相等,如果hashCode不相等,则不会判断equals而直接返回false,只有hashCode相等,而且equals也相等,才会认为两个对象完全相等。对象相等,则hashCode也一定相等,为什么说hashCode相等,两个对象不一定相等呢?我们可以理解为hashCode是每个对象上的编码,比如假设A的hashCode是10,假设B的hashCode是11,C的hashCode是12,D的hashCode是13。
现在生成某个对象ABDhashCode为10+11+13=34,对象BBC的hashCode是11+11+12=34两个对象的hashCode相等,但是内容却是不相等的。
下面看一个equals与hashCode结合使用的例子,该实例中想通过判断dog 的名字,如果名字相等就认为两个对象相等,如果名字不相等就认为两个对象不相等。
public class Dog {
private String dogName;
public String getDogName() {
return dogName;
}
public void setDogName(String dogName) {
this.dogName = dogName;
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((dogName == null) ? 0 : dogName.hashCode());
return result;
}
public boolean equals(Object obj) {
if (obj == null)
return false;
final Dog other = (Dog) obj;
if (dogName.equals(other.dogName)){
return true;
}else{
return false;
}
}
}
其中的hashCode 方法根据对象属性加上基本的算法得到对象的hashCode并返回,得到hashCode的方法并不固定,可以对其修改。主要关注equals方法,if(obj==null)是在判断传入的对象是否为null,如果为null就返回false,认为两个对象不相等,其中if (dogName.equals(other.dogName))判断dogName字符串内容是否相等,如果相等,则返回true,否则返回false.
入口函数如下:
public static void main(String args[]){
Dog dog0 = new Dog();
dog0.setDogName("xiaobai");
Dog dog1 = new Dog();
dog1.setDogName("xiaobai");
System.out.println("dog0.equals(dog1):"+dog0.equals(dog1));
}
运行结果:dog0.equals(dog1):true