JavaSE-object类

object

（1）定义：

Object 是我们所有类的顶层父类，所有类都是直接或间接继承自他。

（2）哈希码值：

hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

（3）举例：

public class MyTest extends Object{
public static void main(String[] args) {
//创建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);
//不同的对象的哈希码值不一样
}
}

输出：21029277
24324022

（4）比较两个对象的地址值是否相等

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

（5）object类和其构造方法

类层次结构的根类
所有类都直接或者间接的继承自该类

构造方法为：public Object()

注意：子类的构造方法默认访问的是父类的无参构造方法。

object类的hashcode（）方法

（1）书写方法

public int hashCode()

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

object类的getClass（）方法

（1）书写方法：

public final Class getClass()

a:返回此 Object 的运行时类。
b:可以通过Class类中的一个方法，获取对象的真实类的全名称。
public String getName()

object类的toString（）方法

（1）书写方法：
public String toString()

public String toString()
a:返回该对象的字符串表示。
源代码:
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
b:它的值等于：
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
怎么重写, 一般是将该类的所有的成员变量组成返回即可

（2）举例

import java.util.Scanner;

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());
System.out.println("------------------------");
Student student1 = new Student("张三", 24);
String s1 = student1.toString();
System.out.println(s1);
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 +
'}';
}
}

结果：

java.lang.Object@140e19d

Student{name=‘null’, age=0}

Student{name=‘张三’, age=24}
java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=,][decimal separator=.][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\Q�\E][infinity string=\Q∞\E]

object类的clone（）方法

（1）权限修饰符：

clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public

（2）使用clone()方法采用的是浅克隆的方式

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。

2. Cloneable接口只不过是一个标识接口而已，没有任何方法。

3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把
   另外一个对象也克隆一份。

4. 对象的浅克隆也不会调用到构造方法的。

   （3）举例

   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("狗吃肉");
   }
   }

结果：
构造方法执行了
狗吃肉