JAVASE 小白学习笔记 （12-1）Java中的常用类--object类

我们知道Java一门面向对象语言，我们在学习中如果对某些类不了解，我们可以通过API进行查询。所谓API指的是应用程序编程接口。Java ApI:就是Java提供给我们使用的类，这些类将底层的实现封装起来。

---

1.object类

object类：类层次结构的根类，所有的类都直接或间接继承自该类
object类中有一些常用的方法，下表对常用的方法进行总结。

object类中的常用方法	方法的作用
hashCode()方法	返回对象的哈希码值。默认情况下，该方法会根据对象的地址值进行计算
getClass()方法	返回该类的字节码文件对象
toString()方法	返回对象的字符串的表示（获得对象的地址值，并以字符串的形式进行返回）
equals()方法	默认比较的是两个对象的地址值是否相等。equals()可以进行重写，如果重写，最后比较的是重写后的内容
clone()方法	创建并返回对象的一个副本

---

1.1 hashCode()方法

hashCode()方法：返回对象的哈希码值。默认情况下，该方法会根据对象的地址值进行计算。

public class Demo1 {
    
    
   public static void main(String[] args) {
    
    
       //object类是所有类的顶层父类，所有类都直接或间接继承自它
       Object obj = new Object();
       System.out.println(obj);//打印对象的地址值
       /*hashCode()方法返回对象的哈希码值，默认情况下
       该方法会根据对象的地址值来进行计算
        */
       int i = obj.hashCode();
       System.out.println(i);

       /*不同对象的hashCode()返回的值一般是不相等
         但是同一对象的hashCode()返回的值肯定相等
        */
       Object obj1 = new Object();
       System.out.println(obj1);
       int i1 = obj1.hashCode();
       System.out.println(i1);
   }
}

---

1.2 getClass()方法

getClass()方法 : 返回该类的字节码文件对象。

public class Demo2 {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        System.out.println(obj);
        /*getClass()方法，返回该类的字节码文件对象。
        Object.java-编译->Object.class-->加载进内存
        -->JVM会为object.class创建对象-->通过getClass()方法
        获取字节码文件对象
        注意：Class类型，用来表示字节码文件类型
         */
        Class<?> aClass = obj.getClass();
        Object obj2 = new Object();
        Class<?> aClass1 = obj2.getClass();
        //每new一次为一个新对象，地址值不同
        System.out.println(obj == obj2);//false 
        //注意：字节码文件只有一份
        System.out.println(aClass == aClass1);//true
    }
}

---

1.3 toString()方法

toString()方法 : 返回该对象的字符串表示。（获取该对象的地址值，以字符串的形式进行返回）

public class Demo3 {
    
    
    public static void main(String[] args) {
    
    
        Object obj = new Object();
        //toString()方法：获取该对象的地址值，并以字符串的形式返回
        String s = obj.toString();
        System.out.println(s);
        //当打印对象名时，默认这个对象就在调用toString()方法
        System.out.println(obj);
    }
}

注意：toString()方法可以进行重写，当子类重写object类中的toString()方法后，以子类重写后的内容进行显示

public class Demo4 {
    
    
    public static void main(String[] args) {
    
    
        Person person = new Person();
        person.setName("小明");
        person.setAge(25);
        String s = person.toString();
        //显示的为子类重写后的toString()方法
        System.out.println(s);

    }
}

class Person extends Object{
    
    
    private String name;
    private int 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 "姓名:"+this.name+"--年龄："+this.age;
    }
}

总结：

• 当打印对象名时，显示有两种可能，一种可能是打印地址值，另外一种可能是打印其他。当打印输出一个对象名时，如果输出的不是地址值，说明此类重写过toString()方法。

---

1.4 equals()方法

equals()方法默认比较的是两个对象的地址值是否相等。equals()可以进行重写，如果重写，最后比较的是重写后的内容。
一般情况下，子类认为比较两个对象的地址值是否相同意义不大，子类想要比较一些它认为有意义的东西。比如，自定义的类通常比较两个对象的成员变量值相同，就认为两个对象相同。

import java.util.Objects;
public class MyTest {
    
    
    public static void main(String[] args) {
    
    
        Person p1 = new Person("陈奕迅", 35);
        Person p2 = new Person("陈奕迅", 35);
        //比较两个对象的地址值
        System.out.println(p1 == p2);//false
        /*利用equals()方法进行比较两个对象,子类重写了
        toString()方法，重写的内容为成员变量，所以比较
        成员变量的字面值是否相等
         */

        boolean b = p1.equals(p2);
        System.out.println(b);//true
    }
}

class  Person{
    
    
    private String name;
    private int age;
    public Person() {
    
    
    }
    public Person(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;
    }
    //重写父类的equals方法

    @Override
    public boolean equals(Object o) {
    
    
        //判断两个对象是否为同一对象
        if (this == o) {
    
    
            return true;
        }
        //判断传入对象是否为空或者两个对象是否为同一类型
        if (o == null || getClass() != o.getClass()) {
    
    
            return false;
        }
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

}

==与equals（）方法的区别
==是比较运算符，可以比较基本数据类型，也可以比较引用数据类型。作为比较基本数据类型时，比较的是两个值是否相等；作为比较引用数据类型时，比较的是两个对象的地址值是否相等。
equals（）方法是object类中的一个方法，默认比较的是两个对象的地址值是否相等。但有些类，会重写object类中的equals()方法，比较它认为有意义的东西。比如String类它重写父类的equals()方法，比较的是两个字符串字面上的内容是否相同。如果是我们常用自定义的类型，一般会重写object类中的equals()方法，去比较两个对象的成员变量值是否一致。

---

1.5 clone()方法

clone()方法：创建并返回此对象的一个副本。

利用clone()方法克隆一个对象时注意事项
1.object类中的这个clone()方法，是个受保护的方法，为了能够调用到，我们可以使这个类重写clone()方法，把权限修饰符改为public,重写逻辑是继续调用父类的clone()方法
2.为了克隆能被支持，还需要该类实现Cloneable这个标记接口
3.克隆不会调用构造方法

public class MyTest {
    
    
    public static void main(String[] args) throws CloneNotSupportedException {
    
    
        Person p = new Person("张学友", 35);
        //此处会出现编译期异常，按下Alt+Enter键抛出异常
        System.out.println(p);
        Object obj = p.clone();
        Person p1= (Person) obj;
        System.out.println(p1);

    }
}
/*
   1.object类的clone()方法执行特定的复制操作。首先，如果此对象的类
   不能实现Cloneable接口，则会CloneNotSupportedException
   2.Cloneable标记接口，接口中没有任何方法，就是给类打了一个标记，
   告诉jvm可能要实现某种操作，让Jvm支持这种操作
 */
class Person implements Cloneable {
    
    
    private String name;
    private int age;
    public Person() {
    
    
    }
    public Person(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;
    }
//重写父类中的toString方法
    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

• 对象的浅克隆
• 调用clone()方法属于浅克隆
• 对象的浅克隆：就是克隆一个对象时，如果被克隆的对象维护着另外一个类的对象，这个时候只是克隆下另外一个对象的地址，而没有把另外一个对象也给克隆一份。

public class MyTest {
    
    
    public static void main(String[] args) throws CloneNotSupportedException {
    
    
        Food food = new Food("油泼面");
        Person p = new Person("小明", 25, food);
        p.foodname.foodname="鱼香肉丝";
        Object obj = p.clone();
        //向下转型
        Person p1= (Person) obj;
        p1.name="小花";
        p1.foodname.foodname="回锅肉";

        System.out.println(p.name);//小明
        System.out.println(p.age);//25
        System.out.println(p.foodname.foodname);//回锅肉

        System.out.println("----------------");
        System.out.println(p1.name);//小花
        System.out.println(p1.age);//25
        System.out.println(p1.foodname.foodname);//回锅肉


    }
}


class Person implements  Cloneable{
    
    
    String name;
    int age;
    Food foodname;
    public Person() {
    
    
    }
    public Person(String name, int age, Food foodname) {
    
    
        this.name = name;
        this.age = age;
        this.foodname = foodname;
    }

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


class Food{
    
    
    String foodname;
    public Food() {
    
    
    }
    public Food(String foodname) {
    
    
        this.foodname = foodname;
    }
}