java—Object类

Object类是所有类的基类，所以类都继承于Object。

Object类中有11个方法

protected object

clone()

创建并返回对象的一个副本

boolean

equals()

比较两个对象是否相等

protected void

finalize()

对象的垃圾回收器调用次方法回收该对象

Class<?>

getClass()

返回此Object的运行时类的名字

int

hashCode

返回对象的哈希码

void

notify

唤醒该对象监视器上等待的单个线程

void

notifyAll()

唤醒该对象监视器上等待的所有线程

String

toString()

返回该对象的字符串的表示

void

wait()

在其他线程调用此对象的notify()或者notifyAll()方法前，导致当前线程等待。

void

wait(long timeut)

在其他线程调用此对象的notify()或者notifyAll()方法前，或者超过指定的时间量前，导致当前线程等待。

void

wait(long timeut,int nanos)

在其他线程调用此对象的notify()或者notifyAll()方法前，或者某个线程中断当前线程，或者超过指定的时间量前，导致当前线程等待。

# toString方法重写

class YT{

   public Stringname;

   publicint age;

  

   @Override

   public StringtoString(){

     returnthis.name+"-"+this.age;

   }

}

 

# equals方法重写

class YT{

   public Stringname;

   publicint age;

    

   @Override

   publicboolean equals(Object obj){

     YT yt=null;

     if(objinstanceof YT){

        yt=(YT)obj;

        if(this.name.equals(yt.name)&&this.age==yt.age){

          returntrue;

        }

        returntrue;

     }

     returnfalse;

   }

}

#hashCode：hashCode是对象是否相同的标识，不同的对象hashCode是不一样的

@Override

   publicint hashCode() {

     returnthis.name.hashCode()+this.age;

   }

#clone：复制分为浅度赋值和深度复制

浅度复制： 被复制的对象的所有成员属性都有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。

// 浅度复制：protected-->public,并重写clone方法

   @Override

   public Object clone(){

     YT yt=null;

     try{

        yt=(YT)super.clone();

      }catch(CloneNotSupportedExceptione){

        e.printStackTrace();

     }

     returnyt;

   };

深度复制：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不是原有的那些被引用的对象。

// 深度复制：protected-->public,并重写clone方法

   @Override

   publicObject clone(){

     YT yt=null;

     try{

        yt=(YT)super.clone();

        yt.name=this.name;

      }catch(CloneNotSupportedExceptione){

        e.printStackTrace();

     }

     returnyt;

   }

也可以利用串行化实现深度赋值

把对象写到流中的过程是串行化(Serilization)过程，而把对象从流中读出来是并行化(Deserialization)过程。应当指出的是，写在流中的是对象的一个拷贝，而原来对象仍然存在JVM里面。

在Java语言里深层复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流中，再从流中读出来，便可以重建对象。

   // 需要实现Serializable接口

publicObject deepClone(){

     try {

        //将对象写到流中

        ByteArrayOutputStream baos=new ByteArrayOutputStream();

        ObjectOutputStream oos=new ObjectOutputStream(baos);

        oos.writeObject(this);

        //从流中读出来

        ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());

        ObjectInputStream ois=new ObjectInputStream(bais);

        returnois.readObject();

     } catch (ClassNotFoundExceptione) {

        e.printStackTrace();

     } catch (IOExceptione) {

        e.printStackTrace();

     }

     returnnull;

   }