你知道java的Object对象里面都包含什么吗？

Java作为一个庞大的知识体系，涉及到的知识点繁多，本文将从Java中最基本的类java.lang.Object开始谈起。

Object类位于java.lang包中，java.lang包包含着Java最基础和核心的类，在编译时会自动导入。Object类没有定义属性，一共有13个方法，具体的类定义结构如下图：

idea ：alt+7

其主要作用是将C/C++中的方法映射到Java中的native方法，实现方法命名的解耦。

private static native void registerNatives();

static {

registerNatives();

}      

*返回这个{@code对象}的运行时类。返回的

• {@code类}对象是被{@code锁定的对象 （效果与Object.class相同。）

  被表示类的静态同步}方法。

public final native Class<?> getClass();

对象重写euqase方法必须重写hashcode方法

/**

*

开发者应该注意：先使用hashCode进行筛选，可以提高哈希表的性能

尽可能合理地定义这个方法

* 有些类： 不同的对象（内存地址），哈希码不同；

* 有些类： 不同的内容， 哈希码不同

* 根据我们的需要决定是否重写方法，有以上两种情况，不过不管是哪种情况，根据以上第二、三点，

* 在使用时，（1）我们先用HashCode方法比较两个对象的哈希值是否相等，若不等，则一定不是同一个        

* 对象or内容相同；反之，进第二步判断

*（2）再用equals方法比较两个对象是否为同一个对象or内容是否相同，若返回结果为true，则同一个

*对象or内容相同

*之所以按照这个规则，我想大概基于两点：i、hashCode其实是将地址or内容采用一种算法进行映射得    

*到一种编码，而equals则是直接比较两个对象的地址or内容是否相同。 所以，hashCode存在冲突的

*现象————内容or地址不同的2个对象，hashCode值相同 ii、尽管equals是直接比较，但是其消耗较大

*所以，先用hashCode有助于提高性能，筛选掉大部分情况（毕竟冲突时小概率事件）

@return
*/
public native int hashCode();/**      

注意是非空对象的等价关系，也就是说，null不能调用

• 性质1、反射性--任何 非空引用 调用自身，返回结果都是true
• 2、 对称性--两个引用 互相调用，返回结果一样

• 3、 传递性

  4、 一致性--两个对象之间的调用 多少次还是那个结果 前提是没有信息被修改

• 5、 任意非空引用 调用null 返回的都是false

• 不管equals方法有没有重写，我们都要重写hashCode方法

*从而保证————equal的对象（无重写：内存地址相同，指向同一个对象；有重写：内容相同）      

*具有相同的hashCode值：for 地址or 内容的各个位 + hashCode算法 ==得到 相同的值      

*/

public boolean equals(Object obj) {

return (this == obj); // 比较的是两个对象的内存地址

// 前面总是说reference object，也就是引用型数据，而不是基本类型数据（比较简单）

//基本数据类型一般都是用 ==

}
/**      

• （1）clone方法是产生对象的一个独立副本
• （2）对象x和它clone的独立副本 调用getClass方法 结果一样
•  * 但这些不是绝对的条件（意思是clone可以重写吗？）
•    * x的clone副本 和 自己 equal  但是不是绝对的（意思是如果equal的是地址的话就不一定？）

•    按照惯例，返回的对象应该通过super.clone调用得到

• *如果一个类和它所有父类遵循这个惯例，那么x.clone().getClass() == x.getClass()

• 按照惯例，返回的对象是独立的

• *为了实现这个独立性，返回副本之前 有必要修改这个对象的一个or多个元素

• *通常，这意味着复制组成这个对象深层结构的所有可变元素，并用副本的引用替换这些元素的引用
• *如果一个类只包含原始字段、不可变元素的引用，那么super.clone返回的对象 没有字段需要修改
• *大概意思： 浅拷贝  只复制引用的值，没有复制可变元素所引用的对象

*/

protected native Object clone() throws CloneNotSupportedException;

深克隆与浅克隆

/**

*返回这个对象的 字符串表示
    *建议所有子类重写此方法
    返回的字符串包括：类的名字、@、对象的16进制表示的哈希值
      

• @return
*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}/**      

• 唤醒在这个对象的监视器上的 一个等待线程

*如果有线程在等待队列中等待（通过调用wait方法，一个线程在对象的监视器上等待），其中的一个

*被选中唤醒。这种选择是任意的，根据算法进行竞争（最着急的线程）

唤醒的线程将无法继续（被其他对象使用？在等待） 直到当前线程放弃对这个对象的锁定

*被唤醒的线程 以通用的方式 与任何其他（积极竞争同步这个对象的）线程竞争

*同步，是说没有特权，都有机会成为能够锁定该对象的线程

这个方法只能被一个线程（这个线程是 对象的监视器的所有者）调用

*一个线程可以以3种方式 成为这个对象的监视器的所有者

 1、在调用notify()之前，线程必须获得该对象的对象级别锁

* 2、执行完notify()方法后，不会马上释放锁，要直到退出synchronized代码块，当前线程才会释放

*锁

* 3、notify()一次只随机通知一个线程进行唤醒

原则：一次只能有一个线程 拥有一个对象的监视器

如果当前线程 不是这个对象的monitor的所有者，抛出IllegalMonitorStateException

*/

public final native void notify();

//唤醒所有 等待在这个对象的监视器上的线程

public final native void notifyAll();

//实现二：使线程进入等待状态，直到被notify or notifyAll调用

public final native void wait(long timeout) throws InterruptedException;

//第一种实现：使线程进入等待状态，直到被notify or notifyAll调用 or 等待时间达到限定值      

//timeout - 要等待的最长时间（以毫秒为单位）。

//nanos - 额外时间（以毫微秒为单位，范围是 0-999999）

//超时时间=1000000*timeout+nanos(毫微秒)。

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 > 0) {
        timeout++;
    }


    wait(timeout);
}      

//实现二：使线程进入等待状态，直到被notify or notifyAll调用

public final void wait() throws InterruptedException {

wait(0);

}      

//当垃圾回收器将要回收对象所占内存之前被调用

protected void finalize() throws Throwable { }      

作者：​​三号小玩家​​