Ⅰ object类方法
Object类有12个成员方法，按照用途可以分为以下几种
1，构造函数
2，hashCode和equale函数用来判断对象是否相同,
3，wait(),wait(long),wait(long,int),notify(),notifyAll()
4，toString()和getClass,
5，clone()
6，finalize()用于在垃圾回收
函数说明
clone()
clone()函数的用途是用来另存一个当前存在的对象。
hashCode()和equale()
equale()用于确认两个对象是否相同。
hashCode()用于获取对象的哈希值，这个值的作用是检索，具体的作用可以参考这里
哈希值相同的对象不一定equale()
equale()返回true的两个对象一定相同。
toString()和getClass()
toString()返回一个String对象，用来标识自己
getClass()返回一个Class对象，如果打印出来会发现结果是如下格式
class package.name.xxx
1
因为返回的是一个class对象,后面可以跟class类的方法。用的是谁的构造函数，那么getClass返回的就是谁的类型。
getClass()经常用于java反射机制
wait(),wait(long),wait(long,int),notify(),notifyAll()
这几个函数体现的是Java的多线程机制
在使用的时候要求在synchronize语句中使用
wait()用于让当前线程失去操作权限，当前线程进入等待序列
notify()用于随机通知一个持有对象的锁的线程获取操作权限
notifyAll()用于通知所有持有对象的锁的线程获取操作权限
wait(long) 和wait(long,int)用于设定下一次获取锁的距离当前释放锁的时间间隔
finalize()
这个函数在进行垃圾回收的时候会用到，匿名对象回收之前会调用到，具体的例子如图所示
Ⅱ 面试问题java Object类有哪些方法
构造方法，用来初始化对象的时候用的，
toString()以字符串的形式返回；
equals 比较的是对象的引用地址的值
Ⅲ 面试题：简述object类9个方法的作用
简介： Java克隆(Clone)是Java语言的特性之一，但在实际中应用比较少见。但有时候用克隆会更方便更有效率。 对于克隆(Clone)，Java有一些限制： 1、被克隆的类必须自己实现Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口，没有任何接口方法。 2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。 3、在Java.lang.Object类中克隆方法是这么定义的： protected Object clone() throws CloneNotSupportedException 创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。 按照惯例，返回的对象应该通过调用 super.clone 获得。 引题： 举个例子说吧，现在有一个对象比如叫foo，你需要在创建当前对象的一个副本作为存根你能怎么做？ 假如你不用Clone，那么你可以先new一个对象foo1： Foo foo1=new Foo(), 然后用foo给foo1对象set值，这样就得到foo的副本foo1；除此之外，别无选择。 这样说，也许有人会觉得说的过于绝对了，不过事实如此啊。 要产生一个副本，那副本要不要内存？----当然要了，那就对了！既然需要内存，（不克隆的情况下）你不new还有什么办法呢？请大家时刻铭记对象是Java运行时产生的，驻留在计算机内存中。 常见错误： 下面我澄清几个初学者容易犯迷糊的错误，同样的问题，产生foo对象的副本： 1、Foo foo1=new Foo(); foo1=foo; 然后就想当然的认为副本foo1生成了！ 错误原因：foo1没错是申请了内存，但是执行foo1=foo后，foo1就不在指向刚申请的内存区域了，转而指向foo对象的内存区域，这时候，foo1、foo指向了同一内存区域。刚才new的操作制造一堆垃圾等着JVM回收。 2、Foo foo1=foo; 错误原因：还是两个变量都指向了同一块内存。 3、有些老鸟更厉害一些：在Foo中定义一个返回自身的方法： public Foo getInstance(){ return this; } 然后，Foo foo1=foo.getInstance(); 错误原因：同上，主要还是没有重新开辟内存，this在对象里是什么？----就是对象自己的引用！那么getInstance()自然返回的就是对象自己，反正又是两个对象穿了一条裤子----***，哈哈。错得心服口服吧。为了节省篇幅，我在最后写个例子，留给那些对此有异议的人看。 引入克隆 看了这么多方法都不行，还很麻烦！干脆用克隆吧，简单明了。 废话不说了，看例子： 定义两个类CloneFooA、CloneFooB，然后写个测试类CloneDemo分别克隆这两个类的对象，然后打印测试结果到控制台。 /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:40:44 * 简单类克隆实现 * 要实现克隆,必须实现Cloneable接口,这是一个标识接口,没有接口方法 * 实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。 * 按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）。 */ public class CloneFooA implements Cloneable { private String strA; private int intA; public CloneFooA(String strA, int intA) { this.strA = strA; this.intA = intA; } public String getStrA() { return strA; } public void setStrA(String strA) { this.strA = strA; } public int getIntA() { return intA; } public void setIntA(int intA) { this.intA = intA; } /** * @return 创建并返回此对象的一个副本。 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //直接调用父类的clone()方法,返回克隆副本 return super.clone(); } } /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:59:55 * 深度克隆对象,当类存在聚合关系的时候,克隆就必须考虑聚合对象的克隆 */ public class CloneFooB implements Cloneable { private CloneFooA fooA; private Double douB; public CloneFooB(Double douB) { this.douB = douB; } public CloneFooB(CloneFooA fooA, Double douB) { this.fooA = fooA; this.douB = douB; } public CloneFooA getFooA() { return fooA; } public void setFooA(CloneFooA fooA) { this.fooA = fooA; } public Double getDouB() { return douB; } public void setDouB(Double douB) { this.douB = douB; } /** * 克隆操作 * * @return 自身对象的一个副本 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //先调用父类的克隆方法进行克隆操作 CloneFooB cloneFooB = (CloneFooB) super.clone(); //对于克隆后出的对象cloneFooB,如果其成员fooA为null,则不能调用clone(),否则出空指针异常 if (this.fooA != null) cloneFooB.fooA = (CloneFooA) this.fooA.clone(); return cloneFooB; } } /** * Created by IntelliJ IDEA. * User: leimin * Date: 2007-9-20 * Time: 19:52:01 * 测试类：分别克隆CloneFooA和CloneFooB类,并打印克隆前后的结果. */ public class CloneDemo { public static void main(String args[]) throws CloneNotSupportedException { //CloneFooA克隆前 CloneFooA fooA1 = new CloneFooA("FooA", 11); System.out.println("CloneFooA的对象克隆前对象fooA1值为: " + fooA1.getStrA() + "," + fooA1.getIntA()); //CloneFooA克隆后 CloneFooA fooA2 = (CloneFooA) fooA1.clone(); System.out.println("CloneFooA的对象克隆后对象fooA2值为: " + fooA2.getStrA() + "," + fooA2.getIntA()); //比较fooA1和fooA2内存地址 if (fooA1 == fooA2) System.out.println("比较fooA1和fooA2内存地址:相等!"); else System.out.println("比较fooA1和fooA2内存地址:不相等!"); System.out.println("-------------------------"); //CloneFooB克隆前 CloneFooB fooB1 = new CloneFooB(fooA1, new Double("33")); System.out.println("CloneFooB的对象克隆前对象fooB1值为: " + fooB1.getFooA().getStrA() + "," + fooB1.getFooA().getIntA() + " | " + fooB1.getDouB()); //CloneFooB克隆后 CloneFooB fooB2 = (CloneFooB) fooB1.clone(); System.out.println("CloneFooB的对象克隆前对象fooB2值为: " + fooB2.getFooA().getStrA() + "," + fooB2.getFooA().getIntA() + " | " + fooB2.getDouB()); if (fooA1 == fooA2) System.out.println("比较fooB1和fooB2内存地址:相等!"); else System.out.println("比较fooB1和fooB2内存地址:不相等!"); } } 运行结果： CloneFooA的对象克隆前对象fooA1值为: FooA,11 CloneFooA的对象克隆后对象fooA2值为: FooA,11 比较fooA1和fooA2内存地址:不相等! ------------------------- CloneFooB的对象克隆前对象fooB1值为: FooA,11 | 33.0 CloneFooB的对象克隆前对象fooB2值为: FooA,11 | 33.0 比较fooB1和fooB2内存地址:不相等! Process finished with exit code 0 反面教材： 最后，我给出我上面提出到最后要给出的反面例子。 随便写一个，在CloneFooA 的基础上做了少许改动，内容如下： public class CloneFooA implements Cloneable { private String strA; private int intA; public CloneFooA(String strA, int intA) { this.strA = strA; this.intA = intA; } public String getStrA() { return strA; } public void setStrA(String strA) { this.strA = strA; } public int getIntA() { return intA; } public void setIntA(int intA) { this.intA = intA; } /** * @return 创建并返回此对象的一个副本。 * @throws CloneNotSupportedException */ public Object clone() throws CloneNotSupportedException { //直接调用父类的clone()方法,返回克隆副本 return super.clone(); } /** * @return 返回运行时的对象 */ public CloneFooA getInstance(){ return this; } public static void main(String args[]){ CloneFooA fooA=new CloneFooA("aa",11); System.out.println(fooA.getStrA()+" "+fooA.getIntA()); CloneFooA fooA1=fooA.getInstance(); System.out.println(fooA1.getStrA()+" "+fooA1.getIntA()); if(fooA==fooA1) System.out.println("fooA和fooA1内存地址相等!"); System.out.println("-------------------------"); //改变后fooA或者fooA1中任何一个,看看另外一个是否会改变 fooA1.setStrA("bb"); System.out.println(fooA.getStrA()+" "+fooA.getIntA()); System.out.println(fooA1.getStrA()+" "+fooA1.getIntA()); if(fooA==fooA1) System.out.println("fooA和fooA1内存地址相等,改变fooA1后,fooA的值也跟着变化了"); } } 运行结果： aa 11 aa 11 fooA和fooA1内存地址相等! ------------------------- bb 11 bb 11 fooA和fooA1内存地址相等,改变fooA1后,fooA的值也跟着变化了 Process finished with exit code 0
Ⅳ Java object类中有哪些方法归类总结一下
试问的最多的问题是：“”。一般情况下，3年以上工作经验的回答少于6个方法的，会导致减分，2年以下工作经验的知道6个以上会加分。到阿里云后面试过30+，回答让我满意的人很少。 作为一个半路出家当程序员，开始我总是痴迷于应用。a框架的配置，b框架的模板，c框架的控制……其实我对Java底层了解的很少，也没有想过了解java的底层。触动我去看Object类的是几件事。 在上个东家做消息全网传输的时候，我用BeanUtil.Properties()拷贝对象的值，觉得很爽，后面某同事review我的代码提示我可以覆写对象的clone()方法的，毕竟，反射的效率是比较低的。然后当我去做的时候，发现了更好的选择。然后在打印日志的时候，我习惯拼接属性，于是又被提示覆写toString()方法是包爽的，就这样，我认识了Object的2个方法。 看《Effecive Java》这本书，中间提到“为什么覆写equals()方法的时候总是要覆写hashcode()”。开始第一遍没有看懂，也懒得管了，因为hashcode我用的少，后来去参加一个面试，被人问到的时候，感觉无比的尴尬，我读过，却不知道答案！这是个人总结能力的问题，后面又不能不回来仔细看看这2个方法到底是做什么的。 关于线程的notify() ， notifyAll() ， wait()‘3个’ 方法，学习线程的时候看过，不过自从用了JUC的包，我基本没有在代码中使用过了。每次用eclipse的“alt + /” 快捷键从后翻总能看到，所以无论如何，这几个方法应该知道。 写到这里，有7个方法了，这几个方法很容易想到，在我开发java2年后，能够回答Object类中的7个方法。其实clone()方法不常用，所以，我 说的数字6是有依据的。这6个方法，作为java程序员，天天不见也会见几次。如果写了几年java代码不知道基类里面的方法，就算你Hbase玩的再 熟，我凭什么相信你能写优质代码？如果一个在农村盖房子3年的砌匠不知道前后梁有多少瓴子（鲁班收徒的故事），您会怎么想？
Ⅳ 2020-09-10：java里Object类有哪些方法
Java Object类是所有类的父类，主要方法有：
getClass（）：获取运行时类型,返回值为Class对象
2.hashCode（）：返回该对象的哈希码值，是为了提高哈希表的性能（HashTable）
3.equals（）：判断两个对象是否相等，在Object源码中equals就是使用==去判断，所以在Object中equals是等价于==的，但是在String及某些类对equals进行了重写，实现不同的比较。
4.clone（）：JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，我们有时候不希望在方法里讲参数改变，这是就需要在类中复写clone方法。此方法只实现了一个浅层拷贝,对于基本类型字段成功拷贝,对嵌套对象,只把地址拷贝了,需要自己重写clone方法进行深度拷贝。
5.toString（）：返回一个String字符串,用于描述当前对象的信息,可以重写返回对自己有用的信息，默认返回的是当前对象的类名+hashCode的16进制数字。
6.wait（）：多线程时用到的方法，作用是让当前线程进入等待状态，同时也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，当前线程被唤醒
7.notify（）：多线程时用到的方法，唤醒该对象等待的某个线程
8.notifyAll（）：多线程时用到的方法，唤醒该对象等待的所有线程
9.finalize（）：对象在被GC释放之前调用finalize方法。
你明白了吗？
Ⅵ object类的六个方法都有什么分别是什么意思有什么用途
protected Object clone()
创建并返回此对象的一个副本。
boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。
protected void finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
Class<?> getClass()
返回此 Object 的运行时类。
int hashCode()
返回该对象的哈希码值。
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
String toString()
返回该对象的字符串表示。
void wait()
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void wait(long timeout)
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
void wait(long timeout, int nanos)
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导
Ⅶ JAVA中Object类中 有几个方法
Java中Object类Java基础Java中所有类（包括用户自己定义的类）都自动继承Object类，即Object类是所有类的父类。Object中常用方法：public boolean equals（Object obj）比较当前对象与obj是否为同一对象，返回值：ture/falsepublic String toString（）返回当前对象的字符串表达形式public native int hashCode（）；返回对象的Hash码。Hash码是标志对象的唯一值，Hash码相同的对象是同一对象protected void finalize（）throws Throwable对象销毁时被调用以下三个函数用于控制线程public final native void notify（）；public final native void notifyAll（）；public final native void wait（）；native型方法指由C++语言编写的方法，Java解释器对其进行转义后才执行。“==”与equals()"==" 一般用于基本数据类型比较。若用作两个引用对象比较，仅当引用变量引用同一个对象时，才返回true,否则false。 void EqualCompare()
{
String s1 = new String("Hello");
String s2 = new String("Hello");
String s3 = "Hello";
String s4 = "Hello"; //未使用new，s4引用既存的对象（编译器创建对象之前先进行检测"Hello"是否已经存在，若存在，则返回原对象的引用）
System.out.println(s1.equals(s2)); // true x1行
System.out.println(s1 ==s2); // false 两变量引用不同对象
System.out.println(s3.equals(s4)); //true 两变量引用相同对象
System.out.println(s3 ==s4); // true 两变量引用相同对象
}比较对象时，一般用equal()方法。Object类方法定义：public boolean equals（Object obj）{ return （this == obj);}不同的类可方便的对该对象进行覆盖。String类就覆盖了Object类的equals()方法，所以x1行输出true.a==b 如果a,b引用同一对象，则返回true；a.equals(b) 如果a对象内容和b对象内容相同，则返回true如果未重载equals（）方法的类对象使用该方法与另一个对象进行比较，则调用Object的equals()方法，仍然是对象的比较，返回值为false。
Ⅷ java里的object类里面有什么方法
查看一下API讲解object的部分吧，这是一个超类，所有的类都是该类的子类。
超类，意思就是所有类的父类，有equals()、hashCode()、wait()、toString()等方法
Ⅸ java中object类中有哪些方法
java语言中Object是所有类的父类，任何类都默认继承Object。Object类到底实现了哪些方法？
（1）clone方法
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
（2）getClass方法
final方法，获得运行时类型。
（3）toString方法
该方法用得比较多，一般子类都有覆盖。
（4）finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
（5）equals方法
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
（6）hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
（7）wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
（8）notify方法
该方法唤醒在该对象上等待的某个线程。
（9）notifyAll方法
该方法唤醒在该对象上等待的所有线程。
Ⅹ 简要说明object类有什么特点
Object类是所有类的父类，声明一个Object类的作用就是可以传递任何类型的类来使用。
Object是所有类的父类，它有很多类对象会用到的方法，例如比较常用的toString 、equals，当你新建xx类时，你可以重写Object已经定义的方法，也可以直接调用Object中的方法，如果你写一个封装的方法，不确定传进来的是什么类型的值，就可以使用Object作为一个笼统类