Object类概述

Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
每个类都直接或者间接的继承自Object类。

Object类的方法：
public int hashCode():返回该对象的哈希码值。
注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。但也可以理解为地址值。

public final Class getClass():返回此 Object 的运行时类

Class类的方法：
public String getName()：以 String 的形式返回此 Class 对象所表示的实体

 1 public class StudentTest {
 2     public static void main(String[] args) {
 3         Student s1 = new Student();
 4         System.out.println(s1.hashCode()); // 11299397
 5         Student s2 = new Student();
 6         System.out.println(s2.hashCode());// 24446859
 7         Student s3 = s1;
 8         System.out.println(s3.hashCode()); // 11299397
 9         System.out.println("-----------");
10
11         Student s = new Student();
12         Class c = s.getClass();
13         String str = c.getName();
14         System.out.println(str); // cn.wxkj.Student， 包名+类名
15
16         //链式编程
17         String str2  = s.getClass().getName();
18         System.out.println(str2);
19     }
20 }

* public String toString():返回该对象的字符串表示。
*
* Integer类下的一个静态方法：
* public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串
*
建议所有子类都重写该方法。
* 怎么重写呢?
* 把该类的所有成员变量值组成返回即可。
* 重写的最终版方案就是自动生成toString()方法。
*
* 注意：
* 直接输出一个对象的名称，其实就是调用该对象的toString()方法。

 1 public class StudentDemo {
 2     public static void main(String[] args) {
 3         Student s = new Student();
 4         System.out.println(s.hashCode());
 5         System.out.println(s.getClass().getName());
 6         System.out.println("--------------------");
 7         System.out.println(s.toString());// [email protected]
 8         System.out.println("--------------------");
 9         // toString()方法的值等价于它
10         // getClass().getName() + ‘@‘ + Integer.toHexString(hashCode())
11         // this.getClass().getName()+‘@‘+Integer.toHexString(this.hashCode())
12
13         // [email protected]
14         // [email protected]
15
16         System.out.println(s.getClass().getName() + ‘@‘
17                 + Integer.toHexString(s.hashCode()));
18
19         System.out.println(s.toString());
20
21         // 直接输出对象的名称
22         System.out.println(s);
23     }
24 }

equals方法：

* public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。
* 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
* 怎么重写呢?
* 一般都是用来比较对象的成员变量值是否相同。
* 重写的代码优化：提高效率，提高程序的健壮性。
* 最终版：
* 其实还是自动生成。
*
* 看源码：
* public boolean equals(Object obj) {
* //this - s1
* //obj - s2
* return (this == obj);
* }
*
* ==:
* 基本类型：比较的就是值是否相同
* 引用类型：比较的就是地址值是否相同
* equals:
* 引用类型：默认情况下，比较的是地址值。
* 不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

 1 public class Student {
 2     private String name;
 3     private int age;
 4
 5     public Student() {
 6         super();
 7     }
 8
 9     public Student(String name, int age) {
10         super();
11         this.name = name;
12         this.age = age;
13     }
14
15     public String getName() {
16         return name;
17     }
18
19     public void setName(String name) {
20         this.name = name;
21     }
22
23     public int getAge() {
24         return age;
25     }
26
27     public void setAge(int age) {
28         this.age = age;
29     }
30
31     @Override
32     public boolean equals(Object obj) {
33         if (this == obj)
34             return true;
35         if (obj == null)
36             return false;
37         if (getClass() != obj.getClass())
38             return false;
39         Student other = (Student) obj;
40         if (age != other.age)
41             return false;
42         if (name == null) {
43             if (other.name != null)
44                 return false;
45         } else if (!name.equals(other.name))
46             return false;
47         return true;
48     }
49
50 //    @Override
51 //    public boolean equals(Object obj) {
52 //        // return true;
53 //        //这里要改进，根据这里比较的成员变量来决定返回true还是false
54 //        //这里其实要比价的就是name和age
55 //        //但是，name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
56 //        //String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同
57 //        //this -- s1
58 //        //obj -- s2
59 //        //我们要使用的是学生类的特有成员变量,所以要向下转型
60 //        Student s = (Student)obj; //s -- obj -- s2;
61 //        if(this.name.equals(s.name) && this.age == s.age) {
62 //            return true;
63 //        }else {
64 //            return false;
65 //        }
66 //    }
67
68 //    @Override
69 //    public boolean equals(Object obj) {
70 //        //为了提高效率
71 //        if(this == obj){
72 //            return true;
73 //        }
74 //
75 //        //为了提供程序的健壮性
76 //        //我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
77 //        //这个时候，我们要判断的是对象是否是某个类的对象?
78 //        //记住一个格式：对象名 instanceof 类名
79 //        //表示：判断该对象名是否是该类名一个对象
80 //        if(!(obj instanceof Student)){
81 //            return false;
82 //        }
83 //        //如果是就继续
84 //
85 //        Student s = (Student)obj;
86 //        //System.out.println("同一个对象，还需要向下转型并比较吗?");
87 //        return this.name.equals(s.name) && this.age == s.age;
88 //    }
89
90
91 }

 1 public class StudentDemo {
 2     public static void main(String[] args) {
 3         Student s1 = new Student("jjz", 27);
 4         Student s2 = new Student("jjz", 27);
 5         System.out.println(s1 == s2); // false
 6         Student s3 = s1;
 7         System.out.println(s1 == s3);// true
 8         System.out.println("---------------");
 9
10         System.out.println(s1.equals(s2)); // obj = s2; //false
11         System.out.println(s1.equals(s1)); // true
12         System.out.println(s1.equals(s3)); // true
13         Student s4 = new Student("风清扬",30);
14         System.out.println(s1.equals(s4)); //false
15
16         Demo d = new Demo();
17         System.out.println(s1.equals(d)); //ClassCastException
18
19     }
20 }
21
22 class Demo {}

* protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。
* protected Object clone():创建并返回此对象的一个副本。
* A:重写该方法
*
* Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。
* 这个接口是标记接口(没有方法)，告诉我们实现该接口的类就可以实现对象的复制了。

 1 public class Student implements Cloneable {
 2     private String name;
 3     private int age;
 4
 5     public Student() {
 6         super();
 7     }
 8
 9     public Student(String name, int age) {
10         super();
11         this.name = name;
12         this.age = age;
13     }
14
15     public String getName() {
16         return name;
17     }
18
19     public void setName(String name) {
20         this.name = name;
21     }
22
23     public int getAge() {
24         return age;
25     }
26
27     public void setAge(int age) {
28         this.age = age;
29     }
30
31     @Override
32     protected Object clone() throws CloneNotSupportedException {
33         return super.clone();
34     }
35 }

 1 public class StudentDemo {
 2     public static void main(String[] args) throws CloneNotSupportedException {
 3         //创建学生对象
 4         Student s = new Student();
 5         s.setName("jjz");
 6         s.setAge(27);
 7
 8         //克隆学生对象
 9         Object obj = s.clone();
10         Student s2 = (Student)obj;
11         System.out.println("---------");
12
13         System.out.println(s.getName()+"---"+s.getAge());
14         System.out.println(s2.getName()+"---"+s2.getAge());
15
16         //以前的做法
17         Student s3 = s;
18         System.out.println(s3.getName()+"---"+s3.getAge());
19         System.out.println("---------");
20
21         //其实是有区别的
22         s3.setName("sihao");
23         s3.setAge(30);
24         System.out.println(s.getName()+"---"+s.getAge());
25         System.out.println(s2.getName()+"---"+s2.getAge());
26         System.out.println(s3.getName()+"---"+s3.getAge());
27
28     }
29 }