Java——根父类

  Java中规定：
  如果一个类没有显式声明它的父类（即没有写extends xx），那么默认这个类的父类就是java.lang.Object。
  
  类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
 
  如何理解根父类？
  （1）所有对象（包括数组）都实现这个类的方法。
  换句话说Object类中声明的方法，所有引用数据类型（包括数组）中都有
  （2）所有类的对象的实例化过程，都会调用Object的实例初始化方法
  （3）所有的对象都可以赋值给Object的变量
  或者说Object类型的变量，形参，数组可以接收任意类型的对象。
  
  1.toString()方法

/*
 * java.lang.Object类型的方法：
 * （1）public String toString()
 * 		用于返回对象的信息，类似于我们原来写的getInfo()，建议所有子类重写。
 *		如果没有重写：返回的字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。
 *
 *	如果你直接打印一个对象，或者用对象与字符串进行拼接，默认情况下会自动调用这个对象的toString()
 *  如何重写？ Alt + Shift  + S  选择Generate toString。。。。
 */
public class TestMethod {
	public static void main(String[] args) {
		Employee emp = new Employee("杨洪强", 24, 25000);
		System.out.println(emp.toString());
		//com.atguigu.test04.Employee@15db9742
		System.out.println(emp.hashCode());//366712642（十进制）--》十六进制15db9742
		
		System.out.println(emp);
		//com.atguigu.test04.Employee@15db9742  重写之前打印的
		//Employee [name=杨洪强, age=24, salary=25000.0]重写后打印
	}
}
class Employee{
	private String name;
	private int age;
	private double salary;
	public Employee(String name, int age, double salary) {
		super();
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public Employee() {
		super();
	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}
	
}

2.getClass()

/*
 * java.lang.Object的方法：
 * （2）public final Class getClass()：返回此 Object 的运行时类。
 */
public class TestMethod2 {
	public static void main(String[] args) {
		Father f = new Son();
		//此时f就有两个类型，编译时类型，Father，运行时类型，Son
		Class c = f.getClass();
		System.out.println(c);
		
		Object obj = 12;//Integer
		System.out.println(obj.getClass());
	}
}
class Father{
	
}
class Son extends Father{
	
}

3.finalize()方法

/*
 * java.lang.Object的方法：
 * （3）protected void finalize()：
 * 	当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器（GC）调用此方法。  即不是程序员手动调用
 * 	子类重写 finalize 方法，以配置系统资源或执行其他清除。
 * 
 *  什么情况下调用？
 *  ①某个对象确定要被回收了，比喻成“留临终遗言”
 *  ②Java程序员是否无法确定具体哪个时间点会调用
 *  ③它是由GC调用的
 *  ④每一个对象，finalize()只能被调用一次。
 *  如果某个对象在被GC回收之前复活了，那么再死的时候，就不会调用finalize()
 *  当我们在finalize()方法中又让一个引用指向了当前对象this,那么这个对象就复活。
 *  
 *  面试题：final，finalize，finally的区别？
 */
public class TestMethod3 {
	public static void main(String[] args) throws InterruptedException {
		for (int i = 1; i <=10; i++) {
			MyClass my = new MyClass();
			//for循环体中局部变量，每一次循环，都是一个新的局部变量，my指向的对象，在一次循环之后就变为垃圾对象了
		}
		
		//通知垃圾回收器，尽快来回收
		System.gc();//但是不能保证立刻马上过来
		
		Thread.sleep(1000);//休眠，暂停1秒 =1000毫秒
	}
}
class MyClass{

	@Override
	protected void finalize() throws Throwable {
		System.out.println("轻轻的我走了，正如我轻轻的来....");
	}
	
}

4.hashcode()方法、equals()方法

/*
 * java.lang.Object的方法：
 * （4）
 * public int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。
 * 		哈希码值是用这个对象的信息（属性值），通过某种算法，计算出来的一个int值。就好比我们身份证号码代表一个人的信息。
 * 		理想状态下，那么每一个对象都应该有一个唯一的哈希码值。
 * 	
 * 		现实中，两个不同的对象，可能它的哈希码值相同。	
 * 		认为：
 * 			如果两个对象的哈希码值不同，就可以认为这个两个对象一定不“相等”，
 * 		但是，如果两个对象的哈希码值相同，我们不能认为这个两个对象就一定“相等”，可能相同，也可能不同。
 * 
 * public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。 
 * 		换句话说，如果最终要确定两个对象是否“相等”要依据equals方法。
 * 
 * 默认情况下，Object类中实现的equals方法，即如果我们自己写的类，没有重写equals方法的话，那么它的比较是等价于“==”，比较的是对象的“地址值”
 * 我们可以选择进行重写：
 * （1）当此方法equals被重写时，通常有必要重写 hashCode 方法
 * 为什么？
 * 因为：
 * 	 Java中规定 ①如果两个对象调用equals方法返回true，那么这两个对象的hashCode值必须相同
 * 			②如果两个对象的hashCode值不同，那么调用equals方法必须是false
 * 			③如果两个对象的hashCode值相同，那么调用equals方法可能true也可能false
 * 
 * （2）重写equals方法时，要遵循几个原则
 * ①自反性：  x.equals(x)一定true
 * ②对称性：x.equals(y) 和y.equals(x)结果一样
 * ③传递性： x.equals(y)是true,y.equals(z)也是true，那么x.equals(z)一定true
 * ④一致性：只要参与equals比较的属性值没有修改过，那么无论何时调用，结果都应该一样
 * ⑤对于任何非空引用值 x，x.equals(null) 都应返回 false
 */
public class TestMethod4 {
	public static void main(String[] args) {
/*		String s1 = "Aa";
		String s2 = "BB";
		System.out.println(s1.hashCode());//2112
		System.out.println(s2.hashCode());//2112
*/	
		Circle c1 = new Circle();
		c1.radius = 1;
		
		Circle c2 = new Circle();
		c2.radius = 1;
		
		System.out.println(c1 == c2);//false
		System.out.println(c1.equals(c2));//false（重写前） true（重写后）
		
		//回忆
		String str1 = new String("hello");
		String str2 = new String("hello");
		System.out.println(str1 == str2);//false
		System.out.println(str1.equals(str2));//true  因为String类型重写了equals方法
		
		System.out.println("----------------------------");
		String s1 = "hello";//特殊，因为s1和s2指向同一个常量对象，地址值是同一个
		String s2 = "hello";
		System.out.println(s1 == s2);//true
		System.out.println(s1.equals(s2));//true
	}
}
class Circle{
	double radius;

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		long temp;
		temp = Double.doubleToLongBits(radius);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Circle other = (Circle) obj;
		if (Double.doubleToLongBits(radius) != Double.doubleToLongBits(other.radius))
			return false;
		return true;
	}
	
}