Object类
Object类是类结构层次的根类。每一个类都使用Object类作为超类。所有对象(包括数组)都实现了这个类的方法。
equals
equals是Object类的一个方法,只能判断引用类型。
equals与 == 的区别
(1)equals是一个方法,==是一个比较运算符。
(2)==可以判断基本数据类型,也可以判断引用数据类型。
(3)==如果判断的是基本数据类型,那么就是判断值是否相等。
(4)==如果判断的是引用数据类型,那判断的是不是同一个对象。
public class Equalsexe {
public static void main(String[] args) {
A a = new A();
A b = a;
A c = b;
//我们定义的是a指向一个A的对象,我们将a赋给b和c,所以我们的a,b,c都是指向的A对象。
System.out.println(a.equals(b));//判断a与b是否为同一个对象
System.out.println(b.equals(c));//判断b与c是否为同一个对象
System.out.println(b == c);//判断b与c是否为同一个对象
}
}
class A{}
true
true
true
public class Equalsexe {
public static void main(String[] args) {
B ob = a;//向上转型
System.out.println(ob == c);//我们的b是指向a的,所以说是相等的true
}
}
class B{}
class A extends B{}
true
重写equals方法
重写方法,使判断内容相同就输出true,而不是判断对象是否相同。
public class Test {
public static void main(String[] args) {
Person p1 = new Person("jeck",20,'男');
Person p2 = new Person("jeck",20,'男');
//重写之前,该equals是调用Object类的equals方法
System.out.println(p1.equals(p2));
//重写之后,调用的是Person类的equals方法
System.out.println(p1.equals(p2));
}
}
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 String setName() {
return name;
}
public int getAge() {
return age;
}
public int setAge() {
return age;
}
public char getGender() {
return gender;
}
public char setGender() {
return gender;
}
//重新equals
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj instanceof Person){
Person p = (Person)obj;//向下转型,去访问子类特有的对象
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
return false;
}
}
false
true
finalize()
当垃圾回收器确定不存在更多对象对其引用的时候,由对象的垃圾回收器调用此方法。
(1)当对象被回收时,系统自己调用该对象的finalize方法,子类可以重写该方法,做一些资源的释放的操作。
(2)什么时候被回收:当某个对象没有任何引用时,则jvm就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来销毁该对象,在销毁该对象前,会调用finalize方法。
(3)垃圾回收机制的调用:有系统来决定,也是可以通过Systen.gc()主动触发垃圾回收机制。
public class Test {
public static void main(String[] args) {
Car bmw = new Car("宝马");
System.out.println(bmw);
//断开连接
bmw = null;
System.out.println(bmw);
//此时car对象就是一个垃圾对象,垃圾回收器就会销毁(回收)对象,会调用该对象的父类的finalize方法
//程序员就可以在finalize中,写一些自己的业务逻辑代码,进行一些操作:如释放资源,数据库连接等等
//如果程序员不重写该方法,那么系统会自动调用父类(object)默认的finalize方法
//如果重写,那么就会调用子类的重写的finalize方法
//主动调用垃圾回收机制
System.gc();
System.out.println("我们退出程序...");
}
}
class Car{
private String name;
public Car(String name) {
this.name = name;
}
//重写finalize
public void finalize() throws Throwable{
System.out.println("我们销毁汽车"+name);
System.out.println("释放资源操作...");
}
}
com.zlqedu.finalize_.Car@5e91993f
null
我们退出程序...
我们销毁汽车宝马
释放资源操作...
我们可以看到,最后的输出结果顺序和一边的程序执行流程不同,先输出了我们退出程序,这里确实先执行了我们的system.gc()方法,并且继续向下执行,这里是正常现象。
hashCode()
返回该对象的哈希码值,支持此方法是为了提高哈希表的性能。
注意事项:
(1)提高具有哈希结构的容器的效率。
(2)如果指向的是同一个对象,则哈希值肯定是一样的。
(3)如果指向的不是同一个对象,那么哈希值是不一样的。
(4)哈希值主要是根据地址号来的。不能完全将哈希码值等价于地址。
public class Test {
public static void main(String[] args) {
//new一个对象
AA a = new AA();
//b和a指向同一个对象
AA b = a;
System.out.println(a.hashCode());
System.out.println(b.hashCode());
//重新new一个对象
AA a2 = new AA();
System.out.println(a2.hashCode());
}
}
class AA{
}
1586600255
1586600255
474675244
toString()
基本介绍:
默认返回:全类名(包名+类名)+@+哈希值的十六进制。
重写toString()方法,用于返回对象的属性信息。
public class Test {
public static void main(String[] args) {
Monster mon = new Monster("小妖","巡山",1200);
//不重写toString方法
System.out.println(mon.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;
}
public String getName() {
return name;
}
public String setName() {
return name;
}
public String getJob() {
return job;
}
public String setJob() {
return job;
}
public double getSal() {
return sal;
}
public double setSal() {
return sal;
}
//重写toString
public String toString() {
return "Monster={'name="+name+"'job="+job+"'sal="+sal+"'}";
}
}
com.zlqedu.toString_.Monster@5e91993f
Monster={'name=小妖'job=巡山'sal=1200.0'}
这样对比我们就可以看出重写之后我们就可以得到我们需要的结果。
如有错误,还望指正。