Java常用类（一）：根父类——Object

　　java.lang.Object 类是 Java 语言中的根类，即所有类的父类，所有的类都直接或间接的继承 Object 类。

　　在对象实例化的时候，最终的父类就是 Object。

　　如果在类的声明中未使用extends关键字指明其父类， 则默认父类为java.lang.Object类

　　Demo：

1 public class MyClass{
2 // ...
3 }
4
5 等价于
6 public class MyClass extends Object{
7 ...
8 }

　　Object类中方法：

　　1、构造方法

public Object()

　　2、registerNatives 方法

private static native void registerNatives(); //私有的本地方法
static {
　　registerNatives();
}

　　3、getClass 方法

public final native Class getClass();

　　    　　该方法是为了获取此 Object 的运行类。（反射时详细学习）

　　4、hashCode 方法

public native int hashCode();

　　  　　该方法是为了获取该的 hashCode（哈希） 值；

　　5、equals 方法

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

　　　　该方法是用于确认两个对象是否“相同”。

　　6、clone 方法

protected native Object clone() throws CloneNotSupportedException;

　　　　创建并返回此对象的一个副本。

　　7、toString 方法

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

　　　　该方法用于打印此对象的“全类名@此对象在内存中地址值（十六进制）”；

　　8、notify、notifyAll、wait、等方法与线程相关

public final native void notify();  //唤醒在此对象监视器上等待的单个线程。
public final native void notifyAll();  //唤醒在此对象监视器上等待的所有线程。

 //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或 者超过指定的时间量前，导致当前线程等待。
public final native void wait(long timeout) throws InterruptedException;
//用于让当前线程失去操作权限，当前线程进入等待序列
public final void wait() throws InterruptedException {
wait(0);
}
 //在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout <0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos <0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}

　　9、finalize

protected void finalize() throws Throwable { }

　　　　 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

　　1、registerNatives 方法

　　　　　　native 关键字与 registerNatives 方法

　　2、== 操作符与 equals 方法 （常见面试题）

　　3、toString() 方法

　　　　（1）toString()方法在Object类中定义， 其返回值是String类型， 返回类名和它的引用地址；

　　　　（2）在进行String与其它类型数据的连接操作时， 自动调用toString()方法；

Date now=new Date();
System.out.println(“now=”+now); 相当于
System.out.println(“now=”+now.toString());

　　　　（3）可以根据需要在用户自定义类型中重写toString()方法如String 类重写了toString()方法， 返回字符串的值；

s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());

　　　　（4）基本类型数据转换为String类型时， 调用了对应包装类的toString()方法：

int a=10; System.out.println(“a=”+a);

　　　　面试题：

1 public void test() {
2 char[] arr = new char[] { 'a', 'b', 'c' };
3 System.out.println(arr);// abc
4 int[] arr1 = new int[] { 1, 2, 3 };
5 System.out.println(arr1);// [I@15db9742
6 double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
7 System.out.println(arr2);// [D@6d06d69c
8 }

　　　　解析：下面的两个 println(Object x) 方法的形参是 Object，方法体内就是打印地址值；而当参数是  char 数组时，就调用对应的 println(char x[]) 方法，对该数组进行遍历输出。

　　4、clone() 方法

　　　　　　clone：对象的克隆（拷贝）

　　5、finalize() 方法

　　　　当垃圾回收器确定不再有对该对象的引用时，由垃圾回收器在对象上调用该方法。该方法只会被调用一次。

　　　　Demo：

1 public class FinalizeTest {
2 public static void main(String[] args) {
3 Person p = new Person("Peter", 12);
4 System.out.println(p);
5 p = null;//此时对象实体就是垃圾对象，等待被回收。但时间不确定。
6 System.gc();//强制性释放空间
7 }
8 }
9
10 class Person{
11 private String name;
12 private int age;
13
14 public Person(String name, int age) {
15 super();
16 this.name = name;
17 this.age = age;
18 }
19 public String getName() {
20 return name;
21 }
22 public void setName(String name) {
23 this.name = name;
24 }
25 public int getAge() {
26 return age;
27 }
28 public void setAge(int age) {
29 this.age = age;
30 }
31 //子类重写此方法，可在释放对象前进行某些操作
32 @Override
33 protected void finalize() throws Throwable {
34 System.out.println("对象被释放--->" + this);
35 }
36 @Override
37 public String toString() {
38 return "Person [name=" + name + ", age=" + age + "]";
39 }
40 }

　　　　补充：垃圾回收机制关键点

垃圾回收机制只回收JVM堆内存里的对象空间。

对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力

现在的JVM有多种垃圾回收实现算法，表现各异。

垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。

可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。

程序员可以通过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，但是系统是否进行垃圾回收依然不确定。

垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）。

永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

　　  上面重写 equals 方法中，使用了 java.util.objects 类，下面对这个类进行了解。

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

　　在比较两个对象的时候，Object 的 equals 方法容易抛出空指针异常，而 Object 类中的 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));
}

　　有兴趣的可以仔细研读一下源码。