java Object 类

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 毫微秒参数值之和指定的超时时间已用完。