#### 概述

Object类是Java中的祖宗类，一个类或者默认继承Object类，或者间接继承Object类，Object类的方法是一切子类都可以直接使用

默认是比较两个对象的内容是否相同，如果只是比较两个对象的地址可以用“==”替代equals

所以equals存在的意义是为了被子类重写，以便程序员可以自己来定制比较规则

* `protected Object clone()`：创建并返回此对象的副本

只要两个对象的内容一样，就认为是相等的：

```java

public boolean equals(Object o) {

// 1.判断是否自己和自己比较，如果是同一个对象比较直接返回true

if (this == o) return true;

// 2.判断被比较者是否为null ,以及是否是学生类型。

if (o == null || this.getClass() != o.getClass()) return false;

// 3.o一定是学生类型，强制转换成学生，开始比较内容！

Student student = (Student) o;

return age == student.age &&

sex == student.sex &&

Objects.equals(name, student.name);

}

```

**面试题**：== 和equals的区别

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的**地址**是否相同，即是否是**指相**同一个对象。比较的是真正意义上的指针操作。

equals用来比较的是两个对象的**内容**是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断

***

#### 深浅克隆

克隆就是制造一个对象的副本。根据所要克隆的对象的成员变量中是否含有引用类型，可以将克隆分为两种：浅克隆(Shallow Clone) 和 深克隆(Deep Clone)，默认情况下使用Object中的clone方法进行克隆就是浅克隆，即完成对象域对域的拷贝

浅拷贝（shallowCopy）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象，简而言之就是增加了一个指针指向原来对象的内存地址

深拷贝（deepCopy）：深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性并拷贝属性指向的动态分配的内存，简而言之就是把所有属性复制到一个新的内存，增加一个指针指向这个新的内存

* 使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误

Cloneable 接口是一个标识性接口，即该接口不包含任何方法（包括clone()），但是如果一个类想合法的进行克隆，那么就必须实现这个接口，在使用clone()方法时，若该类未实现 Cloneable 接口，则抛出异常

* Clone & Copy：`Student s = new Student`

`Student s1 = s`：只是copy了一下reference，s和s1指向内存中同一个object，对对象的修改会影响对方

`Student s2 = s.clone()`：会生成一个新的Student对象，并且和s具有相同的属性值和方法

* Shallow Clone & Deep Clone：

浅克隆：Object中的clone()方法在对某个对象克隆时对其仅仅是简单地执行域对域的copy


对八种基本类型的克隆是没有问题的，String 在克隆时只是克隆了它的引用，因为**String是在内存中不可以被改变的对象**，所以在使用克隆时，我们可以将 String类型视为与基本类型，只需浅克隆即可

但当对一个引用类型进行克隆时只是克隆了它的引用，克隆对象和原始对象共享了同一个对象成员变量

public class Student implements Cloneable{

private String name;

private Integer age;

private Date date;

@Override

protected Object clone() throws CloneNotSupportedException {

Student s = (Student) super.clone();

s.date = (Date) date.clone();

return s;

}

//.....

#### 不可变好处

* String 不可变性天生具备线程安全，可以在多个线程中安全地使用

***

### 对象创建

#### 创建时机

一个Java对象的创建过程往往包括 **类初始化** 和 **类实例化** 两个阶段

Java对象创建时机：

1. 使用new关键字创建对象： 由执行类实例创建表达式而引起的对象创建

2. 使用Class类的newInstance方法 (反射机制)

3. 使用Constructor类的newInstance方法(反射机制)

```java

public class Student {

private int id;

public Student(Integer id) {

this.id = id;

}

public static void main(String[] args) throws Exception {

Constructor<Student> c = Student.class.getConstructor(Integer.class);

Student stu = c.newInstance(123);

}

}

```

使用newInstance方法的这两种方式创建对象使用的就是Java的反射机制，事实上Class的newInstance方法内部调用的也是Constructor的newInstance方法

4. 使用Clone方法创建对象：用clone方法创建对象的过程中并不会调用任何构造函数，要想使用clone方法，我们就必须先实现Cloneable接口并实现其定义的clone方法

5. 使用(反)序列化机制创建对象：当我们反序列化一个对象时，JVM会给我们创建一个单独的对象，在此过程中，JVM并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现Serializable接口

从Java虚拟机层面看，除了使用new关键字创建对象的方式外，其他方式全部都是通过转变为invokevirtual指令直接创建对象的

***

#### 创建过程

当一个对象被创建时，虚拟机就会为其分配内存来存放对象的实例变量及其从父类继承过来的实例变量(即使这些从超类继承过来的实例变量有可能被隐藏也会被分配空间)，同时这些实例变量也会被赋予默认值(零值)，然后开始进行对象初始化： **实例变量初始化**、**实例代码块初始化** 、 **构造函数初始化**

1. 实例变量初始化与实例代码块初始化

对实例变量直接赋值或者使用实例代码块赋值，编译器会将其中的代码放到类的构造函数中去，并且这些代码会被放在对超类构造函数的调用语句之后 (Java要求构造函数的第一条语句必须是超类构造函数的调用语句)，构造函数本身的代码之前

2. 构造函数初始化

**Java要求在实例化类之前，必须先实例化其超类，以保证所创建实例的完整性**，在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到Object类。然后从Object类依次对以下各类进行实例化，初始化父类中的变量和执行构造函数

***

#### 承上启下

1. 一个实例变量在对象初始化的过程中会被赋值几次？

JVM在为一个对象分配完内存之后，会给每一个实例变量赋予默认值，这个实例变量被第一次赋值

在声明实例变量的同时对其进行了赋值操作，那么这个实例变量就被第二次赋值

在实例代码块中又对变量做了初始化操作，那么这个实例变量就被第三次赋值

在构造函数中也对变量做了初始化操作，那么这个实例变量就被第四次赋值

在Java的对象初始化过程中，一个实例变量最多可以被初始化4次

2. 类的初始化过程与类的实例化过程的异同？

类的初始化是指类加载过程中的初始化阶段对类变量按照代码进行赋值的过程；

而类的实例化是指在类完全加载到内存中后创建对象的过程

3. 假如一个类还未加载到内存中，那么在创建一个该类的实例时，具体过程是怎样的？（**经典案例**）

```java

public class StaticTest {

public static void main(String[] args) {

staticFunction();//调用静态方法，触发初始化

}

static StaticTest st = new StaticTest();

static { //静态代码块

System.out.println("1");

}

{ // 实例代码块

System.out.println("2");

}

StaticTest() { // 实例构造器

System.out.println("3");

System.out.println("a=" + a + ",b=" + b);

}

public static void staticFunction() { // 静态方法

System.out.println("4");

}

int a = 110; // 实例变量

static int b = 112; // 静态变量

}/* Output:

2

3

a=110,b=0

1

4

*///:~

```

`static StaticTest st = new StaticTest();`：

* 实例初始化化不一定要在类初始化结束之后才开始

* 在同一个类加载器下，一个类型只会被初始化一次。所以一旦开始初始化一个类，无论是否完成后续都不会再重新触发该类型的初始化阶段了(只考虑在同一个类加载器下的情形)。因此，在实例化上述程序中的st变量时，**实际上是把实例初始化嵌入到了静态初始化流程中，并且在上面的程序中，嵌入到了静态初始化的起始位置**，这就导致了实例初始化完全发生在静态初始化之前，这也是导致a为110 b为0的原因

代码等价于：

```java

public class StaticTest {

<clinit>(){

a = 110; // 实例变量

System.out.println("2"); // 实例代码块

System.out.println("3"); // 实例构造器中代码的执行

System.out.println("a=" + a + ",b=" + b); // 实例构造器中代码的执行

类变量st被初始化

System.out.println("1"); //静态代码块

类变量b被初始化为112

}

}

```

准备阶段为**静态变量分配内存并设置初始值**，使用的是方法区的内存：

* 类变量也叫静态变量，就是是被 static 修饰的变量

初始化阶段才真正开始执行类中定义的 Java 程序代码，在准备阶段，类变量已经赋过一次系统要求的初始值；在初始化阶段，通过程序制定的计划去初始化类变量和其它资源，执行<clinit>

类构造器<clinit>()与实例构造器<init>()不同，它不需要程序员进行显式调用。在一个类的生命周期中，类构造器<clinit>()最多会被虚拟机**调用一次**，而实例构造器<init>()则会被虚拟机调用多次，只要程序员创建对象

实例化即调用 <init>()V ，虚拟机会保证这个类的构造方法的线程安全，先为实例变量分配内存空间，再执行赋默认值，然后根据源码中的顺序执行赋初值或代码块，没有成员变量初始化和代码块则不会执行

###### 时机

类的初始化是懒惰的，初始化时机：

* 补充：类对象.class 不会触发初始化，Class.forName会