Hierarchy For Package javax.management

java.lang.Object
getClass    public final Class<?> getClass()
Java的每个类都带有一个运行时类对象，该Class对象中保存了创建对象所需的所有信息。可以用.class返回此 Object 的运行时类Class对象，也可以用getClass()获得。可以利用此Class对象进行一些反射特性的操作。
hashCode public int hashCode() 
hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值,支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。
在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行hashcode比较时所用的信息没有被修改。
如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果，注：这里说的equals(Object) 方法是指Object类中未被子类重写过的equals方法。
如果两个hashCode()返回的结果相等，则两个对象的equals方法不一定相等。
如果根据equals(java.lang.Object)方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
equals  public boolean equals(Object obj)
和null的比较应该返回false, null没有equals方法
clone protected Object clone() throws CloneNotSupportedException
x.clone() != x 为true, x.clone().getClass() == x.getClass() 为true  x.clone().equals(x) 为true
这不是硬性要求
Object本身隐藏提供clone方法，我们需要在自己的类中进行实现，并调用super.clone()。
所有的数组已经实现了Cloneable接口。
The class Object does not itself implement the interface Cloneable, so calling the clone method on an object whose class is Object will result in throwing an exception at run time.
Note that all arrays are considered to implement the interface Cloneable and that the return type of the clone method of an array type T[] is T[] where T is any reference or primitive type. Otherwise, this method creates a new instance of the class of this object and initializes all its fields with exactly the contents of the corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation.
对于primitive type来说，这种复制是可行的，对于非primitive type来说，这种复制不可行。

 1 class A {
 2     public A (int a) {
 3         this.a = a;
 4     }
 5     public int a;
 6     public void add() {
 7         a += 5;
 8     }
 9 }
10 class B implements Cloneable {
11     public int b;
12     public A ba = new A (5);
13     public Object clone() {
14         B newB = null;
15         try {
16             newB = (B)super.clone();
17         } catch (CloneNotSupportedException e) {
18             e.printStackTrace();
19         }
20         return newB;
21     }
22 }
23 class C {
24     public static void main(String[] args) {
25         B firB = new B();
26         firB.b = 5;
27
28         System.out.println("before Clone" + firB.b);
29         System.out.println("before Clone" + firB.ba.a);
30
31         B secB = (B)firB.clone();
32         secB.b = 7;
33         secB.ba.add();
34         System.out.println("After Clone firB" + firB.b);
35         System.out.println("After Clone firB" + firB.ba.a);
36         System.out.println("After Clone secB" + secB.b);
37         System.out.println("After Clone secB" + secB.ba.a);
38     }
39 }

结果如下：

可以修改上面的方法

class A implements Cloneable{
    public A (int a) {
        this.a = a;
    }
    public int a;
    public void add() {
        a += 5;
    }
    public Object clone() {
        A newA = null;
        try {
            newA = (A)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newA;
    }
}
class B implements Cloneable {
    public int b;
    public A ba = new A (5);
    public Object clone() {
        B newB = null;
        try {
            newB = (B)super.clone();
            newB.ba = (A)ba.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return newB;
    }
}
class C {
    public static void main(String[] args) {
        B firB = new B();
        firB.b = 5;

        System.out.println("before Clone" + firB.b);
        System.out.println("before Clone" + firB.ba.a);

        B secB = (B)firB.clone();
        secB.b = 7;
        secB.ba.add();
        System.out.println("After Clone firB" + firB.b);
        System.out.println("After Clone firB" + firB.ba.a);
        System.out.println("After Clone secB" + secB.b);
        System.out.println("After Clone secB" + secB.ba.a);
    }
}

reference :  https://blog.csdn.net/baobeisimple/article/details/1727125#_Toc174096679toString publicString toString()
return getClass().getName() + ‘@‘ + Integer.toHexString(hashCode())

首先我们需要再复习一下java的synchronized机制，每一个对象都有一个监听器（monitor），每一个synchronizad（）代码块的括号里面的都是一个对象， 当一个线程试图进入synchronizad的代码块的时候，会试图得到这个对象的monitor，其他处于同一 monitor下面的线程想要进入synchronizad代码块的时候就必须等待这个线程释放monitor，当然，一个线程执行完synchronizad代码块后会自动释放monitor。

reference :http://blog.51cto.com/2925665/1324501

1. 你可以使用wait和notify函数来实现线程间通信。你可以用它们来实现多线程（>3）之间的通信。

2. 永远在synchronized的函数或对象里使用wait、notify和notifyAll，不然Java虚拟机会生成 IllegalMonitorStateException。

3. 永远在while循环里而不是if语句下使用wait。这样，循环会在线程睡眠前后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。

4. 永远在多线程间共享的对象（在生产者消费者模型里即缓冲区队列）上使用wait。

reference : http://www.importnew.com/16453.htmlnotify()

Throws:IllegalMonitorStateException - if the current thread is not the owner of this object‘s monitor.

notifyAll()
Throws:IllegalMonitorStateException - if the current thread is not the owner of this object‘s monitor.
wait()

public final void wait(long timeout) throws InterruptedException

原文地址：https://www.cnblogs.com/lzz-cabbage/p/8884374.html