object常用的方法

A. 面试问题java Object类有哪些方法

构造方法，用来初始化对象的时候用的，
toString()以字符串的形式返回；
equals 比较的是对象的引用地址的值

B. 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()
这个函数在进行垃圾回收的时候会用到，匿名对象回收之前会调用到，具体的例子如图所示

C. Java语言中Object类定义了哪11种方法

Java中所有类（包括用户自己定义的类）都自动继承Object类，即Object类是所有类的父类。

Object中常用方法：

public boolean equals（Object obj）

比较当前对象与obj是否为同一对象，返回值：ture/false

public 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)); //truex1行
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。

D. java中Object... 的用法是什么意思

居然 整个楼里面都答非所问了 看我的看我的哦 提问者都说的这么清楚了

这个问题很好

日常使用不定参数时候基本是Object...可以等同于Object[] obj一维数组理解的

数组本质是连续的指针地址 其中数组的头指针是必须的 但是二者的不同在于何处呢？

很明显
Obj...是针对方法传入参数的 即只能在method（）内使用

即 不定参数只能作为方法的形参，不能用作变量

然后你看我建立2个test犯法

java的 数组结构在jvm的堆和栈上是不同的 但是我个人没有理解这问题如果提问者了解欢迎回复我

有关不定参数的使用

public viod method(Object[] obj,Object...) {

Obj操了自己；

}

不过，不定参数有两个规定：第一，方法的参数列表中最多只有一个不定长度的参数；第二，就是不定长度的数组的位置必须是最后一个参数。不然不能通过编译。

E. 请描述object中有哪些方法及其作用

查看一下API讲解object的部分吧，这是一个超类，所有的类都是该类的子类。 超类，意思就是所有类的父类，有equals()、hashCode()、wait()、toString()等方法

F. python object 有哪些方法

调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。
hasattr(obj, attr):
这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
getattr(obj, attr):
调用这个方法将返回obj中名为attr值的属性的值，例如如果attr为’bar’，则返回obj.bar。
setattr(obj, attr, val):
调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为’bar’，则相当于obj.bar = val。

G. Object下有哪些方法

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方法

该方法唤醒在该对象上等待的所有线程。

H. 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年的砌匠不知道前后梁有多少瓴子（鲁班收徒的故事），您会怎么想？

I. 面试题：简述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

J. java object 有哪些方法

Java.lang.object类中有几个方法不是final的，我们会经常用重写它们，
protected Object clone() 创建并返回此对象的一个副本。
boolean equals(Object obj) 指示某个其他对象是否与此对象“相等”。
protected void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
int hashCode() 返回该对象的哈希码值。
String toString() 返回该对象的字符串表示。
1、clone()
我们为什么要用clone()?
当我们需要一个与某个对像时一模一样的对像时，但它们又是相互独立的，对它们各自的操作不会影响到另外的一个，这时候用clone()就可以
实现，当然，其他的方法也可以实现，但是重写clone()简单，高效
有一个不没重写clone()的例子，能帮助我们更好的去理解clone(),如下：
public class Test
{
public static void main(String[] args){
A a1=new A();
A a2=new A();
a1.name="a1";
a2=a1;
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

}

}
class A
{
public String name;

}
输出结果为：a1.name=a2;
a2.name=a2;
下面这个是重写了clone()的例子
public class Test
{
public static void main(String[] args) throws CloneNotSupportedException {
A a1=new A();
A a2=new A();
a1.name="a1";
a2=(A) a1.clone();
a2.name="a2";
System.out.println("a1.name="+a1.name);
System.out.println("a2.name="+a2.name);

}