C#重载、构造函数、析构函数、readonl、const

• 方法的重载：在同一作用域中，有多个方法的方法名相同，但参数列表不同。参数列表不同包括：参数的个数，类型，顺序

        static void Main(string[] args)//主方法
        {
            Print();
            Print(12);
            Print(12,12);
            Print("faaf");
            Print("asdf", 15);
            Print(17,"sdgg");
            Random rand = new Random();
            int a = rand.Next();
            Console.WriteLine(a);
        }
        
        public static void Print()
        {
            Console.WriteLine("方法的重载1");
        }
        public static void Print(int a)
        {
            Console.WriteLine("方法的重载2"+a);
        }
        public static void Print(int a,int b)
        {
            Console.WriteLine("方法的重载3"+a+b);
        }
        public static void Print(string a)
        {
            Console.WriteLine("方法的重载4"+a);
        }
        public static void Print(string a,int b)
        {
            Console.WriteLine("方法的重载5"+a+b);
        }
        public static void Print(int a, string b)
        {
            Console.WriteLine("方法的重载6" + a + b);
        }
    }

• 构造函数:创建一个类对象，编译器会自动调用构造函数来初始化对象

构造函数的声明和调用：
        static void Main(string[] args)
        {
            person P = new person("构造函数",200);
            P.print();
        }
    class person
    {
        private string name;
        private int age;
        public person(string n,int a) {
            name = n;
            age = a;
        }
        public person(string n = "构造函数带参数且有默认值", int a = 300) {
            name = n;//有这两句输出：构造函数，200
            age = a;//没有输出： ，0（默认值）
        }
        public void print()
        {
            Console.WriteLine("{0}{1}",name,age);
        }
    }        

• 默认构造函数：如果在类中没有包含任何一个构造函数，那么编译器会自动提供一个空的构造函数。

1. 不带参数 public person(){...}
2. 带参数但参数都有默认值
3. 带参数没有默认值

• 构造函数特点：

1. 一个类中可以包含多个构造函数---构造函数的重载
2. 默认构造函数
3. 构造函数名和类名一致
4. 构造函数无返回值
5. 构造函数一般为公有的

• 静态构造函数：用于初始化静态数据成员

1. 静态构造函数不能有访问修饰符和参数
2. 静态构造函数只会被调用一次
3. 静态构造函数不能访问实例成员。 //静态成员是需要通过static关键字来修饰的，而实例成员不用static关键字修饰。
4. 静态构造函数无法直接调用
5. 静态构造函数在创建第一个实例或者在引用任何静态成员之前被调用

        static void Main(string[] args)
        {
            student s = new student("普通学生", 100);
            s.print();
            student s1 = new student("普通学生", 100);
            s1.print();
        }
        //静态构造函数被调用
        //普通学生，100，静态构造
        //普通学生，100，静态构造
    class student
    {
        private static string name;
        private int age;
        private static string teachername;
        //public static string tN { }
        //public student(string n, int a,string ta) { name = n; age = a;teachername = ta; }
        public student(string n, int a) { name = n;age = a; }
        static student()//静态构造方法
        {
            teachername = "静态构造";
            Console.WriteLine("静态构造函数被调用");//只会被调用一次
        }
        public void print() { Console.WriteLine("{0},{1},{2}", name, age, teachername); }
    }        

• 析构函数:用于在对象被销毁之前释放对象所使用的托管和非托管资源。对于C#中的大部分对象，可以使用GC来隐式的执行内存管理任务。但是若封装了非托管资源对象，在应用程序使用完这些非托管资源之后，垃圾回收器将运行对象的析构函数来释放这些资源

特点：

1. 能在结构体中定义，只能在类中定义
2. 一个类只能有一个析构函数
3. 无法继承或重载析构函数
4. 无法显示的调用析构函数，由垃圾回收器自动调用
5. 没有访问修饰符也没有参数

        static void Main(string[] args)
        {
            xigou x = new xigou();
        }
    class xigou
    {
        public xigou() { Console.WriteLine("构造函数被调用"); }//构造函数
        ~xigou(){ Console.WriteLine("析构函数被调用"); }//析构函数
    }        

readonl:

1. 可以在声明时初始化,也可以在构造函数中初始化
2. 只能修饰类成员

const:

1. 必须在声明时初始化
2. 可以修饰类成员，也可以修饰方法成员

    class personn
    {
        private string name;
        private readonly int age = 6;
        private const int id = 1;
        public personn(string n, int a) { name = n;age = a; }
        public void print()
        {
            Console.WriteLine("{0},{1},{2}",name,age,id);
        }
    }