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;
}
}