析构方法说明:

1.析构方法会自动调用
2.析构方法主要用于销毁资源(比如释放数据库的链接，图片资源…销毁某个对象…);
 析构函数会在到对象的所有的引用都被删除或者当对象被显示销毁时执行
3.析构方法调用顺序是，先创建的对象后被销毁
4. 析构方法什么时候被调用
(1) 当程序（进程结束）退出时
(2) 当一个对象称为垃圾对象的时候，该对象的析构方法也会被调用,
(3) 所谓垃圾对象，就是指，没有任何变量再引用它.
(4) 一旦一个对象成为垃圾对象，析构方法就会立即调用

析构方法小结:
①php5加入的的析构方法function __destruct()
②析构方法没有返回值也不接受参数
③主要作用是释放资源的操作，并不是销毁对象本身。
④在销毁对象前,系统自动的调用该类的析构方法
⑤一个类最多只有一个析构方法。
实例：

 <?php
//创建一个人类
class Person {
    //下面是人的成员属性
    public $name; //人的名子
    public $sex; //人的性别
    public $age; //人的年龄
    //定义一个构造方法参数为姓名$name、性别$sex和年龄$age
    public function __construct($name, $sex, $age) {
        //通过构造方法传进来的$name给成员属性$this->name赋初使值
        $this->name = $name;
        //通过构造方法传进来的$sex给成员属性$this->sex赋初使值
        $this->sex = $sex;
        //通过构造方法传进来的$age给成员属性$this->age赋初使值
        $this->age = $age;
    }
    //这个人的说话方法
    function say() {
        echo "我的名子叫：" . $this->name . " 性别：" . $this->sex . " 我的年龄是：" . $this->age . "<br/>";
    }
    //这是一个析构函数，在对象销毁前调用
    function __destruct() {
        echo "再见" . $this->name . "<br/>";
    }
}
//通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄
$p1 = new Person("张三", "男", 20);
$p2 = new Person("李四", "女", 30);
$p3 = new Person("王五", "男", 40);
//下面访问$p1对象中的说话方法
$p1->say();
//下面访问$p2对象中的说话方法
$p2->say();
//下面访问$p3对象中的说话方法
$p3->say();
?>
————————————————
版权声明：本文为CSDN博主「守护那份情」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zjs_csdns/article/details/100085867

运行结果:

我的名子叫：张三 性别：男 我的年龄是：20
我的名子叫：李四 性别：女 我的年龄是：30
我的名子叫：王五 性别：男 我的年龄是：40
再见王五
再见李四
再见张三

"""
析构方法：
释放内存，做释放内存前的准备工作

触发机制：析构方法会在对象被销毁时自动触发
作用：关闭一些开发的资源
注意：是对象被销毁时触发了这个方法，而不是这个方法销毁了对象

对象会在哪些情况下被销毁？
1.当程序执行完毕，内存中的所有资源都会被销毁释放
2.使用del 删除时
3.对象不再被引用时，会自动销毁


创建实例对象时自动被调用：
__new__:创建实例对象
Animal monkey = new Animal()
__init__:初始化数据属性
__del__:析构方法
"""
class Animal:
    """初始化数据属性的方法"""
    def __init__(self,gender,kinds,legs):
        print("初始化方法被调用")
        self.gender = gender
        self.kinds = kinds
        self.legs = legs

    def eat(self):
        print(f"{self.kinds}eating...")

    def __del__(self):
        print("析构方法被调用")

monkey = Animal("wukongSun","猴赛类",4)
monkey.eat()

#3.对象不再被引用时，会自动销毁
Animal("haha","gg",6)
print("析构方法被调用，，，，")

"""
open().close()
通过open().close()，释放open函数的内存
"""
class Open:
    def __init__(self,filePath,mode="r",encode="utf-8"):
        self.file = open(filePath,mode=mode,encoding=encode)

    def write(self):
        temp = input("请输入：")
        self.file.write(temp)

    def __del__(self):
        print("文件流即将关闭，析构方法被调用")
        self.file.close()
#创建了一个实例对象（文件流file）
file = Open("a.txt","w")
file.write()

class Car:
    def __init__(self,brand):
        self.brand = brand
        print(f"{self.brand}被创建")

    def __del__(self):
        print(f"{self.brand}被销毁")


 #1.实例化后调用和销毁的顺序
# baoma = Car("宝马")
# lanbojini = Car("兰博基尼")
# falali = Car("法拉利")

"""
宝马被创建
兰博基尼被创建
法拉利被创建
宝马被销毁
兰博基尼被销毁
法拉利被销毁

"""
#1.实例化后没有被调用和销毁的顺序
Car("宝马")
Car("兰博基尼")
Car("法拉利")

"""
宝马被创建
宝马被销毁
兰博基尼被创建
兰博基尼被销毁
法拉利被创建
法拉利被销毁

"""

在 Java 的 Object 类中还提供了一个 protected 类型的 finalize() 方法，因此任何 Java 类都可以覆盖这个方法，在这个方法中进行释放对象所占有的相关资源的操作。

对象的 finalize() 方法具有如下特点：
垃圾回收器是否会执行该方法以及何时执行该方法，都是不确定的。
finalize() 方法有可能使用对象复活，使对象恢复到可触及状态。
垃圾回收器在执行 finalize() 方法时，如果出现异常，垃圾回收器不会报告异常，程序继续正常运行。

纯文本复制
protected void finalize() 
{
    // 对象的清理工作
}

Counter 类在构造方法中增值，在析构方法中减值。如下所示为计数器类 Counter 的代码：

public class Counter 
{
    private static int count = 0;    // 计数器变量
    public Counter() 
    {
        // 构造方法
        this.count++;    // 创建实例时增加值
    }
    public int getCount() 
    {
        // 获取计数器的值
        return this.count;
    }
    protected void finalize() 
    {
        // 析构方法
        this.count--;    // 实例销毁时减少值
        System.out.println("对象销毁");
    }
}

创建一个带 main() 的 TestCounter 类对计数器进行测试，示例代码如下：

public class TestCounter 
{
    public static void main(String[] args) 
    {
        Counter cnt1 = new Counter();    // 建立第一个实例
        System.out.println("数量："+cnt1.getCount());    // 输出1
        Counter cnt2 = new Counter();    // 建立第二个实例
        System.out.println("数量："+cnt2.getCount());    // 输出2
        cnt2 = null;    // 销毁实例2
        try 
        {
            System.gc();    // 清理内存
            Thread.currentThread().sleep(1000);    // 延时1000毫秒
            System.out.println("数量："+cnt1.getCount());    // 输出1
        }
        catch(InterruptedException e) 
        {
            e.printStackTrace();
        }
    }
}

数量：1
数量：2
对象销毁
数量：1