Object类（包含equls与==区别）

Object类

jdk1.8中包含11个方法

1、概述

java.lang.Object类是Java语言中的根类，即所有类的父类。它描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
  	// ...
}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

• public String toString()：返回该对象的字符串表示。

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

2、toString方法

2.1方法摘要

· public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，**所以没有重写toString方法而去打印对象，输出的是对象的地址值。**而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

2.2覆盖重写

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}

在IntelliJ IDEA中，可以点击Code菜单中的Generate…，也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。

在eclipse中如图：

3、Clone克隆（ 复制对象）

• 1）要复制的对象要实现Cloneable的接口，重写clone方法

• 2）利用创建出来的对象调用clone返回新的对象

  Person p2 = p;

  注意，克隆后两个对象的地址不相同，因此改变一个对象的变量值，另一个对象的变量值不受影响。

  具体代码如下：

  1、要复制的对象要实现Cloneable的接口
      class Person implements Cloneable{
          
      }
  2、重写clone方法
      @Override
  	protected Object clone() throws CloneNotSupportedException {
  		return super.clone();
  

  eclispe 按住ALT+SHIFT+S键，选择步骤一的选项
  

  2、利用创建出来的对象调用clone返回新的对象
      Person p2=(person)p.clone();//从当前实例复制一个对象放回给p2
  p2.setName("小李")；//为p2的对象赋值
      
  

4、Finalize

强制垃圾回收，对某些对象是不能回收，比如IO流对象，网络连接。

垃圾回收有不可预知，程序是没有办法知道何时回收。

建议使用赋值null给对象变量，标志这个对象可被回收。

也可以使用System.gc();建议使用这种

先重写 finalize

@Override
	protected void finalize() throws Throwable {//抛出异常创建finalize时抛出就可以
		System.out.println("强制回收对象，释放空间");
		super.finalize();
	}

p=null;//方法一：告诉jvm，这个对象不再使用了，等待垃圾回收，什么时候回收不知道
System.gc();//方法二：底层调用了Runtime.getRuntime.gc();
p=finalize();//方法三：这种方法不好，在多线程的环境中，没有办法保证这个线程什么时候执行？没有办法保证一定会执行。如果出了异常，程序不会往下执行。

5、equals方法(与==区别)

方法摘要

· public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

1、默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

2、对象内容比较（重写equals）

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。//也可以利用工具自动重写，方法同上

例如：

public static void main(String[] args) {
		// == 除了比较两个对象的地址，还有比较两个基本数据的内容
		int i = 3;
		int i2 = 3;
		System.out.println(i == i2);//true
		
		/*
		 *  == 运算符，判断两个值是否相等
		 *  两个数据类型不一致也可以判断
		 */
		char c = 3;
		System.out.println(i == c);//true 
		
		//比较引用类型
		Person2 p = new Person2(21,"小张");
		Person2 p2 = new Person2(21,"小张");
		
		//比较地址
		System.out.println("p == p2:" + (p == p2));//false 旺财
		System.out.println(p.equals(p2));//希望同样内容的对象要用equals比较
		
	}

这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。

在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。如下图所示：

扩展

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

· public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {

return (a == b) || (a != null && a.equals(b));

}

具体全部示例代码如下：

package com.gec.oop2;

class Person implements Cloneable {
	private String name;
	private int age;

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

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	@Override
	protected void finalize() throws Throwable {
		System.out.println("强制回收对象，释放空间");
		super.finalize();
	}

}

/*
 * Object是所有类的根类
 */
public class ObjectDemo {
	public static void main(String[] args) throws Throwable {
		Person p = new Person();
		p.setAge(23);
		p.setName("小张");
		System.out.println("p:" + p);
		System.out.println("这个类的class:" + p.getClass() + "@" + Integer.toHexString(p.hashCode()));

		// 从当前的实例复制一个对象返回
		Person p2 = (Person) p.clone();
		System.out.println("p2:" + p2);

		p2.setName("小李");
		System.out.println("p.getName:" + p.getName());

		// == 两个等号判断对象是否是同一个
		System.out.println("p == p2:" + (p == p2));

		p = null;// 告诉jvm，这个对象不再使用了，等待垃圾回收，什么时候回收不知道

		// 通知jvm进行垃圾回收
		System.gc();// 底层调用了Runtime.getRuntime.gc();

		// finalize
		// 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象
		p2.finalize();// 在多线程的环境中，没有办法保证这个线程什么时候执行？没有办法保证一定会执行。如果出了异常，程序不会往下执行。

	}
}

equals与==的比较

package com.gec.oop2;


class Person2{
	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + "]";
	}
	public Person2(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	public Person2() {
		super();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person2 other = (Person2) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	//重写equals
	/*
	 public boolean equals(Object o) {
		//判断
		if(this == o) {
			return true;
		}
		
		if(this.getClass() == o.getClass()) {
			return true;
		}
		
		//转型
		if(o instanceof Person) {
			Person p = (Person)o;
			if(p.getAge() == this.getAge() && p.getName().equals(this.getName())) {
				return true;
			}else {
				return false;
			}
		}
		
		
		return true;
	}
	 */
	
}

public class ObjectDemo2 {
	public static void main(String[] args) {
		// == 除了比较两个对象的地址，还有比较两个基本数据的内容
		int i = 3;
		int i2 = 3;
		System.out.println(i == i2);//true
		
		/*
		 *  == 运算符，判断两个值是否相等
		 *  两个数据类型不一致也可以判断
		 */
		char c = 3;
		System.out.println(i == c);//true 
		
		//比较引用类型
		Person2 p = new Person2(21,"小张");
		Person2 p2 = new Person2(21,"小张");
		
		//比较地址
		System.out.println("p == p2:" + (p == p2));//false 旺财
		System.out.println(p.equals(p2));//希望同样内容的对象要用equals比较
		
	}
}
	System.out.println(i == i2);//true
		
		/*
		 *  == 运算符，判断两个值是否相等
		 *  两个数据类型不一致也可以判断
		 */
		char c = 3;
		System.out.println(i == c);//true 
		
		//比较引用类型
		Person2 p = new Person2(21,"小张");
		Person2 p2 = new Person2(21,"小张");
		
		//比较地址
		System.out.println("p == p2:" + (p == p2));//false 旺财
		System.out.println(p.equals(p2));//希望同样内容的对象要用equals比较
		
	}
}