一、介绍
类Object在 java.lang包中， java.lang默认引用
类0bject 是类层次结构的根类。每个类都使用Object 作为超类。所有对象（包括数组〉都实现这个类的方法。
二、类Object方法
1、equals方法
public boolean equals(Object obj)
==和equals方法对比
（1）== 运算符
是一个比较运算符，并不是方法。
- ==：既可以判断基本类型，又可以判断引用类型
- ==： 如果判断基本类型,判断的是值是否相等。示例: int i=10; double d=10.0;3.
- ==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
- == 判断基本数据类型
int num1 = 10;
double num2 = 10.0;
System.out.println(num1 == num2 );
- == 判断引用类型(同一个类)
public class Equals {
public static void main(String[] args) {
A a1 = new A();
A a2 = a1;
A a3 = a2;
System.out.println(a1 == a3);
System.out.println(a2 == a3);
}
}
class A {}
- == 判断引用类型(继承类，向上)
public class Equals {
public static void main(String[] args) {
A a1 = new A();
A a2 = a1;
A a3 = a2;
B bObj = a1;
System.out.println(bObj == a3);
}
}
class A extends B{}
class B {}
仍然相同，因为两个对象bObj 和 a3指向同一个内存空间。
（2）equals方法
- equals 是Object类中的方法，只能判断引用类型，如何看Jdk源码，看老师演示
IDEA中，“hello”.equals(“abc”); 选中equals，使用CTRL+B就可以看到源码 - 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如 Integer,String【看看String 和 Integer的equals 源代码】
- Object.java 中的 equals方法源码
public boolean equals(Object obj) {
return (this == obj);
}
上文说==操作符判断引用类型的时候，比较的是地址。所以《默认判断的是地址是否相等》。
- String.java 中的 equals方法源码
重写Object类中的equals方法
public boolean equals(Object anObject) {
if (this == anObject) {//anObject是他自己
return true;
}
if (anObject instanceof String) {//判断类型
String anotherString = (String)anObject;//向下转型
int n = value.length;//计算长度 = this.value.length
/*
static class String {
private final char value[];
}
*/
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;
}
- Integer.java 中的 equals方法源码
从源码可以看到 Integer 也重写了 Object 的 equals 方法，变成了判断两个值是否相同。
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
例题01
应用实例：断两个Person对象的内容是否相等，如果两个Person对象的各个属性值都一样，则返回true，反之false。
public class EqualsExercise01 {
public static void main(String[] args) {
Person p1 = new Person("jack",18,'m');
Person p2 = new Person("jack",18,'m');
Person p3 = new Person("mary",32,'f');
System.out.println(p1.equals(p2));
System.out.println(p1.equals(p3));
}
}
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;}
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof Person) {
Person p = (Person) anObject;
if (this.getName() == p.getName()
&& this.getAge() == p.getAge()
&& this.getGender() == p.getGender()) {
return true;
} else {
return false;
}
} else {
return false;
}
}
}
代码 improve：
这里的 this.name.equals(p.name) 是调用了String类中重载的equals方法。
return this.name.equals(p.name)
&& this.getAge() == p.getAge()
&& this.getGender() == p.getGender();
例题02
判断输出结果
Person p1 = new Person();
p1.name = "hspedu";
Person p2 = new Person();
p2.name = "hspedu";
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);
class Person {public String name;}
输出为
f
t
f
t
f
例题03
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 str1 = new String("hello");
String str2 = 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.Dateo):
T
？ ：【T】 字符的本质就是整数，int char基本数据类型比较数值。
？ ：【T】
F
T
？ ：【F】 编译器直接报错，左右不是同一个类型
2、hashCode方法
public int hashCode()
返回对象的哈希码值。 支持这种方法是为了散列表，如HashMap提供的那样 。
使用细节
- 提高具有哈希结构的容器的效率!
- 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
- 两个引用，如果指向的是不同对象，则哈希值是不一样的
- 哈希值主要根据地址号来的！，不能完全将哈希值等价于地址。
由类别Object定义的hashCode方法确实为不同对象返回不同的整数。 （这通常通过将对象的内部地址转换为整数来实现，但Java的编程语言不需要此实现技术。） - 案例演示[HashCode_.java]： obj.hashCode()[测试：A obj1 = new A(); A obj2 = new A(); A obj3 = obj1]
- 后面在集合中，hashCode如果需要的话，也会重写
public class HashCode_ {
public static void main(String[] args) {
AA aa = new AA();
AA aa2 = new AA();
System.out.println("aa.hashCode()="+aa.hashCode());
System.out.println("aa2.hashCode()="+aa2.hashCode());
AA aa3 = aa;
System.out.println("aa3.hashCode()="+aa3.hashCode());
}
}
class AA {}
3、toString方法
public String toString()
返回对象的字符串表示形式。
（1）默认返回：全类名+@+哈希值的十六进制
全类名=包名+类名
哈希值的十六进制=把 hashCode() 返回的值转换成十六进制
- String.java中的 toString 方法源码
public String toString() {
return getClass().getName()
+ "@"
+ Integer.toHexString(hashCode());
}
getClass().getName() 类的全类名（包名+类名）
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪","巡山",1000);
System.out.println(monster.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;
}
}
（2）重写toString方法
重写toString方法的目的是：在打印对象或拼接对象时，可以自动调用该对象的toString形式。
重写toString模板：alt+insert -> toString()。模板默认输出类的属性。
案例演示：Monster [name, job, sal] 案例：ToString_.java
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;
}
@Override
public String toString() {
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
}
（3）当直接输出一个对象时，toString方法会被默认的调用。
比如 System.out.println(monster); 就会默认调用 monster.toString()
Monster monster = new Monster("小妖怪","巡山",1000);
System.out.println(monster);
4、finalize方法
protected void finalize()
throws Throwable
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
1、当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作【演示 Finalize_.java】
资源：当对象连接数据库，这个连接就是一种资源。对象打开了一个文件，文件就是一种资源。
2、什么时候被回收：当某个对象没有任何引用时，则 jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁(回收)该对象，在销毁该对象前，会先调用 finalize方法。
3、垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制，但不是100%成功。测试：Car [name]
4、实际开发中，几乎不会运用 finalize。
class Car {
private String name;
public Car(String name) { this.name = name; }
}
Car bmw = new Car("宝马");
bmw = null;
bmw = null; 此时在堆中的对象没有引用，变成了垃圾
垃圾回收器就会回收（销毁）这个对象，就是把堆的空间释放，让别人可以使用这块空间。
在销毁对象前，会调用该对象的finalize方法。
程序员可以在这个方法中写自己的业务逻辑代码（比如释放 资源-数据库连接、文件。
如果程序员不重写finalize，就会调用Object类的finalize，即默认处理；
如果程序员重写finalize，就可以实现自己的逻辑。
- Object类默认的finalize方法如下
@Override
protected void finalize() throws Throwable {
super.finalize();
}
- 重写
package object_;
//finalize方法使用
public class Finalize_ {
public static void main(String[] args) {
Car bmw = new Car("宝马");
bmw = null; //此时在堆中的对象没有引用，变成了垃圾
System.out.println("程序退出");
}
}
class Car {
private String name;
public Car(String name) { this.name = name; }
@Override
protected void finalize() throws Throwable {
System.out.println("销毁汽车"+this.name);
System.out.println("销毁了xxx资源");
}
}
程序并不像我们想像的那样输出 finalize 的中重写的内容。不是对象一变成垃圾就回收，这样的性能太低。系统有自己的GC算法决定。
- 也可以通过System.gc()主动触发垃圾回收机制，但不是100%成功。
Car bmw = new Car("宝马");
bmw = null; //此时在堆中的对象没有引用，变成了垃圾
System.gc();//主动调用垃圾回收器
System.out.println("程序退出");
注意System.gc()方法不会让程序阻塞在该句，而是先向下运行，所以输出顺序可能和代码中不一样。
jdk12废弃了finalize，之前的 jdk 可以使用
扫一扫
1501
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
