构造函数:

基本概念:

作用:

实例化对象,

调用函数,

初始化成员变量.

结构体和class构造函数对比

类是可以声明无参构造函数,但结构体必须有参数:

    class Person
    {
        public int Id;
        public Person() 
        {
            Id = 1;
        }
    }
    struct Person2 
    {
        public int Id;
        public Person2(int a) {
            Id = a;
        }
    }

结构体必须要把所有字段初始化,但class甚至可以一个都不初始化:

js

    class Person
    {
        public int Id;
        public string Name;
        public Person() 
        {
            
        }

    }
    struct Person2 
    {
        public int Id;
        public string name;
        public Person2(int a) {
            Id = a;
            name = "leemoon";
        }
    }

class构造函数可以重载,结构体就不可以.

    class Person
    {
        public int Id;
        public string Name;
        public Person() 
        {
        }
        public Person(int a) 
        {
        }
    }

构造函数特殊写法:

通过对比来观察：

        public int Id;
        public string Name;
        public Person() {
            
        }//无参的构造函数
        public Person(int id)
        {
            Id = id;
        }//一个参数的构造函数（构造函数重载）
        public Person(int id, string name)
        {
            Id = id;
            Name = name;
        }//两个参数的构造函数。

特殊写法：

        public Person(string id):this()
        {
            Id = id;
        }//后面的this会调用第一个无参的重载构造函数。
        

        public Person(int id, string name)：this（id）
        {
            Id = id;
            Name = name;
        }//这样则是调用，一个参数的重载函数。也就是第二个重载函。参数是从前面的int id传入this的id.
                public Person(int id, string name)：this（id+10）
        {
            Id = id;
            Name = name;
        }
        this里的参数甚至还可以拿来运算。

现在有个问题：如果是无参数的重载构造函数想调用有参呢？

        public Person() ：this（10，"leemoon"）
        {
            
        }//因为前面部分不能传入参数所以，可以在this里设置一个常量的默认参数。

析构函数：(了解,因为,C#存在垃圾回收机制.)

起到一个承上启下的作用：

用法
    class Person 
    {
        public int Id;

        ~Person() 
        {
        }//析构函数
    }

当我:

Person p = new Person();
p=null;

也就是p里面没了地址,此时内容new Person(),也就成了垃圾,但并不会调用析构函数 因为还没触发垃圾回收.

所以:析构函数是当垃圾被回收时自动调用的一个函数.

垃圾回收机制

概念:

算法:

原理:

从上面也能看出来,GC是一种被动的方法. 当然我们也能用GC.collect; 很明显看出来是 :类名.函数 所以GC是一种class

但我们不会经常主动调用这个方法,因为会损耗性能.

一般是loading过场景的时候,因为这个时候本来就会让玩家等待,

刚好使用这个间隙.

练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GC
{
    class Ticket
    {
        public int distance=300;
        public Ticket() { }
        
        public double GetPrice(double price)
        {
            price = 1;
            if (distance <= 100)
            {
                price=0.95;
            }
            else if (distance <= 200)
            {
                price = 0.9;
            }
            else if (distance <= 300)
            {
                price = 0.95;
            }
            else
            {
                price = 0.95;
            }
            return price*distance;
            
        }
        public void Show() {
            
            Console.WriteLine($"{distance}公里,花费{GetPrice(1)}元");
        }
    }
    
    internal class Program
    {
        
        static void Main(string[] args)
        {
            Ticket ticket = new Ticket();
            ticket.Show();
        }
    }
}