java学习之路 之 高级类特性1-Object类 及 练习题

Object 类
Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

public class Person {
... 
} 
//等价于：
public class Person extends Object {
...
}

例：

method(Object obj){…}//可以接收任何类作为其参数    
Person o=new Person();      
method(o);

Object类中的主要方法

= =： 
基本类型比较值:只要两个变量的值相等，即为true.
int a=5; if(a==6){…}
引用类型比较引用(是否指向同一个对象):只有指向同一个对象时，==才返回true.
Person p1=new Person();     
Person p2=new Person();      
if (p1==p2){…}
用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错；

equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。
只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。  
格式:obj1.equals(obj2)

特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：在这些类中重写了Object类的equals()方法。

toString() 方法
toString()方法在Object类中定义，其返回值是String类型，返回类名和它的哈希码值的十六进制形式。
在进行String与其它类型数据的连接操作时，自动调用toString()方法
Date now=new Date();
System.out.println(“now=”+now);  相当于      
System.out.println(“now=”+now.toString());   
可以根据需要在用户自定义类型中重写toString()方法
如String 类重写了toString()方法，返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于
System.out.println(s1.toString());
基本类型数据转换为String类型时，调用了对应包装类的toString()方法
int a=10;   System.out.println(“a=”+a);

练习题

class Point extends Object {
	
	private int x;
	private int y;
	
	public Point() {}
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	/* 这是Object类中的equals方法的代码, 比较烂, 不能实现真正的内容比较
	public boolean equals(Object obj) {
        return (this == obj);
    }*/
	
	@Override // 如果重写equals方法, 必须再重写hashCode方法, 因为两个对象的内容如果相等, 意味着两个对象的特征码也应该一样
	public boolean equals(Object obj) {
		// 比较两个对象的内容是否相等 
		// 比较的是左对象this, 右对象是obj 
		if (obj instanceof Point) { // 对象的真实类型判断, 如果是Point对象才进行比较
			if (this.x == ((Point)obj).x && this.y == ((Point)obj).y) {
				return true;
			}
		}			
		return false;
	}
	
	/* 这个方法是从Object类中继承而来, 计算出来的哈希码的特点是完全依据对象的地址来算的.
	public native int hashCode(); 哈希码称为散列码或特征码, 目的是散列不同的对象
	*/
	
	@Override // 特征码根据对象的属性来计算
	public int hashCode() {
		return Integer.parseInt(x + "" + y); // 1020 
	}	
}

class PointTest {
	
	public static void main(String[] args) {
		Point p1 = new Point(10, 20);
		Point p2 = new Point(10, 20);
		System.out.println(p1 == p2); // 比较两个引用变量的地址值 
		System.out.println(p1.equals(p2)); // 比较两个对象的内容是否相等
		
		System.out.println(p1.hashCode());
		System.out.println(p2.hashCode());
	}
}

/*
 Circle类, 包含radius属性
 创建两个半径都是15的圆对象, 保证两个对象调用equals方法返回true, 并且两个对象的特征码一致.	
*/
public class Circle {
	
	private int radius;
	
	public Circle() {}
	
	public Circle(int radius) {
		this.radius = radius;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Circle) {
			if (this.radius == ((Circle)obj).radius) {
				return true;
			}
		}
		return false;
	}
	@Override
	public int hashCode() {
		return Integer.parseInt("" + radius);
	}
	
	public static void main(String[] args) {
		Circle c1 = new Circle(15);
		Circle c2 = new Circle(15);
		System.out.println(c1.equals(c2));
		System.out.println(c1.hashCode());
		System.out.println(c2.hashCode());
	} 
}

/*
请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法，
使其判断当两个MyDate类型对象的年月日都相同时，结果为true，否则为false。    
public boolean equals(Object o)
*/
class TestEquals {  

	public static void main(String[] args) {
		MyDate m1 = new MyDate(14, 3, 1976);
		MyDate m2 = new MyDate(14, 3, 1976);

		if ( m1 == m2 ) {
			System.out.println("m1 == m2"); 
		} else {
			System.out.println("m1 != m2"); //m1 != m2
		}

		if ( m1.equals(m2) ) {
			System.out.println("m1 is equal to m2"); 
			// m1 is equal to m2
		} else {
			System.out.println("m1 is not equal to m2");
		} 
	} 
}

class MyDate {
	
	private int day;
	private int month;
	private int year;
	
	public MyDate() {}
	
	public MyDate(int day,int month,int year) {
		this.day = day;
		this.month = month;
		this.year = year;
	}
	
	@Override
	public boolean equals(Object o) {
		if (o instanceof MyDate) {
			if (this.day == ((MyDate)o).day || this.month == ((MyDate)o).month || this.year == ((MyDate)o).year) {
				return true;
			}
		} 
		return false;
	}
	
	@Override 
	public int hashCode() {
		return Integer.parseInt("" + year + month + day);
	}
}