常用类--Object类

Object类

程序示例

/*
        Object:Class Object是类Object结构的根。
                 每个班(class)都有Object作为超类。
                 所有对象(包括数组)都实现了这个类的方法。
                 每个类都直接或者间接的继承Object类

        Object类中的方法：
                 public int hashCode()返回对象的哈希码值。
                 支持这种方法是为了散列表，如HashMap提供的那样。
           注意：这里的哈希码值是根据哈希算法计算出来的一个值，这个值和地址有关系，但是并不是实际
                 的地址值。简单理解为地址值的另一种表现形式


                 public final 类 getClass()返回此Object的运行时类。
                 返回的类对象是被表示类的static synchronized方法锁定的对象。
                 
                 public String getName()返回由类对象表示的实体的名称
                (类，接口，数组类，原始类型或void)，作为String 。
*/

public class Student2 extends Object{

}

public class StudentTest {
    public static void main(String[] args) {
      //创建Student2对象
        Student2 s = new Student2();
      //调用继承父类Object的hashCode()方法
        System.out.println(s.hashCode()); //输出：1163157884
      //了解了哈希算法是地址值的另一种表现形式，那我再创建一个对象
      //那么s1与s之间的哈希值是不是应该不一样
      //答案是不一定，因为它空间就那么大，你取模有可能发生不同的数值取模的结果是一样的。
        Student s1 = new Student();
        System.out.println(s1.hashCode()); //输出：1956725890
      
      //将s的地址值赋值给s2
        Student s2 = s;
        System.out.println(s2.hashCode()); //输出：1163157884

        System.out.println("*************************");
      
      //创建s3对象调用继承父类Object的getClass()方法
        Student s3 = new Student();
      //返回此Object的运行时类。
        System.out.println(s3.getClass()); //输出：class com.shujia.wyh.day18.Student

        Class c = s3.getClass();
        //public String getName()
        // 返回由类对象表示的实体的名称(类，接口，数组类，原始类型或void)，作为String 。
        System.out.println(c.getName()); //输出：com.shujia.wyh.day18.Student

        System.out.println("****************************");
        //链式编程
        System.out.println(s3.getClass().getName());
    }
}

哈希算法图解：

/*
        public String toString()返回对象的字符串表示形式。
        一般来说， toString方法返回一个“textually代表”这个对象的字符串。
        结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。
        该toString类方法Object返回一个由其中的对象是一个实例，
        该符号字符`的类的名称的字符串@ ”和对象的哈希码的无符号的十六进制表示。
        换句话说，这个方法返回一个等于下列值的字符串：
                getClass().getName() + '@' + Integer.toHexString(hashCode())
                //Integer.toHexString(hashCode())：将hashCode()值反过来转成具体的地址值
                
        Integer类中有一个toHexString方法将哈希值转换成地址值
            public static String toHexString(int i)
            返回整数参数的字符串表示形式，作为16位中的无符号整数。


        我们虽然掌握了toString()的方法使用，但是呢打印的结果是一个地址值，我们拿到地址值是没有意义的

        我们正常打印一个对象，其实是想看该对象中的成员变量的值。
        又因为toString()方法的返回值是String类型，并且属于Object类中的
        而Object类是所有类的父类，那么我们自己定义类的时候，就可以重写该方法，重写里面的实现。
        将来调用toString()方法的时候，严格遵循编译看左，运行看右，所以调用的是重写后的方法。

        类最终写法：4.0版本：
            成员变量:private
            构造方法:无参，有参
            成员方法：getXxx()和setXxx(),..
            toString()：自动生成即可
*/

public class Student3 {
    private String name;
    private int age;

    public Student3() {
    }

    public Student3(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;
    }

  //自己重写的父类Object的toString()方法
//    @Override
//    public String toString() {
//        return  "姓名：" + name + ",年龄：" + age;
//    }

//自动生成的重写父类Object的toString()方法
    @Override
    public String toString() {
        return "Student3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class StudentTest2 {
    public static void main(String[] args) {
        Student3 s = new Student3();
      //调用继承自父类Object的toString()方法
      //返回对象的字符串表示形式。
        System.out.println(s.toString());//输出：com.shujia.wyh.day18.Student3@4554617c
      
        System.out.println("*************************");
        System.out.println(s.getClass().getName());
        System.out.println("*****************************");
      
        //toString()方法等价于以下内容
        //getClass().getName() + '@' + Integer.toHexString(hashCode())
        //s.getClass().getName() + "@" + Integer.toHexString(s.hashCode())
        //this.getClass().getName() + "@" + Integer.toHexString(this.hashCode())
        System.out.println(s.toString());
        System.out.println(s.getClass().getName()+"@"+Integer.toHexString(s.hashCode()));

        s.setName("小花");
        s.setAge(18);
      //这样重写后的toString()方法就代替了之前的show()方法
        System.out.println(s.toString());
    }
}

/*
        public boolean equals(Object obj)指示一些其他对象是否等于此。
        
        今后想要弄明白一个类中的方法是如何实现的时候，API也没告诉我们怎么办呢？
        
        看源码。将鼠标光标放在方法名上  ctrl+鼠标左键
        
        通过观察源码发现：Object类中的equals方法实现底层依旧是 ==
            public boolean equals(Object obj) {
                return (this == obj);
            }
        而==比较引用数据类型比较的是地址值，当地址值不一样的时候返回的是false

        ==:
          基本类型：比较的是值是否相同
          引用类型：比较的地址值是否相同

       equals:(为什么equals不能比较基本数据类型？因为调用equals方法的是一个对象，本身就不是基本数据类型了)
            引用数据类型：            
                不需要我们自己重写，自动生成即可
                重写之前，默认调用的是Object类中的equals方法，默认比较的是地址值
                重写之后，比较的是对象成员变量值
*/

import java.util.Objects;

public class Student4 {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(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 "Student3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
  
 //重写的equals()方法
    @Override
    public boolean equals(Object o) { //s3.equals(s4)
        //this -- s3
        //o -- s4
      
      //先判断两者地址值是否相同
        if (this == o) return true;
      //在判断这个对象是不是null || 这两个对象的class文件是不是一样的
        if (o == null || getClass() != o.getClass()) return false;
      //然后o向下转型获取age和name，再去判断
        Student4 student4 = (Student4) o;
        return age == student4.age &&
                Objects.equals(name, student4.name);
    }
}


public class StudentTest3 {
    public static void main(String[] args) {
        Student4 s1 = new Student4("阿伟", 18);
        Student4 s2 = new Student4("阿伟", 18);
     //    new了两次
        System.out.println(s1==s2);//结果为false
      //将s1的地址值赋给了s3
        Student4 s3 = s1;
        System.out.println(s1==s3);//结果为true
      
        System.out.println("***************************");

        System.out.println(s1.equals(s2)); //false    equals()方法重写之后//结果为：true
        System.out.println(s1.equals(s3)); //true
        System.out.println(s1.equals(s1)); //true

        //但是，我们两个对象的成员变量值都一样，从现实生活角度出发，我们应该创建的是同一个学生
       // 所以我们想要重写继承自父类Object的equals()方法，让重写之后，比较的是对象成员变量值
        Student4 s4 = new Student4("小朱", 18);
        System.out.println(s3.equals(s4)); //输出结果：false
    }
}

/*
    protected void finalize()
                 throws Throwable当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
                 一个子类覆盖了处理系统资源或执行其他清理的finalize方法。
                 这个方法简单理解为就是用来垃圾回收的，什么时候回收呢？
                 不确定。这里涉及到了GC机制

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

    clone的方法Object执行特定的克隆操作。
    首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。
    将想要调用克隆方法的类实现Cloneable接口
    通过观察API发现，Cloneable接口中没有成员变量也没有成员方法
    今后看到类似于Cloneable接口里面什么都没有的接口，我们称之为标记接口

    拷贝在IT行业中常见两种：
        浅拷贝
            拷贝的时候，重新创建一个对象，成员变量值和被拷贝的一样，但是后续修改与原先的没有关系
        深拷贝
            拷贝的时候，没有创建新的对象，只是改个名字，地址值都一样，修改拷贝后的连带影响到原先的
*/

import java.util.Objects;

public class Student5 implements Cloneable{//加上了实现克隆的接口
    private String name;
    private int age;

    public Student5() {
    }

    public Student5(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 "Student3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

  //重写了继承自父类Object的clone()方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class StudentTest4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student5 s1 = new Student5("华根", 18);
      
        System.out.println(s1.toString());

        //CloneNotSupportedException//克隆不支持异常
       //当想要被克隆的类加上了实现克隆的接口，就可以被克隆
        //这里其实隐含了多态
      //Student5对象s1，克隆出来的还是Student5的对象
      //所以父类的引用指向子类的对象
        Object obj = s1.clone();

        System.out.println(obj.toString());//克隆过后发现 s1.toString() 和 obj.toString()输出结果一样
      
      //那我克隆有什么意义呢？现在我直接将s1赋给s2
        Student5 s2 = s1;
        System.out.println(s2.toString());//输出结果和 s1.toString() 一样
      //这样 s1.toString() 和 s2.toString()输出结果不还是一样的吗？

        System.out.println("**************************");
      //现在我将s2的年龄改为20岁
        s2.setAge(20);

        System.out.println(s1.toString());//我们发现当我们改了s2之后s1也跟着变了
        System.out.println(s2.toString());//s1与s2这样的拷贝方式是深拷贝
        System.out.println(obj.toString());//但是克隆出来的没有影响，所以克隆是浅拷贝
    }
}