大家在学习 java 的时候，一定遇到过Object类，因为在java单一继承体系中Object类是根类，所有的类都会继承它，并拥有Object的公共方法，意味着在java的面向对象的世界中，所有对象都拥有这些方法，非常通用。那么我们来看一看这些方法有哪些？
直接看一下，Object类的源码：
package java.lang;
public class Object {
priva te sta ti c na TI ve void registerNa TI ves（）;
sta TI c {
registerNa TI ves（）;
}
public final native Class《？》 getClass（）;
public native int hashCode（）;
public boolean equals（Object obj） {
return （this == obj）;
}
protected native Object clone（） throws CloneNotSupportedException;
public String toString（） {
return getClass（）.getName（） + “@” + Integer.toHexString（hashCode（））;
}
public final native void not if y（）;
public final native void notifyAll（）;
public final native void w ai t（long timeout） throws InterruptedException;
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 》= 500000 || （nanos ！= 0 && timeout == 0）） {
timeout++;
}
wait（timeout）;
}
public final void wait（） throws InterruptedException {
wait（0）;
}
protected void finalize（） throws Throwable { }
}
其实看JDK文档大家都能知道这些方法的含义，不过我把自己对它们的理解介绍一下，这里面public的方法，重点我会详细介绍较难掌握的wait和notify方法。
具体方法的说明如下：
public String toString（）
这个默认是打印对象的getClass（）.getName（） + ‘@’ + Integer.toHexString（hashCode（））
类名@哈希码，可子类可重写该方法定义自己的对象 字符 串，最常用。
public final native Class《？》 getClass（）;
获取对象的类名，在反射中可以用到。
public int hashCode（）;
public boolean equals（Object obj）
这两个方法在集合框架的Set集合类中用途非常重要，因为Set集合中的元素不允许重复，各种自定义对象如何判断是否重复，就是通过重写这两个方法来完成的。
public final native void notify（）;
public final native void notifyAll（）;
public final void wait（）
public final native void wait（long timeout）
public final void wait（long timeout， int nanos）
这里几组方法有多个重载方法，不过核心的方法就是wait方法和notify方法，这两个方法，如果没有学习过java多线程编程估计不会接触到，这涉及到线程的同步以及在同步条件下线程通信的问题。
java 线程同步机制就是保证多个线程访问同一个共享对象时不发生冲突的步骤是上 锁 、操作、释放锁。而这个锁是在java对象中隐含的锁，锁也叫“同步监视器” ，它是所有对象都拥有的，你不用可视而不见，
其实就定义在Object类中，不过我们不用了解它的存在，为了防止同一个共享对象不发生冲突，java用 synchronized 来保护共享对象不处于竞争状态。，可采用同步方法或同步块来完成，但是当同步环境下两个线程需要通信怎么办？如果没有通信机制，两个线程只能针对锁的获取发出轮询效率很低，这里Object类的wait和notify两个方法就可以解决这个问题。
采用 wait（）/notify（） 实现同步条件下线程间通信的原理如下：
使用前提：必须是同步条件，否则调用会异常。
调用wait（）
调用线程会放弃 CPU
调用线程释放锁
调用线程进入锁的等待集合（池），等待CPU重新调度。
调用notify（）
某个线程从锁的等待集合中离开进入准备运行状态
被通知的线程必须重新请求锁才能执行。
notify（）不能精确指定被通知的线程。
notifyAll（） 通知所有在等待集合的线程离开进入准备运行状态
下面以经典的生产者和消费者问题来了解生产者线程Producer和消费者线程Consumer，同步一个同享对象Shop，利用wait和notify方法来通信的代码：
Puducer.java 生产者线程定义
public class Producer implements Runnable{
Shop shop;
public Producer（Shop shop） {
// TODO Auto-generated constructor stub
this.shop=shop;
new Thread（this，“生产者线程”）.start（）;
}
@Override
public void run（） {
// TODO Auto-generated method stub
int i=0;
while（true）{
shop.put（i++）;
}
}
}
Consumer.java 消费者线程定义
public class Consumer implements Runnable{
Shop shop;
public Consumer（Shop shop） {
// TODO Auto-generated constructor stub
this.shop=shop;
new Thread（this，“消费者线程”）.start（）;
}
@Override
public void run（） {
// TODO Auto-generated method stub
while（true）{
shop.get（）;
}
}
}
共享对象Shop.java定义
public class Shop {
int no;
boolean hasData=false; //false表示无数据 true有数据
synchronized int get（）{ //消费产品
if（hasData==false）{
try {
wait（）;//消费者线程暂停
} catch （InterruptedException e） {
// TODO Auto-generated catch block
e.printStackTrace（）;
}
}
System.out.println（“消费：”+no）;
hasData=false;//消费完了。通知生产
notify（）;
return no;
}
synchronized void put（int no）{ //放产品
if（hasData==true）{
try {
wait（）;
} catch （InterruptedException e） {
// TODO Auto-generated catch block
e.printStackTrace（）;
}
}
System.out.println（“生产：”+no）;
hasData=true;
this.no=no;
notify（）;
}
}
测试 类PC.java
public class PC {
public static void main（String［］ args） {
Shop shop=new Shop（）;
new Producer（shop）;
new Consumer（shop）;
}
}
以上生产消费者问题很好的说明了wait和notify方法的用途，其他方法的变种例如wait（long timeout）就好理解了，如果超过指定时间等待的线程也会进入等待集合而不用再等待。
责任编辑：ct
