Object类及常用方法(hashCode()、getClass()、toString()、equals()、clone() )

Object类及常用方法

一、概述

  • Java API

    Java提供给我们使用的类,这些类将底层的实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用

  • Object类

    类层次结构的根类,所有类都直接或间接的继承自该类

  • Object类构造方法

    public Object(),子类的构造方法默认访问父类的无参构造

二、Object类的hashCode()方法

​ public int hashCode()

  1. 返回该对象的哈希码值,默认情况下,该方法会根据对象的地址来计算
  2. 不同对象的,hashCode()一般来说不会相同。但同一个对象的hashCode()值肯定相同
  3. 哈希码值不是对象的实际地址,相当于一个逻辑地址值
  • 案例

        public static void main(String[] args) {
            int i = new Object().hashCode();
            int i1 = new Object().hashCode();
            System.out.println(i);
            System.out.println(i1);
        }
        //输出:
        356573597
    	1735600054
    

三、Object类的getClass()方法

​ public final Class getClass()

​ 返回该类的字节码文件对象

  • 案例

        public static void main(String[] args) {
            Object o = new Object();
            Object o1 = new Object();
            Class aClass = o.getClass(); //字节码文件对象
            Class aClass1 = o1.getClass();
            String name = aClass.getName();
            String name1 = aClass1.getName();
            System.out.println(name);
            System.out.println(name1);
        }
        //输出:
        java.lang.Object
    	java.lang.Object
    

四、Object类的toString()方法

​ public String toString()

​ 返回该对象的地址值的字符串表现形式,一般重写,输出一个对象则默认在对象名后有隐式的.toString()

  • 源码

    public String toString() {
       	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    
  • 案例1

    public static void main(String[] args) {
            Object obj = new Object();
            String s = obj.toString(); //获取该对象的地址值的字符串表现形式
            System.out.println(s);
            Object o = new Object();
            System.out.println(o.toString());
        }
        //输出:
        java.lang.Object@1540e19d
    	java.lang.Object@677327b6
    
    
  • 案例2

    public class MyTest {
        public static void main(String[] args) {
            Teacher teacher = new Teacher("张三", 23);
            System.out.println(teacher);
    
        }
    }
    
    class Teacher{
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            this.name = name;
            this.age = age;
        }
    //重写toSring方法
        @Override
        public String toString() {
            return "Teacher{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

    //输出:Teacher{name=‘张三’, age=23}

五、Object类的equals()方法

​ public boolean equals(Object obj)

  • 指示其他某个对象是否与此对象“相等”,默认情况下比较的是对象的引用是否相同,由于比较对象的引用没有意义,一般建议重写该方法。一般用于比较成员变量的值是否相等

  • 源码

    public boolean equals(Object obj) {
        return (this == obj);
    }
    
  • 案例

    public class MyTest {
        public static void main(String[] args) {
            Object obj = new Object();
            Object obj2 = new Object();
            // boolean equals (Object obj) 判断两个对象的地址值是否相同
            System.out.println(obj == obj2); //false
            boolean b = obj.equals(obj2); 
            System.out.println(b); //b=true
            Student s1 = new Student("张三", 23);
            Student s2 = new Student("张三", 23);
            System.out.println(s1 == s2);//false
            //System.out.println(s1.equals(s2)); //true
            //s1.equals(s2) 比较两个对象的地址值,是否相同,对我来说意义不大,我认为的是,只要两个对象的成员变量的值一样,我就认为这两个对象一样。那么我就得重写父类的equals()方法,让他去比较两个对象的成员变量的值是否相同
    
            boolean b1 = s1.equals(new Teacher());//ClassCastException 类型转换异常
            System.out.println(b1);//false
            boolean b2 = s1.equals(s1);
            System.out.println(b2);//true
        }
    }
    
    class Student {
        private String name;
        private int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public boolean equals(Object obj) {
            //如果是自己跟自己比,直接就是true
            if (this == obj) {
                return true;
            }
    
            // 让他去比较两个对象的成员变量的值是否相同
            if (!(obj instanceof Student)) {
                return false;
            }
            //向下转型
            Student stu = (Student) obj;
            return this.name.equals(stu.name) && this.age == stu.age;
        }
    }
    
    class Teacher {
    
    }
    
  • equals()方法重写优化

        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
    
    

六、Object类的clone() 方法(浅克隆)

​ protected Object clone () 创建并返回此对象的一个副本

  • 案例

    public class MyTest {
        public static void main(String[] args) throws CloneNotSupportedException {
          //  protected Object clone () 创建并返回此对象的一个副本。
            Dog dog = new Dog();
            System.out.println(dog);
            dog.name="小黑";
            dog.age=10;
            System.out.println(dog.name);//小黑
            System.out.println(dog.age);//10
    
            Dog dog1= (Dog) dog.clone();//需强制转型
            System.out.println(dog1);
            System.out.println(dog1.name);//小黑
            System.out.println(dog1.age); //10
            //CloneNotSupportedException 克隆不支持异常
    
            Dog dog2 = new Dog();
            Dog dog3 = (Dog) dog2.clone();
            System.out.println(dog3.name);//小白
            System.out.println(dog3.age);//23
    
    
        }
    }
    //此类实现了 Cloneable 接口,以指示 Object.clone()方法可以合法地对该类实例进行按字段复制。
    //如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法,则会导致抛出CloneNotSupportedException 异常。
    //Cloneable 没有任何抽象方法的接口,是一个标记接口
    class Dog extends Object implements Cloneable{
        String name="小白";
        int age=23;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            //调用父类的clone功能
            return super.clone();
        }
    }
    
  • 注意

    1. 如果一个对象需要调用clone的方法克隆,那么该对象所属的类必须要实现Cloneable接口
    2. Cloneable接口只不过是一个标识接口而已,没有任何方法
    3. 对象的浅克隆就是克隆一个对象的时候,如果被克隆的对象中维护了另外一个类的对象,这时候只是克隆另外一个对象的地址,而没有把另外一个对象也克隆一份
    4. 对象的浅克隆也不会调用到构造方法的

你可能感兴趣的:(Java基础)