关于java:Java中对象的生与灭-核心篇

大家好啊，我是汤圆，明天给大家带来的是《Java 中对象的生与灭 - 外围篇》，心愿对大家有帮忙，谢谢

文章纯属原创，集体总结不免有过错，如果有，麻烦在评论区回复或后盾私信，谢啦

后面咱们理解了 Java 的三大个性，其中介绍了类的继承、重载等，这里咱们就基于这些知识点，把对象的创立和回收进行一个简略的介绍

这篇不是很长，只是介绍外围的几个知识点，置信大家很快就可以看完，真的

堆和栈
构造函数（生）
对象的回收（灭）

堆是一块内存，用来寄存对象

栈是另一块内存，用来执行办法并存储局部变量，遵循后进先出的准则；

PS：栈并不存储办法，只是执行办法，执行完办法后，会将办法弹出栈（办法存在办法区）

上面咱们用理论代码，来看下堆和栈的区别

代码如下：

public class LiveAndDeathDemo {
      // 根本类型属性
    private int a;

    public static void main(String[] args) {LiveAndDeathDemo live = new LiveAndDeathDemo(1);
        live.fun();}
    public void fun(){
        int temp = 10;
        System.out.println(temp);
    }

    public LiveAndDeathDemo(int a) {this.a = a;}
    public int getA() {return a;}

    public void setA(int a) {this.a = a;}
}

能够看到，有一个实例变量 a（堆）, 两个办法 main 和 fun，其中 fun 有一个局部变量 temp（栈）

它们的区别如下所示：

这里简略介绍一下下面的流程

main 办法压入栈中，创立局部变量 live（对象的援用）
创建对象 live，在堆中开拓内存，将 live 放入堆中
live 调用 fun 办法，将 fun 压入栈中（此时 fun 在栈顶）
fun 执行实现，出栈，继续执行 main 办法
最初 main 办法执行实现，也出栈，程序完结

这里可能有敌人要问了，那如果属性是一个援用呢？它要寄存在哪里？

堆

援用寄存在堆里，援用指向的对象也寄存在堆里，只不过是堆的另一个中央

如下图所示：堆中 live 对象的属性 liveRef 指向了另一个对象（live 对象 2）

为啥要先介绍堆和栈呢？

因为堆和栈跟对象的生存非亲非故

如果用人来比作对象的话，那堆就是人的家，栈就是里面的世界

咱们出世在家里，跟里面的世界打交道，最初在家里。。。

生存还是覆灭，这是一个问题。

— 莎士比亚《哈姆莱特》

在 Java 的花花世界中，这也是个问题，不过是个有答案的问题；

答案就在上面。。。

这里咱们先把问题简化

因为咱们最常见的创建对象是通过 new 创立，而 new 对象的外围就是通过构造函数来实现，所以咱们这里简略起见，着重介绍构造函数，其余的前面等到虚拟机局部再介绍

构造函数的分类：

无参构造函数
有参构造函数

构造函数和一般办法的区别：

构造函数没有返回类型
构造函数名与类名统一

对于编译器的默认操作：

如果没有定义构造函数，编译器会默认创立一个无参构造函数
如果子类定义了有参构造函数，且没有显示调用父类的构造函数，则编译器默认调用父类的无参构造函数

当你本人有创立构造函数（无参或有参）时，编译器都不会再去创立构造函数

构造函数的重载：

很罕用，个别用来设置属性的默认值

具体做法就是多个构造函数层层调用（又来套娃了）

上面举个例子：

public class LiveAndDeathDemo {
    private int a;
    private String name;
        
    public LiveAndDeathDemo(){this(1);
    }
    public LiveAndDeathDemo(int a) {this(a, "JavaLover");
    }
    public LiveAndDeathDemo(int a, String name) {
        this.a = a;
        this.name = name;
    }
  // 省略 getter,setter
}

用图示意的话，就是上面这个样子

构造函数的私有化

如果构造函数私有化，那么它要怎么用呢？

私有化阐明只有类自身能够调用，这种次要用在工厂办法中

比方 Java 中的 LocalDate，源码如下：

public final class LocalDate
        implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {
    // 构造函数私有化 
  private LocalDate(int year, int month, int dayOfMonth) {
        this.year = year;
        this.month = (short) month;
        this.day = (short) dayOfMonth;
    }
  // 对外提供一个静态方法，用来创建对象实例
   public static LocalDate of(int year, int month, int dayOfMonth) {YEAR.checkValidValue(year);
        MONTH_OF_YEAR.checkValidValue(month);
        DAY_OF_MONTH.checkValidValue(dayOfMonth);
        return create(year, month, dayOfMonth);
    }
}

这种用法在 LocalDate 这种工具类中用的比拟多，还有就是单例模式（前面设计模式时再介绍）

下面介绍的构造函数没有介绍到父类，上面开始介绍

如果有父类，构造函数的有哪些不一样的中央

this 和 super：

在介绍父类的构造函数之前，有必要介绍下这个 super

this指向以后类
super指向父类

super用来显式调用父类相干属性和办法（包含构造函数）

比方 super.filedA, super.fun() 等

这里有个特例，如果是在子类的构造函数中或者覆写办法中，则间接调用 super()即可调用父类对应的构造函数或办法(上面代码有演示)

构造函数的执行程序

如果子类 Dog 继承父类 Animal，那么会 先调用父类的构造函数 ，再 调用子类的构造函数；
如果父类 Animal 下面 还有父类 ，会持续 往上调用；
下面这个过程就叫做“构造函数链”

这个关系有点像是：子女和父母的关系，子女要想出世，必须先让爷爷奶奶把父母生进去，而后父母能力生子女

所以这里如果咱们要结构子类，必须先结构父类；如果父类还有父类，则持续延长，始终到 Object 超类为止

上面用代码演示下这个层层调用的过程：

public class SuperDemo extends Father{public SuperDemo() {
        // 1.1 这里显示调用父类的构造函数
        // 1.2 Super 必须放在构造函数的第一行
        super();
        System.out.println("sub construct");
    }

    public static void main(String[] args) {SuperDemo demo = new SuperDemo();
    }
}
class Father{public Father() {
        // 2. 这里没有显示调用父类（Object）的构造函数，编译器会本人去调用
        System.out.println("father construct");
    }
}
/** 假如上面这个 Object 就是咱们的超类
class Object{public Object(){// 3. 最终的构造函数，会调到这里为止} 
}
**/

输入如下：

father construct
sub construct

能够看到，先调用父类 Father 的构造函数，再调用子类的构造函数

他们之间的继承关系如下：

图示阐明：

右边的虚线示意层层往上调用，直到超类 Object

左边的实现示意下面的结构实现会回到上面那一层，持续结构，直到以后类

好了，结构的过程大抵就是这个样子了，还有很多其余方面的细节（比方类的初始化等）这里先不介绍了，太多了，放到前面介绍

对象的回收是在程序内存不够用时，将没用的对象（可回收）进行开释的一种操作，这个操作是由垃圾收集器 GC 来实现的

什么是没用的对象？

没用的对象就是可回收的对象

说人话：当指向对象 A 的最初一个援用 ref 隐没时，这个对象 A 就会变成没用的对象，期待着垃圾收集器的回收

那怎么才算援用隐没呢？

根本分为两种状况：

如果援用是局部变量，那当援用所在的办法执行结束时，援用就会被开释，那么该对象随即也就会被标记为没用的对象，期待回收
当援用指向其余对象或者 null 时，该对象会被标记为没用的对象，期待回收

下面都是假如援用是指向对象的最初一个援用的状况，如果有多个援用指向同一个对象，那么要等到援用都隐没，对象才会被标记为可回收，即没用的货色

堆和栈

堆寄存对象，栈用来执行办法并寄存局部变量

对象的创立

次要通过构造函数来创立，比方 new 对象

如果是反序列化来创建对象，则不会结构，因为结构后，对象的属性会被从新初始化，那么序列化的属性值就被抹掉了（后面的 Java 中的 IO 流有波及）

如果子类有父类，则先调用父类的构造函数，如果父类还有父类，则顺次类推，直到 Object 超类

对象的回收

当指向对象的最初一个援用隐没时，这个对象就会变成没用的对象，期待着垃圾收集器的回收

最初，感激大家的观看，谢谢

关于java:Java中对象的生与灭-核心篇

前言

简介

目录

注释

堆 (heap) 和栈(stack)

对象的创立（生）

对象的回收（灭）

总结

后记

Just My Socks（注册教程内含优惠码）

关于java:Java中对象的生与灭-核心篇

前言

简介

目录

注释

堆 (heap) 和栈(stack)

对象的创立（生）

对象的回收（灭）

总结

后记

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）