Object类

1、意义

• Class Object is the root of the class hierarchy.

• Every class has Object as a superclass.

• All objects, including arrays, implement the methods of this class.

## 2、主要方法

 package object;
 ?
 /**
  *  1、Object 类中定义的 toString() 方法用于获取对象的字符串的表示形式
  *  2、Object 类中定义了 hashCode() 方法用于获取对象的 哈希码 ( 或称作 哈希值 / 哈希码 )
  *  3、java.lang 包中的所有的类都可以不显式 import
  * */
 ?
 public class Hamster {
     public static void main(String[] args) {
         Object object = new Object();
         System.out.println(object); // 类型@哈希码
 ?
         String s = object.toString(); // 获取 object 所引用的对象的字符串表示形式
         System.out.println(s); // 类型@哈希码
 ?
         int code = object.hashCode();// 获取哈希码 （ 以 十进制形式返回 ）
         System.out.println(code);
         System.out.println(Integer.toHexString(code));
 ?
         Hamster hamster = new Hamster();
         System.out.println(hamster);
         System.out.println(hamster.toString());
         System.out.println(hamster.hashCode());
         System.out.println(Integer.toHexString(hamster.hashCode()));
 ?
     }
 }

• public String toString()

   Object 类中定义的 toString() 方法用于获取对象的字符串的表示形式

• public int hashCode()

   Object 类中定义了 hashCode() 方法用于获取对象的 哈希码 ( 或称作 哈希值 / 哈希码 )

• public final Class<?> getClass()

• public boolean equals( Object another )

• protected void finalize() throws Throwable

  • finalize 方法不是析构函数

  • finalize 方法从 JDK 9中已经被废弃

3、类类型

如果将一个类也当做一个对象，则该对象就是 java.lang.Class 类的实例

任意类型（ 原始类型、数组类型、引用类型 ）都可以通过 .class 来获取相对应类型的 Class 对象

• java.lang.Class 类中的 getName 可以获得 相对应的类型名称

  • 获取全限定名称

    • 对于基本类型来说就是 类型名称

    • 对于 数组 都是 [ 和 相对应类型的字母组成

    • 对于类 和 接口 就是 包名.类名

 package object;
 /**
  *  任意一个类型都可以通过 .class 来获取该类型对应的 Class 实例
  *  基本数据类型 和 数组 都可以 通过 .class 来获取其 相应的 Class 实例
  *  引用类型 也可以
  *  全限定名称 对于基本类型来说就是 类型名称 对于类 和 接口
  *  全限定名称
  *
  *  对于 基本数据类型 就是 类型名称
  *  对于 数组 都是 [ 和 相对应类型的字母组成
  *  对于类 和 接口 就是 包名.类名
  * */
 public class Smilodon {
     public static void main(String[] args) {
 ?
         Class ic = int.class;
         // 由 java.lang.Class 类定义的 getName() 方法可以 获取相应的类型的 全限定名称
         System.out.println(ic.getName());
 ?
         Class oc = Object.class;
         System.out.println(oc.getName());
 ?
         Class iac1 = byte[].class;
         System.out.println(iac1.getName());
 ?
         Class iac2 = boolean[][].class; // 为了 区别 byte 用了 Z
         System.out.println(iac2.getName());
 ?
         Class cc = Smilodon.class;
         System.out.println(cc.getName());
 ?
         Class interClass = java.util.List.class;
         System.out.println(interClass.getName());
 ?
     }
 }
 ?

• java.lang.Class 类中的 getSuperclass 可以获得 某个类的父类相对应的class 对象

4、重写（Override）

理解什么是重写(override) / 覆盖(override) 1、当子类中声明了 与 父类中 继承的 （可见的）方法 同名 同参 同返回值 的 方法时 就说子类中的 同名方法 重写（ 覆盖了 ） 父类的同名方法

当通过子类类型的对象 调用 该名称的方法时，会执行子类中声明的方法 不会调用 父类的方法了 2、同名、同参、同返回

重点：同名、同参、同返回值

 package object;
 ?
 /** 1、重写了 从 Object 继承时，可见的 toString 方法（ 同名同参同返回 ）
  *  2、当 重写一个方法时 为了让编译器能够提示相应的错误 可以加 @override
  *
  * */
 ?
 public class Loong {
     private String name;
     private int age;
     public Loong(String name,int age) {
         this.name = name;
         this.age = age;
     }
 ?
     @Override
     public String toString() {
         // System.out.println(this.name + " " + this.age);
         return this.name + " " + this.age;
     }
 ?
     public static void main(String[] args) {
         Loong loong = new Loong("敖丙",100);
         System.out.println(loong);
         System.out.println(loong.toString());
     }
 }
 ?

即使我们重写了 Object 的 hashCode 方法

我们可以通过

 System.out.println(System.identityHashCode(sheep));

来获取原来的哈希值

5、this 和 super 的区别

相同点：

1、都可以用来调用构造方法，但是调用的构造方法是不同的

如果用来调用构造方法的，必须是在构造方法内部且必须是首行代码

3、都可以来调用方法（ 但是调用的方法时不同的 ）

( this 和 super 都是与实例有关的，通常在 实例化 或 访问实例成员时使用， 而 static 修饰的 字段、代码块、方法 都是与类有关 )

区别：

1、在构造方法 通过 this([ 参数列表 ]) 可以调用本类中重载的其他构造方法，而子类中构造方法中 通过 super( [ 参数列表 ] ) 可以调用父类

2、使用 this.字段名称 形式 可以访问本类中 直接声明的字段，也可以访问从父类中继承的可见的字段，而 通过 super （ [ 参数列表 ] ）只能访问从父类中继承的 可见的 字段( 可以是直接父类继承，也可以是间接父类继承 )

3、使用 this.方法名称 形式 可以访问本类中 直接声明的字段，也可以访问从父类中继承的可见的字段，而 通过 super .方法名称（ [ 参数列表 ] ）只能访问从父类中继承的 可见的 方法( 可以是直接父类继承，也可以是间接父类继承 )

4、this 可以单独使用，他表示指向当前对象的一个指针，而 super 不可以

this 表示当前对象本身，因此可以看做是一个引用变量

super 必须通过 super( [ 实参列表 ] ) 形式 或 super. 形式来使用，super 本身不表示父类实例的引用 （ super 不表示父类实例的指针 ）

 package object;
 /**
  *  1、通过 this (实参列表)可以调用本类中的重载构造方法
  *  2、如果父类中存在多个相互重载的构造方法，则通过 super(实参列表) 可以调用父类的构造方法
  *
  * */
 ?
 public class MashiMaro { //流氓兔
 ?
     private String name;
     private int age;
 ?
     public MashiMaro() {
         super(); // 通过参数确定调用的是父类的无参构造
         System.out.println("MashiMaro()");
     }
     public MashiMaro(String name) {
         // super(); // 通过参数确定调用的是父类的无参构造
         this(); // 通过参数调用本类的构造中的无参数构造
         this.name = name;
         System.out.println("MashiMaro(String)");
     }
 ?
     public MashiMaro(String name,int age) {
         this(name); // 通过
         this.age = age;
         System.out.println("MashiMaro(String,int)");
     }
 ?
 ?
     public static void main(String[] args) {
         MashiMaro mashiMaro = new MashiMaro("流氓", 4);
         System.out.println(mashiMaro);
     }
 ?
 }
 ?

6、 == 和 equals 的区别

== 比较的是两个变量的值

• 对于基本数据类型存储的是数值，则两者比较的是数值是否相等

• 对于引用类型存储的是地址（ 指针 ），则比较的是 地址值

• 总之 == 比较的都是变量所存储的值是都相等

equals 方法比较的是对象的值，这里的值是指实例变量所存储的地址值

比较的是地址值

在 Object 中的 equals 方法的实现

 public boolean equals(Object o) {
     return this == o; // 本质上 仍然是在比较地址
 }

注：在 使用 == 比较两个变量的时候，需要注意 == 两侧的类型必须匹配

package object;

/** 1、凡是使用 == 比较两个变量，一定是比较两个变量中存储的值
 *     基本类型的变量中存储的是数值本身，引用类型的变量中存储的是地址
 *     所以 就有了
 *     == 运算符 对于基本类型比较值，对于引用比较的是 地址
 *  2、使用 == 运算符 比较两个变量时，需要注意 == 两侧的类型必须匹配
 *
 * */

public class Cobra {

    private String name;
    private int age;
    private int length; // 以 cm 为单位
    private int weight; // 以 g 为单位


    // 当显式书写了构造后 编译器不会默认添加 无参构造了
    public Cobra(String name,int age,int length,int weight) {
        this.name = name;
        this.age = age;
        this.length = length;
        this.weight = weight;
    }

    public static void main(String[] args) {

        int x = 100;
        int y = 100;
        System.out.println(x == y); // true 比较两个变量的值

        System.out.println("============");

        Cobra a = new Cobra("老大",18,125,2500);
        System.out.println(a);
        System.out.println(System.identityHashCode(a));

        Cobra b = new Cobra("老大",18,125,2500);
        System.out.println(b);
        System.out.println(System.identityHashCode(b));

        System.out.println(a == b);

        // System.out.println(x == b); // 【编译失败】

        Object o = new Object();
        System.out.println(o == b); // 引用类型的变量之间可以使用 == 进行比较

        int[] array = {1,3,5};

        int[][] array2 = new int[5][5];
        // System.out.println(array == b);
        // System.out.println(array == array2); // 失败

        System.out.println(o == array); // false 因为数组也继承了 Object 类

    }

}

7、instanceof关键字

instanceof 关键字：可以判断 某个对象 是否是 某种 类型

格式：

引用变量 instanceof 类型

结果：当引用变量 所指向的 对象 是 指定类型 instanceof 返回 true 否则 返回 false

package object;


/**
 *  1、在 Object 类中 equals 方法实现过程如下
 *
 *     public boolean equals(Object o) {
 *         return this == o; // 本质上 仍然是在比较地址
 *     }
 *  2、我们需要重写从 Object 类继承的 equals 来实现自己的方法
 *
 *  3、声明变量时所使用的类型决定了通过该变量可以访问 哪些 成员变量 和 成员方法
 *
 *  4、使用 instanceof 关键字 可以判断 某个对象 是否是 某种 类型
 *
 *    引用变量 instanceof 类型
 *
 *    当引用变量 所指向的 对象 是 指定类型 instanceof 返回 true 否则 返回 false
 *
 *  5、引用类型的 强制类型转换
 *   目标类型 变量名称 = (目标类型) 引用变量
 *  6、比较两个 基本类型的值 是否相等 可以使用 == 运算符
 *     比较两个对象 需要使用 equals 方法
 *  7、如果要比较两个 字符串 是否相等 ，应该使用 由 String 类重写的 equals 方法来实现
 * */

public class Horse {
    private String name;
    private int age;
    private int height;
    private int weight;

    public Horse(String name,int age,int height,int weight) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    @Override
    public boolean equals(Object o) {
        // 声明一个变量时所使用的类型 决定了通过该变量可以访问那些 成员变量 和 成员方法
        // if (this.height == o.height) // 编译失败 因为在 Object o 对象没有 height 变量
//        if (this.height == horse.height) {
//            return true;
//        }
//        else {
//            return false;
//        }

        if (o instanceof Horse) {
            Horse horse = (Horse) o; // 引用类型的 强制转换 地址还是一样的 类型变了
            // 比较基本数据类型 是否相等可以使用 == 但比较 两个对象是否相等 需要借助于 equals (String 也是引用类型 不能使用 ==)
            if (this.name.equals(horse.name) && this.age == horse.age && this.height == horse.height && this.weight == horse.weight ) {
                return true;
            }
        }
        return true;
    }


    public static void main(String[] args) {
        Horse a = new Horse("的卢",20,198,289000);
        Horse b = new Horse("的卢",20,198,289000);

        System.out.println(a == b); // 因为两个变量存在的值时不一样的


        System.out.println(a.equals(b)); // 借助于 从 Object 类 继承的、可见的 equals 方法 来实现比较连个对象是否相等


    }
}

Object 类

原文：https://www.cnblogs.com/zachyoung/p/12952770.html