Java基础--常用API--java.lang.Object

一、简述

　　1、object类是所有类的父类，即直接或间接的继承java.lang.object类。省略了extends object。

 

　　2、方法

　　　　（1）protected native object clone() throws clonenotsupportedexception; //创建并返回一个对象的副本。

　　　　（2）public string tostring();  //返回一个字符串，一般需要重写。

　　　　（3）public final native class<?> getclass();  //返回对象在运行时的类的类型

　　　　（4）public boolean equals(object obj);  //用来判断调用equals对象与参数对象obj是否为同一个对象，一般需重写。

　　　　（5）public native int hashcode(); //返回对象的哈希码，可用于哈希查找，减少equals比较的次数，一般重写equals方法后也要重写hashcode方法。

　　　　（6）protected void finalize() throws throwable { }; //该方法用于释放资源，无法确定该方法什么时候被调用。

　　　　（7）public final native void wait(long timeout) throws interruptedexception; //使当前线程等待锁，直到获取锁或被中断，timeout指的是最长等待时间。

　　　　（8）public final native void notify(); //用于随机唤醒该对象上等待的某个线程。

　　　　（9）public final native void notifyall(); //用于唤醒该对象上等待的所有线程。

 

　　3、由于getclass()、notify()、notifyall()、wait()等方法被final修饰，所以不能被重写。

 

二、clone()

　　1、clone()方法作用是返回一个object对象的复制，且复制的对象是一个新的对象。

　　

　　2、使用clone()方法时，需要实现cloneable接口，否则会抛出异常（clonenotsupportedexception）。

 

　　3、分类：浅复制（shallow clone）与深复制（deep clone）

　　　　（1）浅复制：复制后的对象的所有变量都与原有对象的值相同，且所有对其他对象的引用仍指向原来的对象。简单的讲，对于基本类型，复制的是数据，对于引用类型，复制的是数据的地址。即浅复制复制当前对象，不复制当前对象中的引用对象。

　　　　　　注意一个坑：对于引用类型，复制的是数据的地址（通过地址访问对象的真实数据）。若通过地址来修改对象，那么原有对象以及复制的对象均会修改相应的值。但若是修改了地址（比如new了一个对象，则地址发生改变，而原有的对象并未发生改变），则只有被修改的对象才会发生改变。

　　　　（2）深复制：指的是完全复制，将当前对象整体复制，并创建一个新的对象保存。即深复制复制当前对象，且复制当前对象中的引用对象。简单的讲，深复制在浅复制的基础上，将引用类型再复制一份，其中引用类型需要实现cloneable接口（如下例中的people类实现了cloneable接口）。

　　　　　　注意一个坑：只有实现了cloneable接口，才能调用clone()方法。

/**
 * 引用类型，用于测试浅复制与深复制的差别。 若只是浅复制，不用实现clonable接口。 若是深复制，则要实现cloneable接口以及clone方法。
 */
class people implements cloneable {
    private string name;
    private int age;

    public people(string name, int age) {
        this.name = name;
        this.age = age;
    }

    public string getname() {
        return name;
    }

    public void setname(string name) {
        this.name = name;
    }

    public int getage() {
        return age;
    }

    public void setage(int age) {
        this.age = age;
    }

    @override
    public string tostring() {
        return "people [name=" + name + ", age=" + age + "]";
    }

    @override
    protected object clone() throws clonenotsupportedexception {
        return super.clone();
    }
}

/**
 * 浅复制
 */
class shallowclonedemo implements cloneable {
    private people people;
    private string sex;

    public shallowclonedemo(people people, string sex) {
        this.people = people;
        this.sex = sex;
    }

    public string getsex() {
        return sex;
    }

    public void setsex(string sex) {
        this.sex = sex;
    }

    public people getpeople() {
        return people;
    }

    public void setpeople(people people) {
        this.people = people;
    }

    @override
    protected object clone() {
        try {
            return (shallowclonedemo) super.clone();
        } catch (clonenotsupportedexception e) {
            system.out.println("shallow clone error");
            return null;
        }
    }

    @override
    public string tostring() {
        return "shallowclonedemo [people=" + people + ", sex=" + sex + "]";
    }
}

/**
 * 深复制
 */
class deepclonedemo implements cloneable {
    private people people;
    private string sex;

    public deepclonedemo(people people, string sex) {
        this.people = people;
        this.sex = sex;
    }

    public people getpeople() {
        return people;
    }

    public void setpeople(people people) {
        this.people = people;
    }

    public string getsex() {
        return sex;
    }

    public void setsex(string sex) {
        this.sex = sex;
    }

    @override
    protected object clone() {
        deepclonedemo obj = null;
        try {
            obj = (deepclonedemo) super.clone();// 浅复制
            obj.people = (people) this.getpeople().clone();// 需要克隆引用类型
        } catch (clonenotsupportedexception e) {
            system.out.println("deep clone error");
            return null;
        }
        return obj;
    }

    @override
    public string tostring() {
        return "deepclonedemo [people=" + people + ", sex=" + sex + "]";
    }

}

/**
 * 测试类，用于测试浅复制与深复制
 */
public class test {
    public static void main(string[] args) {
        system.out.println("普通实例化一个shallowclonedemo：");
        shallowclonedemo shallowclonedemo1 = new shallowclonedemo(new people("rick", 18), "man");
        system.out.println("实例化完成");
        system.out.println();

        system.out.println("通过clone()方法浅复制克隆一个shallowclonedemo：");
        system.out.println("start shallow cloning");
        shallowclonedemo shallowclonedemo2 = (shallowclonedemo) shallowclonedemo1.clone();
        system.out.println("shallow clone end");
        system.out.println();

        system.out.println("输出原有对象以及浅复制克隆对象的值：");
        system.out.println(shallowclonedemo1);
        system.out.println(shallowclonedemo2);
        system.out.println();

        system.out.println("对原有对象进行修改后,输出原有对象以及浅复制克隆对象的值：");
        shallowclonedemo1.getpeople().setname("tom");
        shallowclonedemo2.getpeople().setage(20);
        shallowclonedemo1.setsex("woman");
        system.out.println(shallowclonedemo1);
        system.out.println(shallowclonedemo2);
        system.out.println("结果显示，浅复制对象会随着原有对象一起修改。");
        system.out.println("这里由于string类型相当于指向了一个新地址，所以只有被修改的对象改变值");
        system.out.println();

        system.out.println("普通实例化一个deepclonedemo：");
        deepclonedemo deepclonedemo1 = new deepclonedemo(new people("rick", 18), "man");
        system.out.println("实例化完成");
        system.out.println();

        system.out.println("通过clone()方法深复制克隆一个deepclonedemo：");
        system.out.println("start deep cloning");
        deepclonedemo deepclonedemo2 = (deepclonedemo) deepclonedemo1.clone();
        system.out.println("deep clone end");
        system.out.println();

        system.out.println("输出原有对象以及深复制克隆对象的值：");
        system.out.println(deepclonedemo1);
        system.out.println(deepclonedemo2);
        system.out.println();

        system.out.println("对原有对象进行修改后,输出原有对象以及浅复制克隆对象的值：");
        deepclonedemo1.getpeople().setname("tom");
        deepclonedemo2.getpeople().setage(20);
        deepclonedemo1.setsex("woman");
        system.out.println(deepclonedemo1);
        system.out.println(deepclonedemo2);
        system.out.println("结果显示，深复制时对象是独立的，互不干扰。");
        system.out.println("这里由于string类型相当于指向了一个新地址，所以只有被修改的对象改变值");
    }
}
/*
测试结果：
普通实例化一个shallowclonedemo：
实例化完成

通过clone()方法浅复制克隆一个shallowclonedemo：
start shallow cloning
shallow clone end

输出原有对象以及浅复制克隆对象的值：
shallowclonedemo [people=people [name=rick, age=18], sex=man]
shallowclonedemo [people=people [name=rick, age=18], sex=man]

对原有对象进行修改后,输出原有对象以及浅复制克隆对象的值：
shallowclonedemo [people=people [name=tom, age=20], sex=woman]
shallowclonedemo [people=people [name=tom, age=20], sex=man]
结果显示，浅复制对象会随着原有对象一起修改。
这里由于string类型相当于指向了一个新地址，所以只有被修改的对象改变值

普通实例化一个deepclonedemo：
实例化完成

通过clone()方法深复制克隆一个deepclonedemo：
start deep cloning
deep clone end

输出原有对象以及深复制克隆对象的值：
deepclonedemo [people=people [name=rick, age=18], sex=man]
deepclonedemo [people=people [name=rick, age=18], sex=man]

对原有对象进行修改后,输出原有对象以及浅复制克隆对象的值：
deepclonedemo [people=people [name=tom, age=18], sex=woman]
deepclonedemo [people=people [name=rick, age=20], sex=man]
结果显示，深复制时对象是独立的，互不干扰。
这里由于string类型相当于指向了一个新地址，所以只有被修改的对象改变值
*/

 

三、tostring、getclass

　　1、object 类的 tostring 方法返回一个字符串，该字符串由类名、标记符“@”和此对象哈希码的无符号十六进制表示组成。

 

　　2、object 类的getclass()方法返回一个对象的类名。

 

四、equals、hashcode

　　1、object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参obj所引用的对象是否是同一对象（即是否占据同一个内存）。对于内容相同但内存不同的对象，返回false。需要进行重写，并重写比较规则，才能使其为true。

 

　　2、object的hashcode()方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashcode方法。

　　3、equals与hashcode的区别，可以看看这个：