目录
java的object 类是所有类的父类，也就是说 java 的所有类都继承了 object，子类可以使用 object 的所有方法。object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 object，成为 object 的子类。
object 类可以显式继承，也可以隐式继承，以下两种方式是一样的：
// 显式继承:
public class runoob extends object{ }
// 隐式继承:
public class runoob { }
object 类提供的方法
| 方法 | 描述 |
|---|---|
| object() | 构造一个新对象 |
| protected object clone() | 创建并返回一个对象的拷贝 |
| boolean equals(object obj) | 比较两个对象是否相等 |
| protected void finalize() | 当 gc (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法 |
| class getclass() | 获取对象的运行时对象的类 |
| int hashcode() | 获取对象的 hash 值 |
| void notify() | 唤醒在该对象上等待的某个线程 |
| void notifyall() | 唤醒在该对象上等待的所有线程 |
| string tostring() | 返回对象的字符串表示形式 |
| void wait() | 让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyall() 方法 |
| void wait(long timeout) | 让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyall() 方法，或者超过参数设置的timeout超时时间 |
| void wait(long timeout, int nanos) | 与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒 |
方法实例
clone() 方法
protected native object clone() throws clonenotsupportedexception;
描述：
用于创建并返回一个对象的拷贝。clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存。
参数：
无
返回值：
返回一个对象的拷贝。
注意：
由于 object 本身没有实现 cloneable 接口，所以不重写 clone 方法并且进行调用的话会发生 clonenotsupportedexception 异常。
public class test implements cloneable {
// 声明变量
string name;
int likes;
// 属性引用的对象
juejin juejin;
test() {
this.juejin = new juejin();
}
public static void main(string args[]) {
// 创建对象
test obj1 = new test();
// 初始化变量
obj1.name = "runoob";
obj1.likes = 111;
obj1.juejin.name = "掘金";
// 打印输出
system.out.println("obj1 的 name = " obj1.name); // runoob
system.out.println("obj1 的 likes = " obj1.likes); // 111
system.out.println("obj1 的 juejin 的 name = " obj1.juejin.name); //掘金
try {
// 创建 obj1 的拷贝
test obj2 = (test) obj1.clone();
obj2.name = "juejin";
obj2.likes = 222;
obj2.juejin.name = "稀土掘金";
// 使用 obj2 输出变量
system.out.println();
system.out.println("obj2 的 name = " obj2.name); // juejin
system.out.println("obj2 的 likes = " obj2.likes); // 222
system.out.println("obj2 的 juejin 的 name = " obj2.juejin.name); //稀土掘金
system.out.println();
system.out.println("浅拷贝的问题");
system.out.println("obj1 的 name = " obj1.name); // runoob
system.out.println("obj1 的 likes = " obj1.likes); // 111
system.out.println("obj1 的 juejin 的 name = " obj1.juejin.name); //稀土掘金
} catch (exception e) {
system.out.println(e);
}
}
}
class juejin {
public string name;
}
// 以上程序执行结果为：
// obj1 的 name = runoob
// obj1 的 likes = 111
// obj1 的 juejin 的 name = 掘金
// obj2 的 name = juejin
// obj2 的 likes = 222
// obj2 的 juejin 的 name = 稀土掘金
// 浅拷贝的问题
// obj1 的 name = runoob
// obj1 的 likes = 111
// obj1 的 juejin 的 name = 稀土掘金
解析：
由于浅拷贝对对象内属性引用的对象只会拷贝引用地址，所以 obj1 与 obj2 的 juejin 属性引用的对象指向同一内存地址，所以在 obj2 修改 juejin 的 name 属性后，obj1 的 juejin 的 name 属性也发生了变化。
equals() 方法
public boolean equals(object obj)
描述：
用于比较两个对象是否相等。比较两个对象时，是通过判断两个对象引用指向的是同一个对象，即比较 2 个对象的内存地址是否相等。
参数：
obj -- 要比较的对象。
返回值：
如果两个对象相等返回 true，否则返回 false。
注意：
不同的类重写了 equals() 方法，导致equals() 方法的行为有所不同。但如果子类重写了 equals() 方法，就需要重写 hashcode() 方法，比如 string 类就重写了 equals() 方法，同时也重写了 hashcode() 方法。
public class test implements cloneable {
public static void main(string args[]) {
// 创建两个对象
object obj1 = new object();
object obj2 = new object();
// 判断 obj1 与 obj2 是否相等
// 不同对象，内存地址不同，不相等，返回 false
system.out.println(obj1.equals(obj2)); // false
// obj1 赋值给 obj3
// 对象引用，内存地址相同，相等，返回 true
object obj3 = obj1;
system.out.println(obj1.equals(obj3)); // true
}
}
// 以上程序执行结果为：
// false
// true
finalize() 方法
protected void finalize() throws throwable { }
描述：
用于实例被垃圾回收器回收的时触发的操作。当 gc (垃圾回收器) 确定不存在对该对象的有更多引用时，对象的垃圾回收器就会调用这个方法。
参数：
无
返回值：
无
public class test {
public static void main(string args[]) {
junjin junjin = new junjin();
junjin = null;
system.gc();
}
}
class junjin {
@override
protected void finalize() throws throwable {
super.finalize();
system.out.println("对象被回收了");
}
}
// 以上程序执行结果为：
// 对象被回收了
getclass() 方法
public final native class getclass();
描述：
用于获取对象的运行时对象的类。
参数：
无
返回值：
返回对象的类。
public class test {
public static void main(string args[]) {
// getclass() with object
object obj1 = new object();
system.out.println("obj1 的类为: " obj1.getclass());
// getclass() with string
string obj2 = new string();
system.out.println("obj2 的类为: " obj2.getclass());
// getclass() with arraylist
arraylist obj3 = new arraylist<>();
system.out.println("obj3 的类为: " obj3.getclass());
}
}
// 以上程序执行结果为：
// obj1 的类为: class java.lang.object
// obj2 的类为: class java.lang.string
// obj3 的类为: class java.util.arraylist
hashcode() 方法
public native int hashcode();
描述：
用于获取对象的 hash 值。
参数：
无
返回值：
返回对象哈希值，是一个整数，表示在哈希表中的位置。
public class test {
public static void main(string args[]) {
// object 使用 hashcode()
object obj1 = new object();
// obj1 赋值给 obj2
object obj2 = obj1;
// 判断两个对象是否相等
system.out.println(obj1.equals(obj2)); // true
// 获取 obj1 与 obj2 的哈希值
system.out.println("对象相等则hashcode一定相等");
system.out.println(obj1.hashcode()); // 225534817
system.out.println(obj2.hashcode()); // 225534817
}
}
// 以上程序执行结果为：
// true
// 对象相等则hashcode一定相等
// 692404036
// 692404036
wait() 方法
// 该方法有以下几种语法格式： public final void wait() throws interruptedexception public final native void wait(long timeout) throws interruptedexception public final void wait(long timeout, int nanos) throws interruptedexception
描述：
让当前线程进入等待状态。
参数：
- timeout -- 等待超时时间（以毫秒为单位）。如果 timeout 参数为 0，则不会超时，会一直进行等待，类似于 wait() 方法。如果阻塞的时间超过该参数时间，会唤醒线程。
- nanos -- 额外时间（以纳秒为单位，范围是 0-999999）。如果设置该时间，超时的时间还需要加上 nanos 纳秒。
返回值：
无
注意：
- 当前线程必须是此对象的监视器所有者，否则还是会发生 illegalmonitorstateexception 异常。
- 如果当前线程在等待之前或在等待时被任何线程中断，则会抛出 interruptedexception 异常。
- 如果传递的参数不合法，则会抛出 illegalargumentexception 异常。
notify() 与 notifyall() 方法
public final native void notify();
描述：
用于唤醒一个在此对象监视器上等待的线程。如果所有的线程都在此对象上等待，那么只会选择一个线程，选择是任意性的，并在对实现做出决定时发生。
参数：
无
返回值：
无
public final native void notifyall();
描述：
用于唤醒在该对象上等待的所有线程。notifyall() 方法跟 notify() 方法的区别在于 notifyall() 方法唤醒在此对象监视器上等待的所有线程，notify() 方法是一个线程。
参数：
无
返回值：
无
public class test {
// 声明一个同步列表
private list synchedlist;
/**
* 构造方法
*/
public test() {
// 创建一个同步列表
synchedlist = collections.synchronizedlist(new linkedlist());
}
/**
* 删除列表中的元素
* @return 删除的元素
* @throws interruptedexception
*/
public string removeelement() throws interruptedexception {
synchronized (synchedlist) {
// 列表为空就等待
while (synchedlist.isempty()) {
system.out.println("列表是空的...");
system.out.println("线程 " thread.currentthread().getname() " 将开始等待...");
synchedlist.wait();
system.out.println("线程 " thread.currentthread().getname() " 等待结束!");
}
// 删除元素
string element = (string) synchedlist.remove(0);
// 返回删除的元素
return element;
}
}
/**
* 添加元素到列表
* @param element 要添加的元素
*/
public void addelement(string element) {
synchronized (synchedlist) {
// 添加一个元素，并通知元素已存在
synchedlist.add(element);
system.out.println("添加了新元素:'" element "'");
synchedlist.notify();
system.out.println("notify 已调用，唤醒 synchedlist 上等待的任意一个线程!");
//synchedlist.notifyall();
//system.out.println("notifyall 已调用，唤醒 synchedlist 上等待的所有线程!");
}
system.out.println("添加元素完成...");
}
/**
* main 函数
* @param args
*/
public static void main(string args[]) {
final test demo = new test();
runnable runa = new runnable() {
public void run() {
try {
// 删除 synchedlist 中的一个元素并输出
string item = demo.removeelement();
system.out.println("删除了元素 " item);
} catch (interruptedexception ix) {
system.out.println("中断的异常!");
} catch (exception x) {
system.out.println("exception thrown.");
}
}
};
runnable runb = new runnable() {
// 执行添加元素操作，并开始循环
public void run() {
demo.addelement("hello!");
}
};
try {
// 创建线程 threada1 并开始执行
thread threada1 = new thread(runa, "google");
threada1.start();
// 当前执行 main 方法的线程休眠
thread.sleep(500);
// 创建线程 threada2 并开始执行
thread threada2 = new thread(runa, "runoob");
threada2.start();
// 当前执行 main 方法的线程休眠
thread.sleep(500);
// 创建线程 threadb 并开始执行
thread threadb = new thread(runb, "taobao");
threadb.start();
// 当前执行 main 方法的线程休眠
thread.sleep(1000);
// 中断 threada1 线程
threada1.interrupt();
// 中断 threada2 线程
threada2.interrupt();
} catch (interruptedexception x) {
system.out.println(x);
}
}
}
使用 notify() 方法唤醒线程时，可以看到 google 线程的等待被唤醒了，但 runoob 线程的等待最终没有被唤醒，输出如下：
列表是空的...
线程 google 将开始等待...
列表是空的...
线程 runoob 将开始等待...
添加了新元素:'hello!'
notify 已调用，唤醒 synchedlist 上等待的任意一个线程!
添加元素完成...
线程 google 等待结束!
删除了元素 hello!
中断的异常!
使用 notifyall() 方法唤醒线程时，可以看到 runoob 与 google 线程的等待都被唤醒了，但 runoob 线程唤醒后将集合中的元素删除了，所以集合再次变为空的，google 就再次进入了等待状态，输出如下：
列表是空的...
线程 google 将开始等待...
列表是空的...
线程 runoob 将开始等待...
添加了新元素:'hello!'
notifyall 已调用，唤醒 synchedlist 上等待的所有线程!
添加元素完成...
线程 runoob 等待结束!
删除了元素 hello!
线程 google 等待结束!
列表是空的...
线程 google 将开始等待...
中断的异常!
注意：
notify() 与 notifyall() 方法只能被作为此对象监视器的所有者的线程来调用。如果当前线程不是此对象监视器的所有者的话会抛出 illegalmonitorstateexception 异常。
一次只能有一个线程拥有对象的监视器。一个线程要想成为对象监视器的所有者，可以使用以下 3 种方法：
- 执行对象的同步实例方法
- 使用 synchronized 内置锁
- 对于 class 类型的对象，执行同步静态方法
tostring() 方法
public string tostring()
描述：
用于返回对象的字符串表示形式。
参数：
无
返回值：
返回对象的字符串表示形式。默认返回格式：对象的 class 名称 @ hashcode 的十六进制字符串。
public class test {
public static void main(string[] args) {
// tostring() with object
object obj1 = new object();
system.out.println(obj1.tostring());
object obj2 = new object();
system.out.println(obj2.tostring());
object obj3 = new object();
system.out.println(obj3.tostring());
}
}
// 以上程序执行结果为：
// java.lang.object@29453f44
// java.lang.object@5cad8086
// java.lang.object@6e0be858
以上就是详解java中object 类的使用的详细内容，更多关于java object 类的资料请关注其它相关文章！
