object类的概述以及方法

object类

概述

• API(Application Programming Interface)
  应用程序编程接口
• Java API 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
• 类层次结构的根类，所有类都直接或者间接的继承自该类
• 构造方法public Object()，子类的构造方法默认访问的是父类的无参构造方法

hashCode（）方法

方法概述

• 返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
• 不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
• 不是对象的实际地址值，可以理解为逻辑地址值。

代码演示

public class MyTest extends Object{
    public static void main(String[] args) {
        //Object 是我们所有类的顶层父类，所有类都是直接或间接继承自他
        //创建Object类的对象
        Object obj = new Object();
        //Object类中常用的方法
        //hashCode() 返回一个对象的哈希码值
        int code = obj.hashCode(); //把对象的地址值换算成一个整数值
        System.out.println(code);
        Object obj2 = new Object();
        int i = obj2.hashCode();
        System.out.println(i);
        //不同的对象的哈希码值不一样
    }
}

equals（）方法

方法概述

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

代码演示

public class MyTest2 {
    public static void main(String[] args) {
        //  boolean equals (Object obj) 比较两个对象的地址值是否相等
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1==obj2);
        boolean equals = obj1.equals(obj2);
        System.out.println(equals);

        //public boolean equals (Object obj){
        //    return (this == obj);
        //}
    }
}

equals（）方法代码优化

优点

提高效率提高健壮性(instanceof)

代码演示

ublic class MyTest {
    public static void main(String[] args) {
        //Student student = new Student();
        //Student student1 = new Student();
        //System.out.println(student==student1);
        我们认为equals方法的默认实现，去比较两个对象的地址值是否相同，这个比较方式，我们认为不够好
        我们想要按照自己的比较方式，去比较
        //
        //student.equals(student1);

        System.out.println("-----------------------");
//我们想要按照自己的比较方式，去比较 我认为只要两个对象的成员变量值一样，我就认为两个对象一样
        Student student3 = new Student("张三", 23);
        Student student4 = new Student("张三", 23);


        System.out.println(student3.equals(student4));
    }
}

class Dog {
}
-----------------
public class Student {
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name=name;
        this.age=age;
    }

    @Override
    public boolean equals(Object obj) {
        //instanceof 可以判断一个引用或者对象，是不是该类型的一个引用
        //我认为，两个对象的成员变量一摸一样，我就认为两个对象一样
        //向下转型
        //优化比较效率
        if(this==obj){
            return true;
        }


        if(!(obj instanceof Student)){
            return false;
        }
        Student stu= (Student) obj;
        //"张三"=="张三" 有肯能 false  String 类认为父类Object中的 equals默认比较方式意义不大，String类 他重写了equals方法，去比较两个字符串字面内容是否相同
        return this.name.equals(stu.name)&&this.age==stu.age;

    }
}

getClass（）方法

概述

• 返回此 Object 的运行时类
• 可以通过Class类中的一个方法，获取对象的真实类的全名称

代码演示

public class MyTest {
    public static void main(String[] args) {
      //  Class<?> getClass () 按Java万物皆对象的思想，那么他会把 .class 文件看做一个对象

        //Student.class 加载进内存后，JVM 就会为 Student.class文件创建一个对象
        //我们可以把这个对象获取出来用，怎么获取，getClass（）这个方法可以获取
        Student student1 = new Student("张三",23);
        Student student2 = new Student("张三", 23);
        Class aClass = student1.getClass(); //Student.class--->对象
        Class aClass1 = student2.getClass();
        System.out.println(student1==student2);//false

        System.out.println(aClass==aClass1);//true

        System.out.println("-----------------------------------------");
        System.out.println(student1.equals(student1));//false
    }
}

to String()方法

概述

• 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
• 怎么重写, 一般是将该类的所有的成员变量组成返回即可

代码演示

public class MyTest {
    public static void main(String[] args) {
        //String toString ()
        //返回该对象的字符串表示。
        Object obj= new Object();
        String s = obj.toString();
        System.out.println(s);

        Student student = new Student();
        System.out.println(student.toString());


        //public String toString () {
        //    return getClass().getName() + "@" + Integer.toHexString(this.hashCode());
        //}
        //

        System.out.println("------------------------");
        Student student1 = new Student("张三", 24);
        String s1 = student1.toString();
        System.out.println(s1);
       // System.out.println(student1.getName()+"==="+student1.getAge());

        Scanner scanner = new Scanner(System.in);
        System.out.println(scanner.toString());

        //如果我们以后直接打印一个对象名的时候，如果输出的不是地址值，说明该类重写了Object类中的toString()方法
    }
}


class Student{
    private String name;
    private int age;

    public Student() {
    }

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

    //@Override
    //public String toString() {
    //    return "[姓名"+this.name+",年龄"+this.age+"]";
    //}
}

clone（）方法

概述

• clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
• 使用clone()方法采用的是浅克隆的方式
• 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
• Cloneable接口只不过是一个标识接口而已，没有任何方法
• 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份。
• 对象的浅克隆也不会调用到构造方法的。

浅克隆

代码演示

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
      //  protected Object clone () 创建并返回此对象的一个副本。
        Dog dog = new Dog();
        Object clone = dog.clone(); //克隆对象时不会执行构造方法

        Dog dog1= (Dog) clone;
        dog1.eat();
    }
}


//Cloneable 里面没有任何抽象方法，这种接口，我们称之为标记即可，作用就是让JVM知道，我要克隆
class Dog implements Cloneable{
    public Dog() {
        System.out.println("构造方法执行了");
    }

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

    public void eat(){
        System.out.println("狗吃肉");
    }
}

浅克隆2

代码演示

public class MyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        //Dog dog = new Dog();
        //dog.name="旺财";
        //dog.age=3;
        //Dog dog1= (Dog) dog.clone();
        //dog1.name="赛虎";
        //dog1.age=4;
        //System.out.println(dog.name+"==="+dog.age);
        //System.out.println(dog1.name + "===" + dog1.age);
        DogFood dogFood = new DogFood("王中王");
        Dog dog1 = new Dog("旺财", 2, dogFood);
        dog1.food.name="双汇";
        Dog dog2 = (Dog) dog1.clone();
        dog2.name="赛虎";
        dog2.age=34;
        dog2.food.name="金锣";
        System.out.println(dog1.name + "==" + dog1.age + "===" + dog1.food.name);//金锣
        System.out.println(dog2.name + "==" + dog2.age + "===" + dog2.food.name);//金锣

    }
}


class Dog implements Cloneable{
    String name;
    int age;
    DogFood food;

    public Dog() {
    }

    public Dog(String name, int age, DogFood food) {
        this.name = name;
        this.age = age;
        this.food = food;
    }

    public void show(){
        System.out.println(name+"==="+age);
    }

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

class DogFood{
    String name;

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

    @Override
    public String toString() {
        return "DogFood{" +
                "name='" + name + '\'' +
                '}';
    }
}