019：Java 对象的创建、访问以及销毁

Java 对象的创建、访问、销毁

（转自：http://c.biancheng.net/view/940.html）

1        对象的创建（掌握）

首先明白对象是什么东西？对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明对象所具有的行为。Java 对象的生命周期包括创建、使用和清除，本文详细介绍对象的创建，在 Java 语言中创建对象分显式创建与隐含创建两种情况。

1） 显式创建对象（4种方式）

（1）  使用new关键字创建对象

这是常用的创建对象的方法，语法格式如下：

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

例如：Student student1 = new Student("小刘",22);

（2）  调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法

在 Java 中，可以使用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法来创建对象，代码格式如下：

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

类名 对象名 = (类名)Class类对象名称.newInstance();

  1. // 调用 java.lang.Class 的 newInstance() 方法创建对象
  2. Class c1 = Class.forName("Student");
  3. Student student2 = (Student)c1.newInstance();

调用 java.lang.Class 类中的 forName() 方法时，需要将要实例化的类的全称（比如 com.mxl.package.Student）作为参数传递过去，然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。

   （3）调用调用对象的 clone() 方法（不常用）
使用该方法创建对象时，要实例化的类必须继承 java.lang.Cloneable 接口。 调用对象的 clone() 方法创建对象的语法格式如下：

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

例如：

  1. // 调用对象的 clone() 方法创建对象
  2. Student student3 = (Student)student2.clone();

 

（4）调用 java.io.ObjectlnputStream 对象的 readObject() 方法（了解）

对上述示例的说明如下：

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

 

2）隐式创建对象（三种情况）

1）String strName = "strValue"，其中的“strValue”就是一个 String 对象，由 Java 虚拟机隐含地创建。

2）字符串的“+”运算符运算的结果为一个新的 String 对象，示例如下：

  1. String str1 = "Hello";
  2. String str2 = "Java";
  3. String str3 = str1+str2;    // str3引用一个新的String对象

3）当 Java 虚拟机加载一个类时，会隐含地创建描述这个类的 Class 实例。

提示：类的加载是指把类的 .class 文件中的二进制数据读入内存中，把它存放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class 对象，用来封装类在方法区内的数据结构。

无论釆用哪种方式创建对象，Java 虚拟机在创建一个对象时都包含以下步骤：

  • 给对象分配内存。
  • 将对象的实例变量自动初始化为其变量类型的默认值。
  • 初始化对象，给实例变量赋予正确的初始值。
    注意：每个对象都是相互独立的，在内存中占有独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由 Java 虚拟机自带的垃圾回收机制处理。

2） 匿名对象（应用部分很多地方使用）

概念：匿名对象就是没有明确的给出名字的对象，是对象的一种简写形式。一般匿名对象只使用一次，而且匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

创建匿名对象的标准格式如下：

类名称 对象名 = new 类名称();

每次 new 都相当于开辟了一个新的对象，并开辟了一个新的物理内存空间。如果一个对象只需要使用唯一的一次，就可以使用匿名对象，匿名对象还可以作为实际参数传递。

  1. public class Person {
  2.     public String name; // 姓名
  3.     public int age; // 年龄
  4.  
  5.     // 定义构造方法，为属性初始化
  6.     public Person(String name, int age) {
  7.        this.name = name;
  8.        this.age = age;
  9.     }
  10.  
  11.    // 获取信息的方法
  12.    public void tell() {
  13.       System.out.println("姓名：" + name + "，年龄：" +           age);
  14.    }
  15.  
  16.    public static void main(String[] args) {
  17.       newPerson("张三",30).tell();// 匿名对象
  18.    }
  19. }

程序运行结果为：

姓名：张三，年龄：30

在以上程序的主方法中可以发现，直接使用了“new Person("张三",30)”语句，这实际上就是一个匿名对象，与之前声明的对象不同，此处没有任何栈内存引用它，所以此对象使用一次之后就等待被 GC（垃圾收集机制）回收。

匿名对象在实际开发中基本都是作为其他类实例化对象的参数传递的，在后面的 Java 应用部分的很多地方都可以发现其用法，而且细心的读者可以发现，匿名对象实际上就是个堆内存空间，对象不管是匿名的还是非匿名的，都必须在开辟堆空间之后才可以使用。

2        对象的访问（访问对象的属性和行为--掌握）

每个对象都有自己的属性和行为，这些属性和行为在类中体现为成员变量和成员方法，其中成员变量对应对象的属性，成员方法对应对象的行为。
在 Java 中，要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。语法格式如下：

对象名.属性(成员变量)    // 访问对象的属性
对象名.成员方法名()    // 访问对象的方法

例如，定义一个 Student 类，创建该类的对象 stu，再对该对象的属性赋值，代码如下：

  1. Student stu = new Student();    // 创建 Student 类的对象 stu
  2. stu.Name = "李子文";    // 调用stu对象的Name属性并赋值
  3. stu.Sex = true;    // 调用stu对象的Sex属性并赋值
  4. stu.Age = 15;    // 调用stu对象的Age属性并赋值

如果一个对象要被使用，则对象必须被实例化，如果一个对象没有被实例化而直接调用了对象中的属性或方法，如下代码所示：

  1. Student stu = null;
  2. stu.Name = "李子文";
  3. stu.Sex = true;
  4. stu.Age = 15;

则程序运行时会出现以下异常：

Exception in thread "main" java.lang.NullPointerException

此异常是开发中最常见的异常，也会始终伴随着每位开发人员，使用了未实例化的对象则肯定会出现此异常。。

3        对象的销毁（知道可以这样用就行）

       对象使用完之后需要对其进行清除。对象的清除是指释放对象占用的内存。在创建对象时，用户必须使用 new 操作符为对象分配内存。不过，在清除对象时，由系统自动进行内存回收，不需要用户额外处理。这也是 Java 语言的一大特色，某种程度上方便了程序员对内存的管理。
       Java 语言的内存自动回收称为垃圾回收（Garbage Collection）机制，简称 GC。垃圾回收机制是指 JVM 用于释放那些不再使用的对象所占用的内存。
Java 语言并不要求 JVM 有 GC，也没有规定 GC 如何工作。不过常用的 JVM 都有 GC，而且大多数 GC 都使用类似的算法管理内存和执行回收操作。具体的垃圾回收实现策略有好多种，在此不再赘述。
       注意：C++语言对象是通过 delete 语句手动释放。如果回收内存的任务由程序负责，也就是说必须在程序中显式地进行内存回收，这无疑会增加程序员的负担，而且存在很多弊端。Java 语言对象是由垃圾回收器收集然后释放，程序员不用关心释放的细节。自动内存管理是现代计算机语言发展趋势，

例如：C# 语言的垃圾回收，Objective-C 和 Swift 语言的 ARC（内存自动引用计数管理）。

一个对象被当作垃圾回收的情况主要如下两种。
1）对象的引用超过其作用范围。

  1. {
  2.     Object o = new Object();    // 对象o的作用范围，超过这个范围对象将被视为垃圾
  3. }

2）对象被赋值为null。

  1. {
  2.     Object o = new Object();
  3.     o = null;    // 对象被赋值为null将被视为垃圾
  4. }

在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。
在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。
1）可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。
2）可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。
3）不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。
注意：调用 System.gc() 或者 Runtime.gc() 方法也不能保证回收操作一定执行，它只是提高了 Java 垃圾回收器尽快回收垃圾的可能性。

 

 

 

 

posted @ 2021-11-14 22:25  Jaoany  阅读(706)  评论(0)  编辑  收藏  举报