JAVA SE之面向对象6：Object类

今日内容：

Object(类)
	public int hashCode()
	public final Class getClass()
	public String toString()
	public boolean equals(Object obj)

常见对象

API概述以及Object类的概述

1. API(Application Programming Interface) 应用程序编程接口；
2. Object类概述“是所有类的顶层父亲”
   类层次结构的根类; 所有类都直接或者间接的继承自该类。
3. 构造方法 public Object()
   子类的构造方法默认访问的是父类的无参构造方法。

Object类的hashCode()方法

1. 返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算；
2. 不同对象的，hashCode一般来说不会相同。但是，同一个对象的hashCode()值肯定相同；
3. 不是对象的实际地址值，可以理解为逻辑地址值。

Object类的getClass()方法

1. 返回此 Object 的运行时类；
2. 可以通过Class类中的一个方法，获取对象的真实类的全名称：
   public String getName()

Object类的toString()方法

1. 返回该对象的字符串表示。
   源代码:

   	   public String toString() {
   				 return getClass().getName() + "@" +
   				 Integer.toHexString(hashCode());
   	  }
   

2. 它的值等于：
   getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

3. 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。一般是将该类的所有的成员变量组成返回。

Object类的equals()方法

1. 指示其他某个对象是否与此对象“相等”；
   源代码:

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

2. 默认情况下比较的是对象的引用是否相同；

3. 由于比较对象的引用没有意义，一般建议重写该方法。一般用于比较成员变量的值是否相等；

面试题：==和equals()的区别？

   == 操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存
   中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，
   只能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了
   两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如 
   Objet obj = new Object();变量 obj 是一个内存， new Object()是另一个内存，
   此时，变量 obj 所对应的内存中存储的数值就是对象占用的那块内存的首地址。
   对于指向对象类型的 变量，如果要比较两个变量是否指向同一个对象，即要看
   这两个变量所对应的内存中的数值是否相等，这 时候就需要用==操作符进行比
   较。 equals 方法是用于比较两个独立对象的内容是否相同，就好比去比较两个
   人的长相是否相同，它比较 的两个对象是独立的。
   例如，对于下面的代码： String a=new String("foo"); 
   String b=new String("foo"); 两条 new 语句创建了两个对象，然后
   用 a,b 这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的
   首地址是不同的，即 a 和 b 中存储的数值是不相同的，所以，表达式 a==b 
   将返回 false，而这 两个对象中的内容是相同的，所以，表达式 
   a.equals(b)将返回 true。 

Object类的clone() 方法

1. clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public；

2. 对象的浅克隆:浅克隆和深克隆，使用clone()方法采用的是浅克隆的方式；
   对象浅克隆要注意的细节：
   1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
   2. Cloneable接口只不过是一个标识接口而已，没有任何方法。
   3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把
   另外一个对象也克隆一份。
   4. 对象的浅克隆也不会调用到构造方法的。

3. 对象的深克隆(后面讲)：采用IO流来实现 使用 ObjectOutputStream 将对象写入文件中,然后再用ObjectInputStream读取回来。

代码如下：

	public class MyTest {
		 public static void main(String[] args) throws CloneNotSupportedException {
			 Person p1 = new Person("狗娃", 23);
			 Person p2 = (Person) p1.clone();
			        p2.name="张三";
			        p2.age=30;
				System.out.println(p1);
				System.out.println(p2);
		System.out.println("---------------------------");
			 Address address = new Address("北京");
			Person p3 = new Person("王五", 25, address);
			Person p4 = (Person) p3.clone();
			p4.name="赵六";
			p4.age=36;
			p4.address.city="上海";
			System.out.println(p3);
			System.out.println(p4);


    }
}
class Person implements Cloneable{
    public String name;
    public int age;
    public Address address;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}
class Address{
    public String city;

    public Address(String city) {
        this.city = city;
    }
    
    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }
}