Java中对象的初始化和回收

关注

原创最新推荐文章于 2026-02-19 00:09:32 发布 2k 阅读 AI 写同款· GEO 优化 ›

20、Java编程中的对象清理、垃圾回收与初始化机制解析本文详细解析了Java编程中对象清理、垃圾回收与初始化机制。内容涵盖终结器`finalize()`的作用与局限性、垃圾回收的不同算法（引用计数法、停止-复制算法、标记-清除算法）、Java堆内存分配与回收流程、类成员的初始化规则（包括局部变量、基本类型成员、对象引用的初始化）、构造函数与静态块初始化顺序、以及初始化机制在多线程环境和实际应用中的影响。同时，还讨论了初始化过程中的异常处理和性能考量，并提供了实际应用建议和未来发展趋势展望。适合Java开发者深入理解底层机制并优化程序性能。阅读详情

对象初始化

构造方法

<span style="font-size:18px;">package com.cloud.day1;
/**
 * 对象的初始化
 * 1.编译器调用构造器
 * 2.构造器和类名相同
 * 3.初始化期间自动调用构造器
 */
class Test{
   /*无参构造器*/
   public Test(){
      System.out.println("初始化期间自动调用构造器");
   }
   /*带参构造器*/
   public Test(int t){
      System.out.println("有参构造器："+t);
   }
}
public class Demo1 {
   public static void main(String[] args) {
      /*Java中对象初始化和创建是在一起执行的*/
      for(int i=0;i<5;i++){
        /*每次初始化期间都调用构造器,给对象分配存储空间*/
        new Test();
        new Test(i);
      }
   }
}</span>

方法重载

创建对象，会给这个对象所存储的空间取了一个名字，方法是给某个对象动作取的名字。

构造器：方法名相同而形式参数不同，用来初始化一些常用对象信息。

重载的方法必须有独一无二的形参列表，参数顺序和类型都可以用来区分方法的不同信息。

<span style="font-size:18px;">package com.cloud.day1;
class DogTest{
   String name;
   /*有参数和无参数的构造器*/
   public DogTest(){
      name = "小白1";
      System.out.println("初始化一条小白.."+name);
   }
   public DogTest(String name){
      this.name = name;
      System.out.println("自己给小狗取名.."+name);
   }
   /*根据方法中形参的不同进行方法重载*/
   public void info(){
      System.out.println("小狗会汪汪叫..");
   }
   public void info(String what){
      System.out.println(name+"小狗会："+what);
   }
   public void info(int age){
      System.out.println(name+"小狗："+age+"岁..");
   }
}
public class Demo2 {
   public static void main(String[] args) {
      DogTest dt = new DogTest("哈士奇");
      dt.info("看家..");
      dt.info(6);
   }
}</span>

基本类型方法重载

基本类型存在一个自动转换的信息，在当做方法的形式参数时需要特别的注意。

返回值区分重载:这种方式会报错

<span style="font-size:18px;">public void getI(){
		System.out.println("I=2");
}
public int getI(){
		return 1l;
}</span>

构造器

这里就说一点：无参构造器就是默认构造器

<span style="font-size:18px;">package com.cloud.day1;
public class Demo3 {
   public static void main(String[] args) {
      new TestCon1();
      //如果TestCon2不声明无参构造器这里就会报错
      new TestCon2();
      new TestCon2(2);
   }
}
class TestCon1{
   public TestCon1(){
      System.out.println("无参构造器！");
   }
}
/**  
 * @ClassName: TestCon2
 * @Description: 这里很明确验证了无参构造器就是默认构造器
 * @author午_夜
 * @date 2016-8-10 下午5:55:25
 */
class TestCon2{
   public TestCon2(){
      System.out.println("无参构造器！");
   }
   public TestCon2(int i){
      System.out.println("有参构造器！"+i);
   }
}
 </span>

this关键字

this代表调用方法的那个对象的引用。

<span style="font-size:18px;">package com.cloud.day1;
public class Demo4 {
   int i = 1;
   public Demo4 add(){
      System.out.println(++i);
      //很明显这里返回this就代表了Demo4的对象
      return this;
   }
   public static void main(String[] args) {
      Demo4 dm = new Demo4();
      System.out.println("调用方法的对象："+dm.add().getClass().getName());
      /*既然每次都返回的都是对象就可以连续的调用*/
      dm.add().add().add().add();
   }
}
</span>

this在构造方法中的使用

<span style="font-size:18px;">package com.cloud.day1;
public class Demo5 {
   public static void main(String[] args) {
      Cat cat = new Cat();
      System.out.println(cat.getCat().getClass().getName());
   }
}
class Dog{
   static Cat getCat(Cat cat){
      return cat;
   }
}
class Cat{
   Cat getCat(){
      /*this代表调用getCat的对象引用，那么就是Cat对象*/
      return Dog.getCat(this);
   }
}</span>

初始化

直接使用没有初始化的变量

<span style="font-size:18px;">void add(){
      /*这里声明一个int类型的变量，但是没有初始化*/
      int i;
      /*这里操作一个没有初始化的变量，编译器编译时直接报错*/
      //++;
}</span>

常见类型初始化

<span style="font-size:18px;">package com.cloud.day1;
public class Demo7 {
   public static void main(String[] args) {
 
   }
}
/**  
 * @ClassName: InitValue1
 * @Description: 基本数据类型初始化
 * @author午_夜
 * @date 2016-8-11 下午6:14:44
 */
class InitValue1{
   boolean b = true;
   int i = 2;
   long lg = 1;
   byte bt= 55;
   float f = 3.14f;
}
/**  
 * @ClassName: InitValue1
 * @Description: 引用类型初始化
 * @author午_夜
 * @date 2016-8-11 下午6:18:46
 */
class InitValue2{
   InitValue1 iv = new InitValue1();
   /*使用一个方法提供初始值,但是只有这个方法被执行之后才有初始值*/
   int i = f();
   int f(){return 11;}
}
</span>

构造器初始化

<span style="font-size:18px;">package com.cloud.day1;
public class Demo8 {
   public static void main(String[] args) {
      Constr cs = new Constr();
      /* 这里这样输出就会报错
      int i;
      System.out.println(i);
      */
   }
}
class Constr{
   public int i;
   public Constr(){
      /*i=0*/
      System.out.println("1.---"+i);
      i = 3;
      /*i=3*/
      System.out.println("2.---"+i);
   }
}
</span>

初始化顺序

在类的内部，变量定义的先后顺序决定了初始化的先后顺序。

<span style="font-size:18px;">package com.cloud.day1;
public class Demo9 {
   public static void main(String[] args) {
      House hs = new House();
      hs.ff();
   }
}
class Window{
   public Window(int i){
      System.out.println("Window:"+i);
   }
}
class House{
   Window w1 = new Window(11);
   public House(){
      System.out.println("House()");
      w3 = new Window(33);
   }
   Window w2 = new Window(22);
   public void ff(){
      System.out.println("ff()");
   }
   Window w3 = new Window(3);
}
</span>

静态数据初始化

无论创建多少个对象，静态存储数据只占有一份内存空间，static关键字不能使用于局部变量，如果一个静态域存放是基本数据类型，而且没有进行初始化，那么它们就是基本类型的标准初值，如果是引用类型没有初始化，那么就是null。

<span style="font-size:18px;">package com.cloud.day2;
public class Demo1 {
   public static void main(String[] args) {
      Test2 te = new Test2();
   }
}
class Test1{
   Test1(int t1){
      System.out.println("Test1:"+t1);
   }
   public void test1f(int f){
      System.out.println("fff:"+f);
   }
}
class Test2{
   static Test1 t1 = new Test1(1);
   public Test2(){
      System.out.println("Test2");
      t2.test1f(222);
   }
   public void test2f(){}
   static Test1 t2 = new Test1(2);
}
</span>

静态代码块

和静态变量一样，静态代码块也是在首次访问类的时候被加载。

<span style="font-size:18px;">package com.cloud.day2;
public class Demo1 {
   public static void main(String[] args) {
      Test2 te = new Test2();
   }
}
class Test1{
   Test1(int t1){
      System.out.println("Test1:"+t1);
   }
   public void test1f(int f){
      System.out.println("fff:"+f);
   }
}
class Test2{
   static Test1 t1;
   static Test1 t2;
   static {
      t1 = new Test1(11);
      t2 = new Test1(22);
   }
   public Test2(){
      System.out.println("Test2初始化");
   }
}
</span>

非静态初始化

<span style="font-size:18px;">package com.cloud.day2;
public class Demo1 {
   public static void main(String[] args) {
      Test2 te1 = new Test2();
      Test2 te2 = new Test2(222);
   }
}
class Test1{
   Test1(int t1){
      System.out.println("Test1:"+t1);
   }
   public void test1f(int f){
      System.out.println("fff:"+f);
   }
}
class Test2{
   Test1 t1;
   Test1 t2;
   /*每次实例化这个类的时候，这个代码块都会被加载，这是和静态代码块的区别*/
   {
      t1 = new Test1(11);
      t2 = new Test1(22);
      System.out.println("代码块！");
   }
   public Test2(){
      System.out.println("Test2初始化");
   }
   public Test2(int i){
      System.out.println("Test2初始化"+i);
   }
}
</span>

数组初始化

数组是具有相同类型，使用同一个标识符封装到一起的一个对象序列或者基本类型的数据序列。数组是引用类型，数组之间的相互赋值就是在复制引用。

<span style="font-size:18px;">package com.cloud.day2;
public class Demo1 {
   public static void main(String[] args) {
      int[] a1 = {1,2,3};
      int[] a2 ;
      a2 = a1;
      for(int i = 0;i<a2.length;i++){
        a2[i] = a2[i]+1;
      }
      for(int j = 0;j<a1.length;j++){
        System.out.println("a1["+j+"]="+a1[j]);
      }
   }
}
</span>

可变参数列表

<span style="font-size:18px;">public class Demo1 {
   static void printArray(Object[] args){
      for(Object obj:args){
        System.out.println(obj+"");
      }
   }
   public static void main(String[] args) {
      printArray(new Object[]{"11","22","33"});
   }
}</span>

Java中垃圾回收机制

什么是垃圾回收

对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其它对象；而在Java中，当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。JVM的一个系统级线程会自动释放该内存块。垃圾回收意味着程序不再需要的对象是"无用信息"，这些信息将被丢弃。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用。

Java垃圾回收器

java存在一个垃圾回收器，监视所有使用new创建的对象，并判断哪些是不再被引用的对象，随后释放内存空间，这样很好的解决了编程的内存泄露问题。

<span style="font-size:18px;">public class Demo1 { 
    public static void main(String[] args) { 
        //这里创建一个引用，并且初始化 
        String s = "Hello"; 
        //创建一个引用并且使用new关联对象 
        String s1 = new String("MyString"); 
        String s2 = new String("YourString"); 
        //这里修改s2的引用的指向地址，指向s1引用指向的对象地址 
        //程序运行到这里就会产生一个垃圾对象"YourString" 
        //jvm启动垃圾回收时，就会回收该垃圾对象，释放空间 
        s2 = s1; 
        System.out.println("s1:"+s1); 
        System.out.println("s2:"+s2); 
        /**输出结果
         * s1:MyString
         * s2:MyString
         */ 
    } 
}</span>

收录于