Object o=new Object();
其中有两个受保护的方法：
1、protected void finalize()
2、protected Object clone()
1、System.out.println( o );//输出的时候默认调用的是该对象的toString() 方法
2、toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Integer.toHexString(hashCode())：
toHexString()表示返回XXX的16进制数
3、hashCode()
源文件
public native int hashCode(); 像这种没有方法体的方法，只有两种一种是抽象方法abstract和native（本地方法）
native关键字的说明：
{ 使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。这些函数的实现体在DLL中，JDK的源代码中并不包含，你应该是看不到的。对于不同的平台它们也是不同的。这也是java的底层机制，实际上java就是在不同的平台上调用不同的native方法实现对操作系统的访问的。
native 是用做java 和其他语言（如c++）进行协作时用的也就是native 后的函数的实现不是用java写的 2。既然都不是java，那就别管它的源代码了，呵呵
native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的， java只能调用。
java是跨平台的语言，既然是跨了平台，所付出的代价就是牺牲一些对底层的控制，而java要实现对底层的控制，就需要一些其他语言的帮助，这个就是native的作用了，参考： http://blog.sina.com.cn/s/blog_67d6d5df0100yqnf.html
}
返回一个int类型的值
返回的值是由《系统》散列码算法生成的。
作用：{JVM每new一个Object,它都会将这个Object丢到一个Hash哈希表中去,这样的话,下次做Object的比较或者取这个对象的时候,它会根据对象的hashcode再从Hash表中取这个对象。这样做的目的是提高取对象的效率，
比较两个对象的时候,首先根据他们的hashcode去hash表中找他的对象,当两个对象的hashcode相同,那么就是说他们这两个对象放在Hash表中的同一个key上,那么他们一定在这个key上的链表上。那么此时就只能根据Object的equal方法来比较这个对象是否equal。}
有一个概念要牢记，两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象。
参考：http://xiaotao-2010.iteye.com/blog/1249006
4、equals（）
源文件： public boolean equals(Object obj) {
return (this == obj);
}
5、getClass()
源文件：public final native Class<?> getClass();
Object类中包含一个方法名叫getClass，利用这个方法就可以获得一个实例的类型类。类型类指的是代表一个类型的类，因为一切皆是对象，类型也不例外，在Java使用类型类来表示一个类型。
可以参考：http://hi.baidu.com/app_2006/item/3884a0f13ba5770b85d278f9
6、notify()和notifyAll() [notify:（英文解释）被通知人]
参考文件---------------------------------------
import java.util.Random;
/*
* 线程之间的通信
*
* 先定义生产者和消费者的共享数据
*
* */
//共享数据
class Product
{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private double price;
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
private boolean tag=false;
public boolean isTag() {
return tag;
}
public void setTag(boolean tag) {
this.tag = tag;
}
public Product()
{
}
public Product(String name,double price)
{
this.name=name;
this.price=price;
}
}
//定义生产者
class Producer implements Runnable
{
Product pro=null;
Random r=new Random();
int caseProduct=-1;
public Producer(Product pro)
{
this.pro=pro;
}
public void run(){
if(pro==null) return ;
while(true)
{
synchronized(pro){
if(pro.isTag())
{
try{
pro.wait();//等待
}
catch(InterruptedException e)
{
System.out.println("有线程中断了当前线程！");
}
}
else
{
caseProduct=r.nextInt(5);//产生一个0-5的随机数
switch(caseProduct)
{
case 1:
pro.setName("苹果");
pro.setPrice(4.0);
System.out.println("生产了一个 "+pro.getName()+" -------价钱为："+pro.getPrice());
break;
case 2:
pro.setName("香蕉");
pro.setPrice(14.0);
System.out.println("生产了一个 "+pro.getName()+" -------价钱为："+pro.getPrice());
break;
case 3:
pro.setName("柿子");
pro.setPrice(24.0);
System.out.println("生产了一个 "+pro.getName()+" -------价钱为："+pro.getPrice());
break;
case 4:
pro.setName("橘子");
pro.setPrice(34.0);
System.out.println("生产了一个 "+pro.getName()+" -------价钱为："+pro.getPrice());
break;
default:
pro.setName("枣子");
pro.setPrice(44.0);
System.out.println("生产了一个 "+pro.getName()+" -------价钱为："+pro.getPrice());
break;
}
//唤醒线程
pro.notify();
pro.setTag(true);
}
}
}
}
}
//定义消费者
class Cousumer implements Runnable
{
Product pro=null;
public Cousumer(Product pro)
{
this.pro=pro;
}
public void run(){
if (pro==null) return;
while(true){
synchronized(pro){
if(pro.isTag())
{
System.out.println("吃了一个"+pro.getName()+"------价钱为："+pro.getPrice());
pro.notify();//唤醒生产者线程
pro.setTag(false);
}
else
{
try{
pro.wait();//等待
}
catch(InterruptedException e)
{
System.out.println("有线程中断了当前线程！");
}
}
}
}
}
}
public class Demo11 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//资源
Product product=new Product();
Producer pro=new Producer(product);
Thread th1=new Thread(pro,"生产者");
th1.start();
Cousumer cousumer=new Cousumer(product);
Thread th2=new Thread(cousumer,"消费者");
th2.start();
}
}
-------------------------------------------------
源文件：public final native void notify();
Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制 参考：http://blog.csdn.net/zyplus/article/details/6672775
底下是一个案例：
Wait()和notify():如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。一般用在synchronized机制中。
例如:线程A
synchronized(obj) {
while(!condition) {
obj.wait();
}
obj.doSomething();
}
当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A。
线程B
synchronized(obj) {
condition = true;
obj.notify();
}
需要注意的概念是：
1.调用obj的wait()， notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {……} 代码段内。
2.调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {……} 代码段内唤醒A.
3.当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。
4.如果A1，A2，A3都在obj.wait()，则B调用obj.notify()只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。
5.obj.notifyAll()则能全部唤醒A1，A2，A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。
6.当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1，A2，A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1，A2，A3中的一个才有机会获得锁继续执行。
7、wait(long timeout)，wait()，wait(long timeout, int nanos)
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
timeout 毫秒值与 nanos 毫微秒参数值之和指定的超时时间已用完。