30从零开始学Java之详解面向对象的7种创建方式

水深无声 2024-03-22 16:50 13阅读 0赞

> **作者**：孙玉昌，昵称【**一一哥**】，另外【**壹壹哥**】也是我哦
> 
> 千锋教育高级教研员、CSDN博客专家、万粉博主、阿里云专家博主、掘金优质作者

## 前言 ##

在上一篇文章中，**壹哥**给大家介绍了Java中的类及其特点、创建过程等内容，相信你现在已经知道该如何创建一个Java类了。接下来在本篇文章中，**壹哥**会继续带大家学习面向对象中关于对象的内容。其实类和对象作为面向对象中最基本，也是最重要的单元，两者可以说是形影不离的，所以请大家继续打起精神认真学习吧。

\--------------------------------------------------**前戏已做完，精彩即开始**\----------------------------------------------

全文大约【**4700】**字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......

## 配套开源项目资料 ##

> **Github：**
> 
> [GitHub - SunLtd/LearnJava][GitHub - SunLtd_LearnJava]
> 
> **Gitee：**
> 
> [一一哥/从零开始学Java][Java]

## 一. 对象简介 ##

### 1. 概念 ###

**壹哥**在之前的文章中，其实已经给大家解释过对象的概念了。在面向对象的编程规范中，“一切皆对象”，对象就是面向对象编程的核心。现实世界中的每一个物体都是对象！当然，这个“对象”不是你怀里撒娇的男/女朋友，而是指某个“类”的一个实例。

比如，“人”是一个“整体”的概念，它不是“个体”的概念，所以“人”是“类别(模板)”，而不是对象。但是在人这个“类别”中，有法外狂徒张三这个个体，张三就是一个具体的“对象”。**每个对象都有自己的状态和行为**，比如张三的状态有：身高、体重、爱好；行为有：吃、喝、piao、du、抽，坑、蒙、拐、骗、偷等。

**本节配套视频链接如下：**

[Bilibili External Player][]

### 2. 行为和特征 ###

一个对象主要包括行为和特征(状态、属性)两个核心要素。

![6519d6423b3779a50a6aae551185e9f3.png][]

**行为**：一般是动词，指的是方法，代表一个对象能干什么，具有哪些功能或能力，例如人可以吃饭、睡觉、说话、工作等；在Java中，一般是用方法来表明对象所具有的行为。

**特征**：也可以叫做状态，一般是名词，指的是属性，代表一个对象有什么特点或参数，例如每个人的姓名、年龄、性别、体重等。在Java中，一般是用变量来表明对象的状态。

### 3. 对象的创建方式(重点) ###

对象就是类的实例化，也就是根据类来创建一个具体的对象，就好比我们使用一个手机壳模具制造出一个具体的手机壳。接下来**壹哥**就给大家讲一下，在Java中创建对象的两种主要方式：**显式创建与隐式创建**。

#### 3.1 显式创建 ####

其中显式创建对象时，又有以下4种具体的创建方式：

>  *  **使用new关键字创建对象；**
>  *  **使用newlnstance()实例方法创建对象；**
>  *  **使用clone()方法创建对象；**
>  *  **使用ObjectlnputStream对象的readObject()方法创建对象。**

#### 3.2 隐式创建 ####

隐式创建对象主要是包括以下几种方式：

>  *  **给String字符串变量赋值；**
>  *  **“+”号拼接多个字符串；**
>  *  **JVM虚拟机加载类时隐式创建类对象。**

接下来**壹哥**分别给大家讲解一下这几种创建对象的方式。受限于篇幅，今天主要是给大家讲解通过new关键字创建对象的方式，其他的方式我们以后再细讲。

## 二. 显式创建 ##

### 1. 使用new关键字创建对象 ###

#### 1.1 new简介 ####

我们知道，new是"新的"的意思。在Java中，**new是一个关键字，它用于创建一个新的类实例，即新的类对象。所以在Java中，创建新对象也可以叫做实例化对象。**对于引用类型来说，如果该类型没有进行实例化，也就是没有进行对象的创建，那么该对象的属性、方法等在内存中都是不存在的。只有使用new关键字创建了对象之后，这个对象在内存中才会存在，才能使用。

#### 1.2 new作用 ####

当一个引用类型的变量被声明以后，如果没有进行初始化，那么它就不指向任何对象，我们也就没办法使用该变量。所以我们就可以通过new关键字对该变量进行初始化，具体地来说，new关键字的作用如下：

>  *  **为新对象及对象中的各实例变量分配内存空间；**
>  *  **将新对象中的各实例变量自动初始化成对应类型的默认值；**
>  *  **初始化对象，并给各实例变量赋予正确的初始值；**
>  *  **调用引用类型对应的构造方法；**
>  *  **返回对象的引用。**

#### 1.3 基本语法 ####

new关键字创建对象的语法格式如下：

**类名 对象名 = new 类名()；**

#### 1.4 代码案例 ####

为了让大家更好地理解new的用法，**壹哥**给大家设计了如下代码案例。

/**
     * @author 一一哥Sun
     * QQ：2312119590
     * CSDN、掘金、知乎找我哦
     * 千锋教育
     */
    public class Demo01 {
    	public static void main(String[] args) {
    		// new关键字
    		Person p1 = new Person();
    	}
    }

在这段简单的代码中，`Person p1=new Person();`，前半部分`Person p1`，表示是在内存中分配一个Person类型的变量p1。后半部分`new Person();`，表示利用new关键字和构造方法来创建一个Person类型的对象，`Person()`是构造方法的名字。当构造方法执行完，这个Person类型的对象就建造出来了，也就为其分配了对应的内存。

**虽然p1是引用类型的变量，但p1自身会存储在栈内存中。而使用new关键字创造出来的对象，则被存储在堆内存(heap)中。且在new关键字真正创建出引用类型的对象之后，会把这个对象在内存中的地址返回给p1变量进行引用，这样我们就可以通过调用p1找到对内存中的Person对象。**

所以`Person p1=new Person();`这行代码的作用就是，**把Person对象在内存中的地址 赋值 给变量p1。在Java中，我们可以把p1变量叫做引用变量，或者简称为引用。又因为p1变量中存放的是引用类型的内存地址值，我们也可以把p1的值叫做引用地址。**

### 2. newlnstance()方法 ###

除了使用new关键字创建对象之外，我们还可以使用newInstance()方法创建对象。该方法是java.lang.Class 或 java.lang.reflect.Constuctor类中的实例方法，其语法格式如下：

java.lang.Class Class类对象名称 = java.lang.Class.forName(要实例化的类全称);
    
    类名 对象名 = (类名)Class类对象名称.newInstance();

我们在调用java.lang.Class类中的forName()方法时，需要将待实例化类的全限定名(如 com.yyg.Person)作为参数传递进来，然后再调用 java.lang.Class类对象的newInstance()方法创建对象。

/**
     * @author 一一哥Sun
     * QQ：2312119590
     * CSDN、掘金、知乎找我哦
     * 千锋教育
     */
    public class Demo01 {
    	public static void main(String[] args) {
    		//newInstance()方法创建对象
    		try {
    			Class<?> clazz = Class.forName("com.yyg.Person");
    			Person p2 = (Person) clazz.newInstance();
    		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
    			e.printStackTrace();
    		}
    	}
    }

因为这一块的内容涉及到了反射的知识点，后面**壹哥**会专门讲解反射，这一块的内容大家先有所了解即可。

### 3. clone()方法 ###

第三种显式创建对象的方法，就是利用实例对象的clone()方法进行对象的复制，也可以创建一个新对象出来。clone()方法创建对象时，不会调用类的构造方法，它会创建一个复制的对象，这个对象和原来的对象具有不同的内存地址，但它们的属性值却相同。

另外clone()方法是Java Object对象中被protected修饰的方法，可供子类调用以实现子类的克隆逻辑，但不能直接调用。并且我们使用该方法创建对象时，还要求待实例化的类必须实现 java.lang.Cloneable接口，否则会抛出 java.lang.CloneNotSupportedException异常，比较麻烦，所以该方法并不常用。 clone()方法创建对象的语法格式如下：

> **类名 对象名 = (类名)已创建好的类对象名.clone();**

### 4. readObject()方法 ###

我们还可以使用`java.io.ObjectlnputStream`对象的`readObject()`方法来创建一个新对象。`ObjectlnputStream`是IO流中的内容，以后**壹哥**会详细讲解Java中的IO流，大家对此先有一个大致的印象即可。

### 5. 小结 ###

**壹哥**在上面给大家提到了4种显式创建对象的方式，在此我们进行一个小小的总结：

>  *  new关键字是最常用的创建对象方式；
>  *  使用 new关键字 或 Class对象的newInstance()方法 创建对象时，都会调用类的构造方法；
>  *  使用 Class类的newInstance()方法 创建对象时，会调用类的默认构造方法，即无参构造方法；
>  *  使用 Object类的clone()方法 创建对象时，不会调用此类的构造方法，只会创建一个复制出的对象，该对象和原来的对象具有不同的内存地址，但它们的属性值相同；
>  *  如果类没有实现Cloneable接口却调用它的clone()方法，会抛出 java.lang.CloneNotSupportedException异常。

## 三. 隐式创建 ##

在Java中，除了可以显式地创建对象之外，还可以隐式地创建对象。隐式创建对象主要是通过以下几种方式：

>  *  **给String字符串变量赋值；**
>  *  **“+”号拼接多个字符串；**
>  *  **JVM虚拟机加载类时隐式创建类对象。**

### 1. 给String字符串变量赋值 ###

我们经常给一个字符串变量赋值，如下所示：

String str = "Hello，壹壹哥";

上面的str变量，其实就是一个String对象，该对象会由JVM虚拟机隐式地创建出来。

### 2. “+”号拼接多个字符串 ###

我们知道，“+”运算符有两个基本作用：加法运算和字符串拼接。当进行字符串拼接时，其运算的结果是一个新的 String对象，示例如下：

String str1 = "Hello";
    String str2 = "一一哥";
    String str3 = str1+str2;    // str3引用一个新的String对象

通过上面的语句，JVM会隐式地创建出第3个String对象。

### 3. JVM虚拟机加载类时隐式创建类对象 ###

当Java的JVM虚拟机加载一个类时，会隐式地创建出一个可以描述这个类的Class实例对象。类的加载是指把类的.class字节码文件读到内存中，把它存放到运行时数据区的方法区中，然后会在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构。关于Java类加载机制的更多详细内容，**壹哥**会在高级课程阶段给大家详细讲解，敬请期待哦。

### 4. 小结 ###

无论我们是釆用显式或是隐式方式创建对象，Java虚拟机都会在创建对象时包含以下步骤：

>  *  **给对象分配内存；**
>  *  **将对象的实例变量自动初始化成该变量类型的默认值；**
>  *  **初始化对象，给实例变量赋予正确的初始值。**

## 四. 对象的使用 ##

### 1. 简介 ###

我们在通过一系列方式创建好对象之后，那么这个对象该怎么用呢？我们知道对象中有状态和行为两个核心要素，那怎么来调用一个对象的行为和状态呢？Java中，一个普通的实例对象调用它的行为和状态，基本的语法格式如下：

> **//调用状态**
> 
> **对象.属性名；**
> 
> **//调用方法**
> 
> **对象.方法名();**

接下来我们通过一个小案例给大家展示一下。

### 2. 使用 ###

/**
    * @author 一一哥Sun
    * QQ：2312119590
    * CSDN、掘金、知乎找我哦
    * 千锋教育
    */
    public class Demo02 {
        public static void main(String[] args) {
            // 对象的使用
    		//先创建一个对象
    		Person p1=new Person();
    		//调用对象的属性(该属性不能是私有的,否则别的类中无法看到)--状态.
    		String name = p1.name;
    		
    		//调用对象的方法
    		p1.eat();
    		p1.speak("一一哥", "男", 18);
        }
    }

大家要注意，当我们在A类中调用B类对象时，B类对象的属性或方法不能是私有的，否则在A类中会无法看到该属性或方法。

**本节配套视频链接如下：**

[Bilibili External Player][Bilibili External Player 1]

## 五. 创建对象的内存分析(重点) ##

### 1. 内存简介 ###

Java程序在运行时，操作系统会给程序分配三块主要的内存空间：**栈内存、堆内存、方法区**。

>  *  **栈内存**: 栈内存也叫做虚拟机栈，可以**存放基本类型的数据和引用类型的地址，主要是局部变量。****这些****局部变量存放了编译期可知长度的各种基本数据类型和对象引用，方法执行完就会自动释放**。栈内存具有先进后出、占用空间比较小、存取速度相对较快的特点。
>  *  **堆内存:** 堆内存中可以**存放各对象实例(所有new出来的对象都是)和数组都在堆中存放，即堆中存放的是引用类型的实际数据。**堆内存占用的空间比较大，存取速度相对较慢。
>  *  **方法区**: 方法区主要用于**存储类信息、常量、静态变量，静态代码块、即时编译器(JIT Compiler)编译后的代码数据等****，**简单言之就是**存储类的结构信息。类的结构信息包括类的名称、方法信息、字段信息等**。在方法区中，有一块空间叫做**常量池(串池)，用来存放字符串常量**。还有一块空间叫**做静态区，用来存储静态变量等静态数据**。但在JDK 7之后，常量池、静态区作为堆中的一个子部分，方法区的概念被弱化。

### 2. 内存分析 ###

/**
    * @author 一一哥Sun
    * QQ：2312119590
    * CSDN、掘金、知乎找我哦
    * 千锋教育
    */
    public class Demo02 {
        public static void main(String[] args) {
            // 对象的使用
    		//先创建一个Person对象
    		Person p1=new Person();
            p1.name="一一哥";
            p1.age=18;
            p1.sex="男";
    
            //创建p2对象
            Person p2=new Person();
        }
    }

在上述代码中，我们定义的Person类型p1变量实际上是一个引用，它会被存放在栈内存中，而存放实际数据的Person对象则存放在堆内存中。如下图所示：

![5032077ac1bacb287363b683253450b8.png][]

**根据上面的内存分析图可知：**

>  *  Person类中包含了name、age、sex三个属性，它们分别是String、int、String类型。我们知道，它们的默认值分别是null、0、null。
>  *  我们创建一个p1对象之后，p1会被存放在栈区，然后p1会通过堆中Person对象的内存地址，去找到该对象被实例化的内容(即name、age、sex等)。
>  *  Java代码中刚创建出来的对象属性都是采用默认值(null、0、null)，等我们通过"对象.属性"的方式对属性进行重新赋值后，堆内存中存储的才是赋值后的内容。
>  *  我们创建的另一个对象p2，p2依然在栈区，但并没有对p2进行初始化，所以p2的属性在堆内存中都是默认值。
>  *  堆内存中的每一个对象，都有一个独立的内存空间。

**本节内容配套视频链接如下：**

[Bilibili External Player][Bilibili External Player 2]

\----------------------------------------------**正片已结束，来根事后烟**\--------------------------------------------

## 六. 结语 ##

至此，**壹哥**就给大家把Java的对象介绍完毕了，现在你知道几种创建对象的方式呢？最后再跟大家说一下，不管我们用哪种方式创建出来的对象，**每个对象都是相互独立的。这些不同的对象在内存中会占有独立的内存地址，且每个对象都具有自己的生命周期。当一个对象的生命周期结束时，对象就变成了垃圾，这些垃圾对象会被JVM虚拟机自带的GC垃圾回收机制来处理。**

虽然今天的代码不多，但内容很重要哦。如果你独自学习觉得有很多困难，可以加入**壹哥**的学习互助群，大家一起交流学习。

## 七. 今日作业 ##

### 1. 第一题 ###

评论区写出Java中创建对象的方式有哪些？

### 2. 第二题 ###

创建一个Java对象，绘图描述出该对象创建时的内存结构。

[GitHub - SunLtd_LearnJava]: https://github.com/SunLtd/LearnJava
[Java]: https://gitee.com/sunyiyi/LearnJava
[Bilibili External Player]: https://player.bilibili.com/player.html?bvid=BV1Ja411x7XB&p=68&page=68
[6519d6423b3779a50a6aae551185e9f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3f8a96a7b3854fbfa85ce0d7e646ff3f.png
[Bilibili External Player 1]: https://player.bilibili.com/player.html?bvid=BV1Ja411x7XB&p=71&page=71
[5032077ac1bacb287363b683253450b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e6b7045ee7cf4cfba68953b19f5ea3b2.png
[Bilibili External Player 2]: https://player.bilibili.com/player.html?bvid=BV1Ja411x7XB&p=70&page=70