Object类的使用

  • Object类是所有java类的根父类
  • Object类只声明了一个空参构造器
  • 如果在类的声明中未使用extends关键字指明父类，则默认父类为java.lang.Object类
public class ObjectTest {
	public static void main(String[] args) {
		Order order = new Order();
		System.out.println(order.getClass().getSuperclass());
	}
}

class Order{
	
}

输出：

class java.lang.Object

  • Object类中的功能（属性和方法）具有通用性
  • 属性：无
  • 方法：equals()/toString()/getClass()/hashCode()/clone()/finalize()/wait()/notify()/notifyAll()

eguals()方法

  • 面试题引入
    ==和equals()的区别？
  • ==：可以使用在基本数据类型和引用数据类型当中
public class EqualsTest {
	public static void main(String[] args) {
        //基本数据类型
		int i = 1;
		int j = 1;
		double d = 1.0;
		boolean b = true;
		char c1 = 1;
		char c2 = '1';
		char c3 = 65;
		char c4 = 'A';
		System.out.println(i == j);//true
		System.out.println(i == d);//true
		//System.out.println(i == b);//编译报错
		System.out.println(i == c1);//true
		System.out.println(i == c2);//false
		System.out.println(c3 == c4);//true
        //引用类型		
		String s1 = new String("abc");
		String s2 = new String("abc");
		String s3 = "abc";
		String s4 = "abc";
		System.out.println(s1 == s2);//false
		System.out.println(s3 == s4);//true
		System.out.println(s2 == s4);//false
	}
}

总结：如果比较的是基本数据类型变量，则比较两个变量保存的数据是否相等。（不一定类型要相同）；如果比较的是引用数据类型变量，则比较两个变量的地址值是否相等，即两个引用对象是否指向同一个对象实体。

  • equals():是一个方法，而非运算符；不能使用在基本数据类型变量中（因为需要类来创建对象来调用，类属于引用数据类型，因此只适用于引用数据类型）；
String s1 = new String("abc");
		String s2 = new String("abc");
		System.out.println(s1.equals(s2));//true
		Customer customer1 = new Customer("小张",'女',20,"18805167526","sss&qq.com");
		Customer customer2 = new Customer("小张",'女',20,"18805167526","sss&qq.com");
		System.out.println(customer1.equals(customer2));//false

Object类中equals()的定义：

public boolean equals(Object obj) {
        return (this == obj);
    }

说明：Object类中定义equals()的方法和==的作用是相同的,比较两个变量的地址值是否相等，即两个引用对象是否指向同一个对象实体

通常情况下，我们自定义类如果要使用equals()方法的话，通常也是比较两个对象的“实体内容”是否相同，即需要对Object类中的equals()方法进行重写，如：

//手动重写
@Override
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		if(obj instanceof Customer) {
			Customer customer = (Customer)obj;
			 return (this.age == customer.age && this.name.equals(customer.name) 
			 		&& this.gender == customer.gender && this.phone.equals(customer.phone)
			 		&& this.email.equals(customer.email));
		}
		return false;
	}
//自动生成
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Customer other = (Customer) obj;
		return age == other.age && Objects.equals(email, other.email) && gender == other.gender
				&& Objects.equals(name, other.name) && Objects.equals(phone, other.phone);
	}

String类中equals()的定义：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String aString = (String)anObject;
            if (coder() == aString.coder()) {
                return isLatin1() ? StringLatin1.equals(value, aString.value)
                                  : StringUTF16.equals(value, aString.value);
            }
        }
        return false;
    }

同样的还有Date、File、包装类等，因为它们都重写了equals()方法，重写之后比较的不是两个引用地址是否相同，而是比较两个对象的“实体内容”是否相同。

toString()方法

  • 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()方法
  • Object类中的toString的定义
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
  • 像String,Date,File，包装类等都重写了Object类中的toString方法，使得在调用对象toString()时，返回“实体内容”信息
  • 自定义类如果重写toString方法，当调用该方法，返回对象实体内容，如：
@Override
	public String toString() {
		return "Customer [name=" + name + ", gender=" + gender + ", age=" + age + ", phone=" + phone + ", email=" + email + "]";
	}