java之Object类

Object类是类层次结构的根类。
每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。

所有类都是Object类的子类。

1、public String toString()方法：返回该对象的字符串表示。
通常，toString方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明且易于读懂的信息表达式。建议所有子类都重写此方法。

示例：

class Demo{
	public static void main(String[] args) {
		Student s = new Student();
		System.out.println(s.toString());//调用toString方法，toString是可以省略的，直接用对象的名称，例如：System.out.println(s);
	}
}

class Student{
	private String name;
	private int sid;
	private int age;
	public Student() {}
	public Student(int sid,String name,int age) {
		this.sid = sid;
		this.name = name;
		this.age = age;
	}
}

输出结果：

Demo.Student@279f2327

重写toString方法：

class Demo{
	public static void main(String[] args) {
		Student s = new Student(1,"飞飞",18);
		System.out.println(s.toString());
	}
}

class Student{
	private String name;
	private int sid;
	private int age;
	public Student() {}
	public Student(int sid,String name,int age) {
		this.sid = sid;
		this.name = name;
		this.age = age;
	}
	//重写Object类中的toString方法，注意，声明要完全一样
	public String toString() {//以后想要输出对象信息的时候，就不用写类似print的方法，直接重写toString方法就可以了
		return "sid="+sid+","+"name="+name+","+"age="+age;
	}
}

输出结果：

sid=1,name=飞飞,age=18

2、public boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。equals方法在非空对象引用上实现相等关系：
（1）自反性：对于任何非空引用值 x，x.equals(x) 都应返回true。
（2）对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回true。
（3）传递性：对于任何非空引用值 x，y，和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回true。
（4）一致性：对于任何非空引用值 x 和 y ，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
（5）对于任何非空引用值 x，x.equals(null) 都应返回false。
Object类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y具有值 true）。

源代码：

public boolean equals(Object obj){
	return (this == obj);
}
//比较的是两个对象的内存地址是否相同

示例1：

class Demo1 {
	public static void main(String[] args) {
		Student s = new Student(1,"飞飞",18);
		System.out.println(s);
		Student s2 = new Student(2,"备备",20);
		boolean b = s.equals(s2);
		System.out.println(b);
	}
}

输出结果：

sid=1,name=飞飞,age=18
false

示例2：

class Demo2 {
	public static void main(String[] args) {
		Student s = new Student(1,"飞飞",18);
		System.out.println(s);
		Student s2 = new Student(1,"飞飞",18);
		boolean b = s.equals(s2);
		System.out.println(b);
	}
}

输出结果：

sid=1,name=飞飞,age=18
false
//虽然值一样，但依然是不同的两个对象

如果要做到认为这两个对象是同一个对象，按下面这种做法是不行的：

class Demo3 {
	public static void main(String[] args) {
		String str1 = new String("备备");
		String str2 = new String("备备");
		System.out.println(str1==str2);
	}
}

输出结果：

false

但是，调用equals方法就行：

class Demo4 {
	public static void main(String[] args) {
		String str1 = new String("备备");
		String str2 = new String("备备");
		System.out.println(str1.equals(str2));
	}
}

输出结果：

true

因为String类重写了equals方法，源代码：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
    	String anotherString = (String)anObject;
    	int n = value.length;
    	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;
}

重写equals方法，来实现两个对象的比较

class Demo5{
	public static void main(String[] args) {
		Student s = new Student(1,"飞飞",18);
		Student s2 = new Student(1,"飞飞",18);
		boolean b = s.equals(s2);
		System.out.println(b);
	}
}
class Student{
	private String name;
	private int sid;
	private int age;
	public Student() {}
	public Student(int sid,String name,int age) {
		this.sid = sid;
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj) {
	    if (this == obj) {
	        return true;
	    }
	    if (obj instanceof Student) {
	    	Student s = (Student)obj;
	    	if(!this.name.equals(s.name)) {
	    		return false;
	    	}
	    	if(this.sid!=s.sid) {
	    		return false;
	    	}
	    	if(this.age!=s.age) {
	    		return false;
	    	}
	    	return true;
	    }
	    return false;
	}
}

输出结果：

true

3、protected void finalize()throws Throwable
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写finalize方法，以配置系统资源或执行其他清除。（一般不重写）