Java类的共同父类Object

Java.lang.Object类是所有Java类的最高层次父类。其内部不存在任何属性，但是存在几个经典方法如下:

一.public int hashcode()–功能是返回当前对象的哈希码，系统会自动的给每个Java对象自动创建的整型编号。

public class Person {
private int age;
public Person(int age){
this.age = age;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
public class hashcode {

public static void main(String[] args) {    // TODO Auto-generated method stub    Person p1 = new Person(18);    Person p2 = new Person(18);    int handle1 = p1.hashCode();//获取p1的哈希码    System.out.println(p1);//输出格式:包名+@+哈希码十六进制表示    System.out.println(handle1);//输出哈希码<整型>}

}
输出结果:
com.hdu.edu.person.Person@2a139a55
705927765
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1.在一个运行的进程中，相等的对象含有相等的哈希码，不相等的对象一定不含有相等的哈希码？<错>，含有相等的哈希码的对象相等?<错>。
2.对象到哈希码的映射，可能为双射或者内射。

二.public String toString()–功能以字符串形式返回当前对象的信息。

public String toString(){
return getClass().getName()+
“@”+Integer.toHexString(hashcode());
}
1
2
3
4
Java语言允许子类对父类中继承来的方法进行重写，以改变其实现细节，因此我们可以在自己定义的类中去重写其toStirng()方法，以提供更适用的说明信息。

三.public boolean equals(Object obj)–功能是比较当前对象和方法参数obj所引用的对象两者的等价性。
基本类型数据比较的是数据的值，引用类型数据比较则是对象的句柄，即对象的hashcode()编码或者引用类型的变量的值，而非对象本身。

public class TestEquals{
public static void main(String args[]){
int i=5,j=5;
System.out.println(i==j);
Person p1 = new Person(18);
Person p2 = new Person(18);
if(p1 == p2){
System.out.println(“p1==p2”);
}
else
{
System.out.println(“p1!=p2”)
}
if(p1.equals(p2)){
System.out.println(“p1 is equals p2”);
}
else{
System.out.println(“p1 is not equals to p2”);
}
p2 = p1;
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
true
p1!=p2
p1 is not equal to p2
true
true
1
2
3
4
5
equals方法在比较一些特定的引用类型数据时，允许改变先前严格的等价性标准——只要两个对象同为上述的特例类型且内容相同，equals即为等价，==则无法变通。

比如我写的Person类中的equals方法重写

public boolean equals(Object o){
if(o instanceof Person){
Person p = (Person)o;
if(this.age == p.age){
return true;
}else{
return false;
}
}
return false;
}

//return (o instanceof person)&&(((person)o).age==this.age);
1
2
3
4
5
6
7
8
9
10
11
12
13
四.protected void finalize()throws Throwable{}
Java运行时环境中的垃圾回收器销毁对象之前，会自动调用该对象的finalize()方法，然后释放对象的内存空间。protected使得外界(子类以外的范围)对于该方法是不可见的。要使其发挥作用，应该在子类中重写finalize()方法，并且修饰符改成public，否则重写没有实际意义。

public class Person{
private String name;
public Person(String name){
this.name = name;
System.out.println(“创建person对象，name:”+name);
}
public void finalize(){
System.out.println(“销毁person对象，name:”+name);
}
}

public class TestFinalize{
public static void main(String args[]){
for(int i=0;i<10;i++){
Person p = new Person(“Tom”+i);
for(int j=0;j<1000;j++)
String[] test = {new String(“Assd”),new String(“Billy”),new String(“Kessy”)}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
内层for()循环达到消耗内存空间的作用，垃圾回收操作是完全透明的，程序无法控制回收机制，除非内存空间不足，否则不会试图释放内存。所以，finalize()方法最终是否会执行，以及何时会执行都是不确定的，即使显示调用System.gc()或者Runtime.gc()强制也无法保证清理无用空间。finalize()并不可靠，在应用开发中不建议使用。