C#面向对象编程的学习笔记

所有东西都是对象：变量和方法的集合。

初级特性：最基本的概念，即类和对象；

中级特性：最核心的概念，即封装、继承和多态；

高级特性：由初级特性和中级特性引出的一些问题，如构造函数的使用、覆盖的规则、静态变量和函数等；

• 类是一个样板，以操作、表示和算法的形式完整地定义了一组对象的行为。它通常也是面向对象语言中的模块化、封装和数据抽象的基础；
• 对象是类的一个实例，是一个软件单元，它由一组结构化的数据和在其上的一组操作构成；

类：C#所有的代码都是在某一个类中，因此不可能在类之外的全局区域有变量和方法；

对象：C#中的对象相当于一块内存区域，保存对象特有的类中所定义的数据；

引用：C#中对于对象的操作全部通过引用进行；

声明一个类： class 类名 {变量声明，方法声明} ，如class Student {long id;  char  gender;…}

声明一个对象引用： 类名 引用名，如Student student；

创建一个对象：new 类构造函数，如student =new Student（）；缺少这一步，编译器会报错；类的实例化；

使用对象： 引用名.变量名/方法名（参数），如student.id=22222;

https://www.cnblogs.com/xiaoyehack/p/9204985.html

类的成员，可以包含常量、字段、类型、方法、属性、事件、构造函数…

举例如下，声明一个类，一般包含属性、构造函数和方法

    class CNCOperate
    {
        #region 属性
        public CNCTag Tag;
        public string Ip { set; get; }
        public ushort Port { set; get; }
        public int Timeout { set; get; }
        /*用Public则外部可访问，若不需外部访问，也可以按照下面方式进行编写定义*/
        private ushort h;
        #endregion

        #region 构造函数
        public CNCOperate(string ip, string port, string timeout)
        {
            Ip = ip;
            Port = Convert.ToUInt16(port);
            Timeout = Convert.ToInt32(timeout);
            Tag = new CNCTag();
        }
        #endregion

        #region 方法
        public int Connect() /*连接机床*/
        {
            int ret = Focas1.cnc_allclibhndl3(Ip, Port, Timeout, out h);
            return ret;
        }
        #endregion
    }

在别的程序中，引用类的方法，类的实例化（创建一个对象）

            //类的实例化1
            CNCOperate operate1;
            operate1 = new CNCOperate(ip, port, timeout);

            //类的实例化2
            CNCOperate operate2 = new CNCOperate(ip, port, timeout);

关于类的一些说明，类的成员可以包含下述部分

常量：表示与该类相关联的常量值。
字段：即该类的变量。
类型：用于表示一些类型，它们是该类的局部类型。
方法：用于实现可由该类执行的计算和操作。
属性：用于定义一些命名特性，通过它来读取和写入相关的特性。
事件：用于定义可由该类生成的通知。
索引器：使该类的实例可按与数组相同的（语法）方式进行索引。
运算符：用于定义表达式运算符，通过它对该类的实例进行运算。
实例构造函数：用于规定在初始化该类的实例时需要做些什么。
析构函数：用于规定在永久地放弃该类的一个实例之前需要做些什么。
静态构造函数：用于规定在初始化该类自身时需要做些什么。

关于字段的部分说明：

使用static关键字修饰的就是静态字段，静态字段属于类而不属于某个类实例，对它的访问使用“类名.静态字段名” ，不能使用“对象名.静态字段名”的格式。

当字段声明中包括readonly修饰符时，该字段成为只读字段。只能在声明只读字段的同时赋初值。其他任何时候都不允许为只读字段赋值。如，public readonly int readNum = 100;

关于属性的部分说明：

属性主要用于描述和维护类对象的状态。从客户端看，对属性的访问就好像直接访问public字段成员，但在类内部是通过类方法访问的。 创建一个属性包括两步：
1.声明一个字段来存储属性值
2.编写一个属性声明，提供访问接口，语法如下：
private 类型名 私有字段
[访问修饰符] 类型名 属性名
{ get
{ return 私有字段; }
set
{ 私有字段 = value; }
}

通过属性进行数据初始化的案例：

        public class Student3
        {
            private int no;
            public int No
            {
                get { return no; }
                //set { no = value; } //不带数据预处理
                set { if (value > 0) no = value; else no = 0; }
            }
        }

        private void button10_Click(object sender, EventArgs e)
        {
            Student3 st1 = new Student3();
            st1.No = 20;
            richTextBox1.AppendText(st1.No.ToString() + "\r"); //显示结果 20

            st1.No = -20;
            richTextBox1.AppendText(st1.No.ToString() + "\r"); //显示结果 0
        }
    }

可以创建只读或只写属性，即只有get或set方法。
可以创建静态属性，用static关键字。
静态属性不与特定实例有关联，因此在静态属性的get和set方法内引用this是错误的。
静态属性使用类名访问，并且，与静态属性相配合的私有字段也应该是静态的。

        public class checkVal
        {
            private static string p_time = "00-00"; //静态私有字段
            public static string my_time //静态属性
            {
                get { return p_time; }
            }

            public static string your_time //静态属性
            {
                set { p_time = value; }
            }
        }

        private void button10_Click(object sender, EventArgs e)
        {
            richTextBox1.AppendText(checkVal.my_time + "\r");
            checkVal.your_time = "10-20";
            richTextBox1.AppendText(checkVal.my_time + "\r");
          //richTextBox1.AppendText(checkVal.your_time +"\r"); //这个写法会报错，提示缺少get访问器
        }

关于构造函数的说明

构造函数是一种用于对象初始化的特殊方法，有以下特点。
–构造函数只能在对象创建时调用，即和new运算符一起被调用。
–构造函数和类具有相同的名字。
–构造函数可以有0个、1个或多个参数。
–构造函数没有返回值。
–每个类至少有一个构造函数，一个类可以有多个构造函数。
–如果没有为类定义构造函数，系统会自动为其定义一个缺省的构造函数。缺省构造函数不带参数，作用是将实例变量都清零。
–一旦为类定义了构造函数，则系统不会再为其定义缺省构造函数。

类的构造函数也可通过关键字this调用同一个类的另一个构造函数

        public class Dog
        {
            long id;
            char gender;
            int classID;
            public Dog():this(0,'F',5)  //构造函数
            { }
            public Dog(long aID, char aGender, int aClassID)  //构造函数
            {
                id = aID;
                gender = aGender;
                classID = aClassID;
            }
            public int mmm()
            {
                return classID;
            }
        }

        private void button9_Click(object sender, EventArgs e)
        {
            Dog dog1 = new Dog();       //没输入参数的将采用构造函数中的默认参数
            Dog dog2 = new Dog(2,'N',3);
            Dog dog3 = new Dog();

            richTextBox1.AppendText(dog1.mmm().ToString() + "\r"); //运行结果5
            richTextBox1.AppendText(dog2.mmm().ToString() + "\r"); //运行结果3
            richTextBox1.AppendText(dog3.mmm().ToString() + "\r"); //运行结果5
        }

静态变量说明

静态变量是在所有类的实例(对象)中共享的变量，在变量声明中用static关键字表示。 类变量可以被标记为public或private。如果被标记为public，不需要类的实例就可以访问。

        public class Student
        {
            public int serialNum;
            private static int counter = 0;
            public static int counterPub = 10;
            public Student()
            {
                serialNum = counter;
                counter++;
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            Student stu1 = new Student();
            Student stu2 = new Student();

            richTextBox1.AppendText(stu1.serialNum.ToString() + "\r");  //运行结果0
            richTextBox1.AppendText(stu2.serialNum.ToString() + "\r");  //运行结果1
            richTextBox1.AppendText(Student.counterPub.ToString()+"\r");//运行结果10

        }

静态方法说明

静态方法是不需要类的任何实例就可以被调用的方法，在方法声明中用static关键字表示。
类方法只能访问静态变量，访问非静态变量的尝试会引起编译错误。
静态方法不能被覆盖成非静态的。
main是静态的，因为它必须在任何实例化发生前被访问，以便应用程序的运行。

        public class GenFunction
        {
            private static int z = 10; //静态变量
            public static int AddUp(int x,int y) //静态方法
            {
                return x + y + z;
            }
        }

        private void button6_Click(object sender, EventArgs e)
        {
            int c = GenFunction.AddUp(5, 10); //运行结果25
            richTextBox1.AppendText(c.ToString() + "\r");
        }

静态构造函数

静态构造函数在类中第一个对象初始化或引用任何静态成员之前执行。

静态构造函数用于初始化类。在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数来初始化类。
静态构造函数既没有访问修饰符，也没有参数。 无法直接调用静态构造函数。 在程序中，用户无法控制何时执行静态构造函数。
静态构造函数的典型用途是：当类使用日志文件时，将使用这种构造函数向日志文件中写入项。

        public class People
        {
            public int serialNum;
            private static int counter;
            static People() //静态构造函数
            {
                Random rand = new Random(0);
                counter = rand.Next(0, 1000);
            }
            public People() //构造函数
            {
                serialNum = counter;
                counter++;
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            People peop1 = new People();
            People peop2 = new People();
            People peop3 = new People();

            richTextBox1.AppendText(peop1.serialNum.ToString() + "\r");
            richTextBox1.AppendText(peop2.serialNum.ToString() + "\r");
            richTextBox1.AppendText(peop3.serialNum.ToString() + "\r");
        }

 私有构造函数

在某些特殊的情况下，使用私有构造函数能够达到意想不到的效果。比如，想建立这样一个类：不允许被其他类实例化，但提供对外的静态接口成员。在.NET框架类库中就存在这样的类，如System.Math类就不能够实例化，它的所有成员都是静态的。 用关键字private修饰的构造函数就是私有构造函数。

        public class filling
        {
            private filling() { }  //私有构造函数
            public static string happy()
            {
                return "哈哈哈哈";
            }
        }
        private void button8_Click(object sender, EventArgs e)
        {
            richTextBox1.AppendText(filling.happy());
        }