Java基础 Object父类中有哪些方法，面试常问........

Object java.lang.Object

Arrays数组操作工具类 java.util.Arrays

Object类中clone方法概述

protected native Object clone() throws CloneNotSupportedException;

如果一个类要使用克隆的方法，那么就要实现Cloneable接口。克隆方法默认是浅复制，即复制对象内的基本数据类型的变量为其复制的内容，但是引用类型的数据原对象和复制的对象共享；要想实现对象深度复制，那么每一个引用类型的对应的类都要实现Cloneable接口，并且要重写clone方法，在被引用的类中也要使用clone方法进行复制，保证复制的类的对象和原对象的引用数据类型的属性的指针也指向不同的对象。实际开发中很少使用，但是学习的时候要系统的学习，能使我们更好的理解对象的引用、数据类型、和Object类的使用。

package com.ybjt.bean;

/**
 * 如果类的构造器或者静态方法工厂中有多个参数（四个参数以上），使用Builder
 * 构建者设计模式
 * 避免创建不必要的对象
 * @author zxh
 * @create 2019-10-08 13:43
 */
public class Car implements Cloneable{
    private String name;
    private String old;
    private String num;

    public static class Bulider{
        private String name = "奥迪";
        private String old;
        private String num;

        public Bulider setOld(String old){
            this.old = old;
            return this;
        }

        public Bulider setNum(String num){
            this.num = num;
            return this;
        }

        public Car build(){
            return new Car(this);
        }
    }

    private Car(Bulider bulider){
        this.name = bulider.name;
        this.old = bulider.old;
        this.num = bulider.num;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", old='" + old + '\'' +
                ", num='" + num + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.ybjt.bean;

import java.io.Serializable;

/**
 * @author zxh
 * @create 2019-07-24 15:50
 * 实体类，类的设计
 * 成员变量即类的属性
 * 局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内的变量
 */
public class User implements Serializable,Cloneable {
    private static final long serialVersionUID = -5555401105921349900L;
    private String name;
    private String age;
    private String address;

    private Car myCar;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    /**
     * 带参的构造器
     * @param name 名字
     * @param age 年龄
     * @param address 地址
     */
    public User(String age, String address) {
        //this.name = name;
        this("bob");
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "com.ybjt.bean.User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public void song(){
        System.out.println(name+"跪着唱征服！");
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        User clone = (User)super.clone();
        clone.myCar = (Car) myCar.clone();
        return clone;
    }
}

Object类详解

package java.lang;
//Object是所有类的基类，当你没有显示extends一个父类时，编译期会自动为你加上一个Object类。
public class Object {

    /**
     * 一个本地方法,具体是用C(C++)在DLL中实现的,然后通过JNI调用
     */
    private static native void registerNatives();

    /**
     * 对象初始化时自动调用此方法
     */
    static {
        registerNatives();
    }

    /**
     * 返回此Object的运行时类
     */
    public final native Class<?> getClass();

    /**
     * hashCode的常规协定是：
     * 1.在java应用程序执行期间,在对同一对象多次调用hashCode()方法时,必须一致地返回相同的整数,前提是将对象进行equals比较时所用的信息没有被修改。
     * 从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。
     * 2.如果根据equals(object)方法,两个对象是相等的,那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的整数结果。
     * 3.如果根据equals(java.lang.Object)方法,两个对象不相等,那么对这两个对象中的任一对象上调用hashCode()方法不要求一定生成不同的整数结果。
     * 但是,程序员应该意识到,为不相等的对象生成不同整数结果可以提高哈希表的性能。
     */
    public native int hashCode();

    /**
     * 这里比较的是对象的内存地址
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 本地clone方法,用于对象的复制
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * 返回该对象的字符串表示,非常重要的方法
     * getClass().getName();获取字节码文件的对应全路径名例如java.lang.Object
     * Integer.toHexString(hashCode());将哈希值转成16进制数格式的字符串。
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * 不能被重写，用于唤醒一个在因等待该对象（调用了wait方法）被处于等待状态（waiting 或 time_wait）的线程，该方法只能同步方法或同步块中调用
     */
    public final native void notify();

    /**
     * 不能被重写，用于唤醒所有在因等待该对象（调用wait方法）被处于等待状态（waiting或time_waiting）的线程，该方法只能同步方法或同步块中调用
     */
    public final native void notifyAll();

    /**
     * 不能被重写，用于在线程调用中，导致当前线程进入等待状态（time_waiting)，timeout单位为毫秒,该方法只能同步方法或同步块中调用,超过设置时间后线程重新进入可运行状态
     */
    public final native void wait(long timeout) throws InterruptedException;


    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()方法或notifyAll()方法前,导致当前线程等待。换句话说,此方法的行为就好像它仅执行wait(0)调用一样。
     * 当前线程必须拥有此对象监视器。
     * 该线程发布对此监视器的所有权并等待,直到其他线程通过调用notify方法或notifyAll方法通知在此对象的监视器上等待的线程醒来,
     * 然后该线程将等到重新获得对监视器的所有权后才能继续执行。
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * 这个方法用于当对象被回收时调用，这个由JVM支持，Object的finalize方法默认是什么都没有做，如果子类需要在对象被回收时执行一些逻辑处理，则可以重写finalize方法。
     */
    protected void finalize() throws Throwable {
    }
}

判断对象是否相同

每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equal()，如果equal()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！