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 { }


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