java Object类基础理解

Object类

类Object 是类层次结构的根类，是所以类的超类，所以类直接或间接的继承自Object类

在任何情况下，都可以使用这个类构成多态

        //构造方法
            public Object() 
            //任何类在访问子类构造方法都会先访问父类无参构造方法
            //而Object是所以类的父类

1.常用方法

int hashCode() （重点掌握）

Class<?> getClass() （反射中详细讲解）

boolean equals(Object obj) （重点掌握）

String toString() （重点掌握）

protected Object clone() （了解）

protected void finalize() （了解）

1.1int hashCode

返回该对象的哈希码值，实际上，有Object 类定义的hashCode方法确实会针对不同的对象返回不同的整数

结论：hashCode 方法不能证明两对象是否相等，实现hashCoke方法是为了提高哈希表的性能

		hashCode = 对象的地址值 再经过转换得来的

注意

• hashCode值并不是真实地址

• 两个对象的哈希值相同，不能证明两对象是同一个对象

• 只有地址相同，才能确认两对象是同一个对象

          //判断两对象的地址值是否相同  
          //使用“ == ”
          //基本数据类型：  比较的是数值
          //引用数据类型：  比较的是地址
  
          //使用 equals
          //引用数据类型默认比较的是地址，但可以通过Object类重写equals方法
  
          public class ObjectDemo {
              public static void main(String[] args) {
                  Student s1 = new Student("Tom", 18);
                  Student s2 = new Student("John", 19);
                  Student s3 = s1;
                  int s1hashCode = s1.hashCode();
                  int s2hashCode = s2.hashCode();
                  int s3hashCode = s3.hashCode();
  
                  System.out.println(s1hashCode); // 2018699554
                  System.out.println(s2hashCode); // 1311053135
                  System.out.println(s3hashCode); // 2018699554
  
              }
          }
  

2.Class<?> getClass()

class是用来描述、定义一个类的，是一个概念，概念也是对象（万事万物皆对象）

Class代表的是类文件信息，无论创建多少个对象，他们都共享一个字节码文件（. class）对象

    //Java文件编译生成class文件 , class文件就是用Class类来表示
    //class文件中保存了一个类的所有信息 【构造方法 成员方法 成员变量...】
    //Class类中可以获取一个类文件中的所有信息

    public class ObjectDemo {
        public static void main(String[] args) {
            Student s1 = new Student("Tom", 20);
            Student s2 = new Student("John", 30);
            Student s3 = new Student("Tom", 20);
            Teacher t = new Teacher();
            System.out.println(s1 == s2); // false
            System.out.println(s1 == s3); // false
            System.out.println(s1.hashCode() == s3.hashCode()); // false
            Class c1 = s1.getClass();
            Class c2 = s2.getClass();
            Class c3 = s3.getClass();
            Class c4 = t.getClass();
            System.out.println(c1 == c2); // true
            System.out.println(c1 == c3); // true
            System.out.println(c1 == c4); // false

            String className = c1.getName();
            System.out.println(className); // com.objectdemo.Student
            System.out.println(s2.getClass().getName()); // com.objectdemo.Student
            System.out.println(t.getClass().getName()); // com.objectdemo.Teacher
            // 类路径: 包名.类名
        }
    }

3.String toString()

• Object 类的toString源码:

  public String toString() {
        return this.getClass().getName() + "@" +Integer.toHexString(this.hashCode());
   }
  		//类路径 + @ + hashCode的十六进制转换结果
  

  		Student s1 = new Student("Tom", 18);
  		Student s2 = new Student("John", 19);
  		Student s3 = null;
  		
  		String s1Str = s1.toString();
  		String s2Str = s2.toString();
  		// int hashCode = s1.hashCode();
  		// System.out.println("s1HashCode: " + hashCode); // 2018699554
  		
  		System.out.println(s1Str); // com.objectdemo.Student@7852e922
  		System.out.println(s2Str); // com.objectdemo.Student@4e25154f
  

  toString所输出的结果不能满足我们的需求，所以需要重写

• 重写的快捷键：alt + shift + s再按S

          @Override
          public String toString() {
              return "Student [name=" + name + ", age=" + age + ", dog=" + dog + "]";
          }
  

• 输出语句

  • 输出基本类型，输出的是数值
  • 输出引用数据类型，输出的是对象的toString方法

          //源码: 
          public void println(Object x) {
              String s = String.valueOf(x);
          }
  
          public static String valueOf(Object obj) {
              return (obj == null) ? "null" : obj.toString();
          }
  

4.boolean equals(Object obj)

默认父类Object类的equals方法比较的是地址,比较两个对象的地址是没有意义的

一般都是比较对象的成员是否相等

• 重写快捷键：alt + shift + s再按H

5.protected Object clone()

创建对象的方式有：

1. new
2. clone 深拷贝 浅拷贝
3. 反序列化
4. 反射

• clone方法在Object用protected修饰的，需要同包下，或着子类才可以访问调用，所以可以在子类进行重写

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

5.1浅克隆

5.2深克隆

当克隆对象内部存在引用对象时，会导致克隆与本体共同指向同一个引用对象，导致引用传递的问题

解决方案：类中重写clone方法

        @Override
        protected Object clone() throws CloneNotSupportedException {
            Student s = (Student) super.clone();
            s.dog = (Dog) this.dog.clone();
            return s;
        }
        //对内部的引用对象也进行克隆

6.protected void finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。