C#基础——类、构造函数和静态成员

类

类是一个数据类型的蓝图。构成类的方法和变量称为类的成员，对象是类的实例。类的定义规定了类的对象由什么组成及在这个对象上可执行什么操作。

class 类名

{

        (访问属性) 成员变量; 

        (访问属性) 成员函数;

}

访问属性：public（公有的，类中可以直接访问） ,protected受保护的  , private私有的（默认的）（私有的，其他的类中不可以直接访问） 

如下类的示例，描述Box的信息（属性（成员变量）和Box的方法（函数）） 

    class Box
    {
        public int row = 0;
        public int col = 0;
        public int rowBk = 0;
        public int colBk = 0;

        //备份
        public void Backup()
        {
            rowBk = row;
            colBk = col;
        }
        
        //返回备份
        public void Revert()
        {
            row = rowBk;
            col = colBk;
        }
    }

类的使用

 在使用类的成员变量或者函数时，要先检查是否在同一个命名空间下，如果不是需要在开头使用

using + 类所在的命名空间名字

需要先创建一个对象。然后通过对象使用类里面的变量或者方法。

类名 对象名 = new 类名();        //创建对象

对象名.成员变量;                       //引用对象

        static void Main(string[] args)
        {
            Box Box = new Box();        // 声明 Box1，类型为 Box

            Box.row = 5;
            Box.col = 6;

            Box.Backup();
            Console.WriteLine(Box.row + " " + Box.col);
            Console.WriteLine(Box.rowBk + " " + Box.colBk);

            Box.row = 10;
            Box.col = 12;

            Console.WriteLine(Box.row + " " + Box.col);
            Console.WriteLine(Box.rowBk + " " + Box.colBk);
            Box.Revert();
            Console.WriteLine(Box.row + " " + Box.col);
            Console.ReadKey();
        }

构造函数

默认构造函数

new一个对象时，会自动调用构造函数，一般用于初始化操作。如果没有写构造函数，系统会给一个默认的空的构造函数，我们可以在默认构造函数里面对成员变量进行赋初始值。

传参构造函数

当在需要创建新的不同的对象的时候，就需要使用传参构造函数。

    class Box
    {
        public int row = 0;
        public int col = 0;
        public int rowBk = 0;
        public int colBk = 0;
        
        //默认构造函数
        /*public Box()
        {

        }*/
        public Box()
        {
            int row = 0;
            int col = 0;
            int rowBk = 0;
            int colBk = 0;
        }

        //传参构造函数
        public Box(int inRow,int inCol) 
        { 
            row = inRow;
            col = inCol;
            rowBk = inRow;
            colBk = inCol;
        }
    }

        static void Main(string[] args)
        {
            Box Box1 = new Box(5, 6);        // 声明 Box1，类型为 Box
            Box Box2 = new Box(10, 12);        // 声明 Box2，类型为 Box

            Console.WriteLine(Box1.row + " " + Box1.col);
            Console.WriteLine(Box2.row + " " + Box2.col);
            Console.ReadKey();
        }

静态成员

使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本，它们的值可以通过直接调用类而不需要创建类的实例来获取。关键字 static 意味着类中只有一个该成员的实例。

    class Test
    {

        public int Num1 = 0;
        public static int Num2 = 0;
    }
    internal class Program
    {
        static void Main()
        {
            Test num1 = new Test();
            num1.Num1++;
            //num1.Num2++;    //报错
        }
    }

静态成员与普通成员的区别

接下来将对这两种成员进行加1操作，看看他们之间的区别。

以上示例中发现，静态成员不能通过实例化后使用，所以，可以在类中创建相应的接口或者方法（函数）来获取和修改静态成员。还可以直接使用 类名.静态成员 进行调用。

        public void count()
        {
            num2++;
        }
        public int getNum()
        {
            return num2;
        }

            Test.Num2++;      //正确写法

直接让两者加1是看不出区别的，所以，再实例化一个对象出来，在执行加1的操作就可以看出两者的区别了。

    class Test
    {
        public int Num1 = 0;
        public static int Num2 = 0;
        public void count()
        {
            Num2++;
        }
        public int getNum()
        {
            return Num2;
        }
    }
    internal class Program
    {
        static void Main()
        {
            Test num1 = new Test();
            Test num2 = new Test();

            //普通成员
            num1.Num1++;
            num2.Num1++;
            Console.WriteLine(num1.Num1);
            Console.WriteLine(num2.Num1);
            
            //静态成员
            //通过方法使用静态成员
            num1.count();
            num2.count();
            Console.WriteLine(num1.getNum());
            Console.WriteLine(num2.getNum());

            //通过 类名.静态成员 使用
            Test.Num2++;
            Console.WriteLine(Test.Num2);

            Console.ReadKey();
        }
    }

从运行结果中，我们可以看出 Num2 的结果是2，这就意味着，创建的第二个对象没有像普通成员那样重新获取了一次 Num1 的值 ，而是直接获取了被改变了值以后的 Num2。这说明静态成员在对象创建之前就已经存在，后面的操作都是直接对同一数据进行修改，而非修改不同的数据。