C#构造函数、析构函数、垃圾回收机制、静态类和静态该构造函数、常量(const)、只读变量(readonly)、

•构造函数：

基本概念: 在实例化对象时 会调用的初始化的函数 如果不写 默认存在 一个无参构造函数

写法:

1.没有返回值 可以重载 2.函数名 必须和 类名 相同 3.有无参数都行 4.如果申明了构造函数 那么必须在其中对所有变量数据初始化 5.没有特殊要求时 一般都是public的 6.this代表当前调用该函数的对象自己

internal class Program
{
    static void Main(string[] args)
    {            
        People people = new People(10, "张","女");
        people.Test();
    }   
}
//构造函数 就是 当你用 new 创建对象时，构造函数会 自动执行，帮你 初始化对象的 属性
//特点：名字 和 类 完全一样   没有返回值  可以有参数（也可以无参数）
//作用：初始化实例属性的

class People
{
    //变量
    public int Id { get; set; }
    public string Name { get; set; }
    public string Sex { get; set; }
    //构造函数
    public People()
    {
        Console.WriteLine("构造函数实施了"); 
        //因为构造函数是在对象创建的时候执行，因此在这里访问不到对象后续赋值的属性值，访问到的是默认值
        Console.WriteLine(Name);
        Console.WriteLine(Id);
    }
    //构造函数本身也是函数，可以定义形参接收参数
    //构造函数 不需要 也不能写返回值
    public People(int id,string name) 
    {
        //构造函数的作用：用于在创建对象的时候进行初始化操作
        this.Id = id;
        this.Name = name;
    }
    public People(int id, string name,string sex) 
    {
        this.Id = id;
        this.Name = name;
        this.Sex = sex;
    }
    //方法
    public void Test()
    { Console.WriteLine($"姓名{Id},年龄{Name},性别{Sex}"); }
}
//可以通过this 重用构造函数代码
//访问修饰符  构造函数名(参数列表) :this(参数1,参数2...)

•析构函数：

基本概念:

当引用类型的堆内存被回收时，会调用该函数

对于需要手动管理内存的语言(比如c++)，需要在析构函数中做一些内存回收处理

但是C#中存在自动垃圾回收机制GC

所以我们几乎不会怎么使用析构函数。除非你想在某一个对象被垃圾回收时，做一些特殊处理

基本语法: ~类名(){}

internal class Program
{
    static void Main(string[] args)
    {
        //C#中不支持显式调用析构函数,而是由垃圾回收器在对象销毁时自动调用
        People p1 = new People() { Name = "张三" };
        People p2 = new People() { Name = "李四" };
        p1 = null;
        People p3 = p2;
        p3 = null;
        p2 = null;
        Console.ReadLine();
        //强制启动垃圾回收
        GC.Collect();
    }
}
class People
{
    public string Name { get; set; }
    //析构函数的定义: 一个和类命相同的方法,前面加上一个~
    //基本语法:   ~类名(){}
    ~People()
    { Console.WriteLine($"{Name}即将被回收"); }
}

•垃圾回收机制：

//垃圾回收，英文简写Gc(Garbage collector)
//垃圾回收的过程是在遍历堆(Heap)上动态分配的所有对象
//通过识别它们是否被引用来确定哪些对象是垃圾，哪些对象仍要被使用
//所谓的垃圾就是没有被任何变量，对象引用的内容
//垃圾就需要被回收释放
​
//垃圾回收有很多种算法，比如
//引用计数(Reference counting)
//标记清除(Mark sweep)
//标记整理(Mark compact)
//复制集合(copy collection)
​
//注意:
//GC只负责堆(Heap)内存的垃圾回收
//引用类型都是存在堆(Heap)中的，所以它的分配和释放都通过垃圾回收机制来管理
​
//栈(stack)上的内存是由系统自动管理的
//值类型在栈(stack)中分配内存的，他们有自己的生命周期，不用对他们进行管理，会自动分配和释放
​
//C#中内存回收机制的大概原理
//0代内存  1代内存  2代内存
//代的概念:
//代是垃圾回收机制使用的一种算法(分代算法)
//新分配的对象都会被配置在第0代内存中
//每次分配都可能会进行垃圾回收以释放内存(0代内存满时)
​
//在一次内存回收过程开始时，垃圾回收器会认为堆中全是垃圾，会进行以下两步//1.标记对象 从根(静态字段、方法参数)开始检查引用对象，标记后为可达对象，未标记为不可达对象
//不可达对象就认为是垃圾
//2.搬迁对象压缩堆(挂起执行托管代码线程) 释放未标记的对象 搬迁可达对象 修改引用地址
​
//大对象总被认为是第二代内存 目的是减少性能损耗，提高性能
//不会对大对象进行搬迁压缩85080字节(83kb)以上的对象为大对象

•静态成员：关键字 static

用static修饰的成员变量 成员方法 成员属性等 就称为静态成员

静态关键字 static 修饰成员变量 方法 属性

静态成员的特点: 直接用类名点出使用

静态成员的作用: 提供了一种不需要实例化对象,就可以访问类成员的一种方式

静态成员和非静态成员之间的区别:

1.访问方式不同 非静态成员: 实例化对象.成员名称 静态成员: 类名.成员名称

2.存储位置不同 非静态成员: 存储在实例化对象上,每个对象都有一份 静态成员: 存储在类上,所有实例共享一个成员

internal class Program
{
    static void Main(string[] args)
    {
        People people = new People();
        //非静态成员访问:通过nuw出来的实例化对象进行访问
        people.Name1 = "我是郝文涌";
        people.Test1();
        //类名.成员名称  访问静态成员
        People.Name2 = "我吃shi";
        People.Test2();
        people.Test1();
    }
}
class People
{
    //非静态成员:
    public string Name1 { get; set; }
    //非静态方法:
    public void Test1()
    {
        Console.WriteLine("这是非静态方法Test1");
        Console.WriteLine(Name1);
        //在非静态的方法中，可以访问所有的类成员
        Console.WriteLine(Name2);
        Test2();
    }
    //静态成员:
    public static string Name2 { get; set; }
    //静态方法:
    public static void Test2()
    {
        Console.WriteLine("这是静态方法Test2");
        //在类的静态方法中,只能访问静态的类成员
        //Console.WriteLine(Name1);
        Console.WriteLine(Name2);
        Test3();
    }
    //静态方法:
    public static void Test3()
    { Console.WriteLine("这是静态方法Test3"); }
}

•常量const和只读变量readonly：

const(常量)可以理解为特殊的static(静态)

相同点 他们都可以通过类名点出使用

不同点 1.const必须初始化，不能修改 static没有这个规则

2.const只能修饰变量、static可以修饰很多

3.const一定是写在访问修饰符后面的，static没有这个要求

internal class Program
 {
     static void Main(string[] args)
     {
         Test t1 = new Test();
         //t1.a = 222;
         Console.WriteLine(t1.a);
         //Console.WriteLine(t1.c);
         Console.WriteLine(Test.c);
     }
 }
 class Test 
 {
     // 类的字段可以添加一个readonly 表示这个字段为只读
     // 这个字段只能被构造函数修改，构造函数以外的地方不可以进行修改
     public readonly int a = 1;
     //静态的readonly字段只能在静态的构造函数中修改
     public  static readonly int b = 1;
     //常量,给字段加一个const关键字,表示这个字段为常量,不能修改值
     //自动将字段修改为静态的 也只能是静态的
     public const int c = 1;
     //属性为只读,直接删除set就可以了,一般属性的只读会搭配一个私有字段一起使用
     private string e = "1";
     public string D { get => e; }
     public Test()
     { a= 2; }
     static Test()
     { b= 2; }
 }

•静态类static和静态构造函数：

静态类概念: 用static修饰的类

特点: 只能包含静态成员变量/属性/方法 不能被实例化

作用: 1.将常用的静态成员写在静 态类中 方便使用 2.静态类不能被实例化，更能体现工具类的 唯一性 比如 console就是一个静态类

静态构造函数概念: 在构造函数加上 static 修饰

特点: 1.静态类和普通类都可以有 2.不能使用访问修饰符 3.不能有参数 4.只会自动调用一次(当你第一次使用这个类里面的内容的时候)

作用: 在静态构造函数中初始化 静态变量

internal class Program
 {
     static void Main(string[] args)
     {
         Console.WriteLine(Staticclass.testInt); 
         Console.WriteLine(Staticclass.testInt2);
         Console.WriteLine(Staticclass.testInt);
         Console.WriteLine(Test.testInt); 
         Test t = new Test(); Test t2 = new Test();
     }
 }
 //使用
 //1.静态类中的静态构造函数
 static class Staticclass
 {
     public static int testInt = 100;
     public static int testInt2 = 100;
     static Staticclass()
     {
         Console.WriteLine("静态构造函数");
         testInt = 200;
         testInt2 = 300;
     }
 }
 //2.普通类中的静态构造函数
 class Test
 {
     public static int testInt = 200;
     static Test()
     { Console.WriteLine("静态构造函数"); }
     public Test()
     { Console.WriteLine("普通构造函数"); }
 }