java8类库简单了解（一）Object

这里主要了解如下几个类：

java.lang 包

这个包称为 java 语言包，是由编译器自动引入的。程序中不必用 import 语句就可以使用。它所包含的类和接口对所有实际的 Java 程序都是必要的。

1.       object 类

2.       数学类 (Math)

3.       数据类型类

4.       线程类

5.       字符串类 (String 类和 StringBuffer 类 )

6.       系统及运行类 (System 类和 Runtime 类 )

7.       错误和异常处理类 (Throwable 、 Exception 、 Error)

8.       过程类 (process)

java.util 包

1. 日期类、日历类（ Data 、 Calendar 、 GregorianCalendar ）

2. 随机数类（ Random ）

3. 位运算类（ BitSet ）

4. 矢量类（ Vector ）

5. 数据结构类（ Stack ）

6. 散列表类（ Hashtable ）

7. StringTokenizer类

一、

这里直接在源码进行注释，如下：

/*
 * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.lang;

/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 * 类{Object}是类层次结构的根。每个类都有{Object}作为父类。所有的对象，包括数组，会实现这个类的方法。
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {

	/**
	为了使JVM发现您的本机功能，他们被一定的方式命名。例如，对于java.lang.Object.registerNatives。
	通过使用registerNatives（或者更确切地说，JNI（Java Native Interface）函数RegisterNatives），您可以命名任何你想要你的C函数。
	JNI允许Java代码使用以其他语言编写的代码和代码库。
	native表示该方法的实现java本身并没有完成，而是有c/c++来完成，形成.dll文件。
	*/
    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
		这个方法主要是获得该类的完整名称。
     */
    public final native Class<?> getClass();

    /**
     * Returns a hash code value for the object. This method is
     * supported for the benefit of hash tables such as those provided by
		这个方法native修饰，java本身不实现，由c/c++来实现，具体根据所依赖的平台来。返回该对象的哈希值
     */
    public native int hashCode();

    /**
	这个方法返回一个boolean类型。该方法主要是比较两个对象是否是同一个。而比较的不是对象本身，而是对非NULL对象的引用。
	这个方法具有自我性，对称型，传递性，一致性。
	自我性体现在：如果x.equals(x)，那么在x不为空的前提下，那么返回true，否则抛出NullPointorException。
	对称型体现在：如果x和y相等，那么y和x也相等。
	传递性体现在：如果x==y，y==z，那么x==z。
	一致性体现在：如果x==y为true，那么只要不修改，后面无论调用多少次，一致为true。
	而且特别要注意的一点是：一个非空对象和null值比较，那么一定返回false。
	如果要对equals方法进行overide重写，那么一定要保证相同对象拥有同样的hash值。
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
	快速创建一个已有对象的副本
	Object类的clone()方法是一个native方法，native方法的效率一般来说都是远高于Java中的非native方法。
	Object.clone()方法返回一个Object对象。我们必须进行强制类型转换才能得到我们需要的类型。
	引申：
	1、
	Person p = new Person(23, "zhang"); 
	Person p1 = p;    
	System.out.println(p); 
	System.out.println(p1); 
	打印出来：
	com.pansoft.zhangjg.testclone.Person@2f9ee1ac
	com.pansoft.zhangjg.testclone.Person@2f9ee1ac
	打印的地址值是相同的，那么肯定是同一个对象。p和p1只是引用而已，这种现象叫做引用的复制。
	2、
	Person p = new Person(23, "zhang"); 
	Person p1 = (Person) p.clone(); 	   
	System.out.println(p); 
	System.out.println(p1); 
	打印出：
	com.pansoft.zhangjg.testclone.Person@2f9ee1ac
	com.pansoft.zhangjg.testclone.Person@67f1fba0
	两个对象的地址是不同的，也就是说创建了新的对象，然后将属性值复制到新对象，是拷贝
	3、
	Person p = new Person(23, "zhang"); 
	Person p1 = (Person) p.clone();    
	String result = p.getName() == p1.getName()  
			? "clone是浅拷贝的" : "clone是深拷贝的";    
	System.out.println(result);
	打印出：clone是浅拷贝的
	name是String类型，它只是一个引用，那么对这个属性的拷贝有两种方式：复制引用，或者拷贝（创建新对象）。测试证明clone对象时，对象非基本数据类型属性是复制引用
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
	toString 方法会返回一个“以文本方式表示此对象”的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }


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

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

	
	/**在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。*/ 
    public final native void wait(long timeout) throws InterruptedException;

	/** 在其他线程调用此对象的 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);
    }

  
    /**Thread对象调用wait()方法就是这个。
	在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。   
	当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。
	然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
	finalize()方法：垃圾回收器准备释放内存的时候，会先调用finalize()。
　　(1).对象不一定会被回收。
    (2).垃圾回收不是析构函数。析构函数定义主要是针对c++，往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。
    (3).垃圾回收只与内存有关。
    (4).垃圾回收和finalize()都是靠不住的，只要JVM还没有快到耗尽内存的地步，它是不会浪费时间进行垃圾回收的。
     */
    protected void finalize() throws Throwable { }
}