Object类
Object类：Java中lang包的类，是类层次结构的根类，每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。
Object类所含有的方法
- clone()
- equals(Object obj)
- finalize()
- getClass()
- hashCode()
- notify()
- notifyAll()
- toString()
- wait()
- wait(long timeout)
- wait(long timeout, int nanos)
一、 equals( )
boolen | equals(Object ob) : 指示其他某个对象是否与此对象"相等"。
● == 与 equals的对比（☆）
（1）== 运算符
- == ： 既可以判断基本类型，又可以判断引用类型
- == ： 如果判断基本类型，判断的是值是否相等。
- == ： 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象。
例如：
public static void main(String[] args){
A a = new A();
A b = a;
A c = b;
System.out.println( a == c);
System.out.println( b == c);
}
class B{}
class A extends B{}
创建了一个A对象，现在有一个a引用，指向了A对象，再有一个b引用，指向了A对象，最后再创建一个c引用也指向A对象，现在用 == 号来比较a与c，而由上述概念得知：== 符号在比较引用类型时，比较的是它们所指向的地址值，而明显a与c指向的都是A对象，即地址值相同，所以a与c比较后返回的是true，同理b == c返回的也是true。
现在增加一个判断
B bObj = a;
Sysout.println(bObj == c);
这时创建一个向上转型的对象，而此时bObj指向的也是A对象，所以最后比较的地址值与c依然相等，最后输出的结果也是true。
（2）equals方法
equals
- Object类中的方法，只能判断引用类型
- 默认判断的是地址值是否相等，子类中往往重写该方法，用于判断内容是否相等。比如：Integer，String
String类的equals方法（JDK源码）
//把Object的equals方法重写了,变成了比较两个字符串值是否相同
if(anObject instanceof String){//判断类型
String anotherString = (String)anObject; //向下转型
int n = value.lenghth;
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; //如果两个字符串的所有字符都相等,则返回true
}
}
return false //如果比较的不是字符串,则直接返回false
Object类的equals方法（JDK源码）
//Object 的 equals 方法默认就是比较对象地址是否相同
//也就是判断两个对象是不是同一个对象。
public boolean equals(Object obj){
return (this == obj);
}
Integer类的equals方法（JDK源码）
public boolean equals(Object obj){
if(obj instanceof Integer){
return value == ((Integer)obj).intValue();
}
return false;
}
Integer integer1 = new Integer(1000);
Integer integer2 = new Integer(1000);
System.out.println(integer1 == integer2); //false
System.out.println(integer1.equals(integer2)); //true
● equals方法练习
实例1
判断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样，则返回true，反之false。
创建Person类
class Person{
private String name;
private int age;
private char gender;
public Person(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
}
创建test类
如果现在在主方法里直接调用equals方法，则调用的是Object类中的equals方法，因为Person没有继承任何类，默认继承的是Object类，而Object类中的equals方法相当于 “==” 来判断，比较的是地址值，很明显现在创建了两个对象，ps1和ps2，直接对比的话肯定返回的值是false，显然和我们想要的true不同。
public class test {
public static void main(String[] args) {
Person ps1 = new Person("jack",19,'男');
Person ps2 = new Person("jack",19,'男');
System.out.println(ps1.equals(ps2)); //false
}
}
那如何得到正确的结果？那就是在Person中重写Object 的 equals方法。
在Person中重写Object的equals方法
//重写Object的equals方法
public boolean equals(Object obj){ //这里的Object obj指的是输出语句中传入的ps2
//判断如果比较的两个对象是同一个对象,则直接返回true
if(this == obj){ //这里的this指的是ps1
return true;
}
//类型判断
if(obj instanceof Person){ //是Person,才进行比较
//向下转型,因为现在需要得到obj的各个属性
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
//如果不是Person,则直接返回false
return false;
}
实例2
看下列代码，分析输出的值为多少？
class Person{ //类
public String name;
}
主方法
Person p1 = new Person();
p1.name = "ccc";
Person p2 = new Person();
p2.name = "CCC";
System.out.println(p1 == p2);
System.out.println(p1.name.equals(p2.name));
System.out.println(p1.equals(p2));
String s1 = new String("asdf");
String s2 = new String("asdf");
System.out.println(s1.equals(s2));
System.out.println(s1 == s2);
第一个输出语句
p1与p2的比较，由于是使用"=="，所以比较的是地址值，而此时p1、p2分别是new出来的，并不是同一个对象，所以最后的结果为false
System.out.println(p1 == p2); //false
第二个输出语句
p1.name是字符串，已经把equals方法重写了，所以p1与p2比较的就是内容，显然内容一直，所以得到的结果应为true
System.out.println(p1.name.equals(p2.name)); //true
第三个输出语句
由于p1与p2都是自定义的类（Person），而此时的Person类中并没有重写equals方法，那么使用的就是他的父类Object的equals方法，所以比较的还是两者的地址值，显然最后的结果为false
System.out.println(p1.equals(p2)); //false
第四个输出语句
由于创建的是String类型的对象，必然使用的是String类重写的equals方法，所以两者比较的是内容的差异，显然二者都是一致的，最后的结果为true
System.out.println(s1.equals(s2)); //true
第五个输出语句
显然两者比较的是地址值，指向的不是同一个对象，所以最后的结果为false
System.out.println(s1 == s2); //false
运行结果
● 实例3
看下面的代码输出的是什么值？
int it = 65;
float fl = 65.0f;
System.out.println("65和65.0f是否相等? " + (it == fl));
char ch1 = 'A'; char ch2 = 12;
System.out.println("65和 'A' 是否相等? " + (it == ch1));
System.out.println("12和ch2是否相等? " + (12 == ch2));
String st1 = new String("hello");
String st2 = new String("hello");
System.out.println("str1和str2是否相等? " + (str1 == str2));
System.out.println("str1是否equals str2?" + (str1.equals(str2)));
System.out.println("hello" == new java.sql.Date());
false，false，true，true，true，true
第一个输出语句
由于是"=="，所以判断的是值是否相等，而一个是int类型，一个是float类型，判断时自动转换，所以为true。
System.out.println("65和65.0f是否相等? " + (it == fl)); // true
第二个输出语句
同样是双等号，所以判断值是否相等，而 A 的ascll码值就为65，所以输出结果为true。
System.out.println("65和 'A' 是否相等? " + (it == ch1)); //true
第三个输出语句
同样是比较值，显然相等，所以输出结果为true。
System.out.println("12和ch2是否相等? " + (12 == ch2)); //true
第四个输出语句
两个对象str1、str2都是被new出来的新对象，所以地址值不同，结果为false
System.out.println("str1和str2是否相等? " + (str1 == str2)); //false
第五个输出语句
String类的equals方法必然重写，比较两者的值，相等，所以输出true。
System.out.println("str1是否equals str2?" + (str1.equals(str2))); //true
最后一个输出语句
编译器报错，因为编译器无法识别这两个对象的关系，它们既不是同一个类型，也没有继承关系，所以报错。
System.out.println("hello" == new java.sql.Date()); //报错
二、hashCode( )
hashCode( ) ：返回该对象的哈希码值。
hashCode
- 提高具有哈希结构的容器的效率。
- 两个引用，如果指向的是同一个对象，则哈希值肯定相同，反之则不同（特殊情况除外）
- 哈希值主要根据地址号来的，不能完全将哈希值等价于地址！
- 后续在集合中介绍hashCode的重写。
hashCode的使用
现创建三个对象，一个aa1、aa2、aa3，其中aa1与aa2是新创建的对象，而aa3是指向aa1创建的对象。
public class test {
public static void main(String[] args) {
AA aa1 = new AA();
AA aa2 = new AA();
AA aa3 = aa1;
System.out.println("aa1.hashCode() = " + aa1.hashCode());
System.out.println("aa2.hashCode() = " + aa2.hashCode());
System.out.println("aa3.hashCode() = " + aa3.hashCode());
}
}
class AA{}
现在看通过hashCode输出的结果：
显然aa1与aa3是同一个对象，所以输出的值一致。
三、toString( )
toString( ) ： 返回该对象的字符串表示。
-
默认返回：全类名（包名 + 类名） + @ + 哈希值的十六进制（通过hashCode得到的整数），子类往往重写toString方法，用于返回对象的属性信息。
-
重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式。
-
当直接输出一个对象时，toString方法会被默认的调用。
Object的toString( ) 原码
Object的toString() 原码
(1) getClass().getName() 类的全类名(包名 + 类名)
(2) Integer.toHexString(hashCode()) 将对象的hashCode值转成16进制字符串
public String toString(){
return getClass().getName() + "@" + Integer.toHexString(hashCode())
}
hashcode使用案例
创建Monster[name，job，sal]
直接使用toString
public class test {
public static void main(String[] args) {
Monster monster = new Monster("章鱼哥","恰人",1000);
System.out.println(monster.toString() + "hashCode值 = " + monster.hashCode());
}
}
class Monster{
private String name;
private String job;
private double sal;
public Monster(String name, String job, double sal) {
this.name = name;
this.job = job;
this.sal = sal;
}
}
运行效果
重写toString方法
class Monster{
private String name;
private String job;
private double sal;
public Monster(String name, String job, double sal) {
this.name = name;
this.job = job;
this.sal = sal;
}
//重写toString方法,输出对象的属性
//使用快捷键 alt + insert - >
@Override
//重写后,一般是把对象的属性值输出,当然程序员也可以自定义内容
public String toString() {
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
}
重写后继续调用monster，运行的结果如下所示：
当直接输出一个对象时，toString方法会被默认的调用。
还是以上面的代码为例，直接在输出语句中传入monster，实际上等价于monster.toString：
System.out.println(monster);//等价 monster.toString()
得到的结果如下所示：
但是可以注意到一个问题，那就是输出语句并没有重写hashcode，所以并没有输出哈希值。
四、finalize( )
finalize() ：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
finalize()
- 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。
- 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
- 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制。
finalize使用实例
public class test {
public static void main(String[] args) {
Car bmw = new Car("宝马");
//把bmw置空,此时Car现在就没人使用,就变为了垃圾对象
//这时垃圾回收器就会回收(销毁)这个对象(堆释放)
//在销毁对象前,会调用该对象的finalize方法
// 此时程序员就可以在finalize中,写自己的业务逻辑代码(比如释放资源:数据库链接,或者打开文件等等)
//如果程序员不重写finalize，那么就会默认调用Object类的finalize方法，如果程序员重写了finalize，就可以实现自己的逻辑。
bmw = null;
}
}
class Car{
private String name;
public Car(String name){
this.name = name;
}
}
1238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
