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;
    }
}

你可能感兴趣的:(JAVASE,java)