【原创】类和对象讲解（持续更新）

da11

//新建一个名为：Wife的类文件
    /// <summary>
    /// 定义一个类，这个类的含义为定义一个“人”的类别（数据类型）
    /// </summary>

    class Wife
    {
        //数据成员
        //统一写上访问级别
        //都是成员变量，在内存的堆中创建
        //private为私有修饰符，一般数据成员都是私有修饰符
        //字段，首字母小写，属性，首字母大写，而且属性必须与字段对应，不能只有属性没有字段

        private string name;    //字段：存储数据（私有修饰符）

        //直接在数据成员中也可以达到类似方法的目的，名称叫“属性”        
        /*
         *属性
         * · 对字段起保护作用，可实现只读、只写功能。
         * · 本质就是对字段的读取与写入方法。
         * · 语法：
         *      【访问修饰符】  数据类型  属性名
         *          {
         *              get { return 字段 ; }     //只读可选项
         *              set { 字段 = value ; }    //只写可选项
         *              //两个都有就是读写都可以
         *          }
         * · 通常一个公有属性和一个私有字段对应。
         * · 属性只是外壳，实际上操作的是私有字段。
         *
         *
         *this关键字
         * · 表示当前对象的引用
         * · 访问当前类成员时，使用this关键字，可以提高代码的可读性
         *   在没有歧义的情况下，也可以省略。
        */
        //注意，在类里面，如果需要进入属性里面的方法查看调试模式，需要在每个方法前加一个断点!
        public string Name      //属性：保护字段（公开修饰符），本质，两个方法
        {
            get                 //读取时保护
            { return name; }
            set                 //写入时保护 value 要设置的数据
            { this.name = value; }
        }

        private string sex;

        private int age;

        public int Age
        {
            get { return age; }
            set
            {
                if (value <= 23)   //判定参数值是否超限
                {
                    this.age = value;
                }
                else
                {
                    //以下语句为抛出异常语句
                    throw new Exception("异常，我不要");
                }
            }
        }

        private int a;

        /*构造函数：提供了创建对象的方式，常常用于初始化类的数据成员。
         * 本质：方法
         * 特殊点1：一个类若没有构造函数，那么编译器会自动提供一个无参数的构造函数。
         * 特殊点2：一个类若具有构造函数，那么编译器不会提供无参数的构造函数。
         * 特殊点3：没有返回值（也不能写void）、与类名同名
         * 特殊点4：不能被直接调用，必须通过new运算符在创建对象时才会自动调用。
         * 可以理解为： 构造函数就是new对象的方式。
         * · 语法：
         *      【访问修饰符】  类名（【参数列表】）
         * 构造函数创建多少个看需求，没有规定一个类只能创建几个构造函数。
        */
        public Wife(string name,int age):this(name)//调用有参数的构造函数，形参还是要有
        {     
            this.Age = age;
        }

        public Wife(string name):this()//调用无参数的构造函数
        {
            this.name = name;//注：构造函数如果为字段赋值，属性中的代码块不会执行（如在属性中的判断）
        }

        //构造函数也可以像方法一样，可以重载，以下这个等于编译器默认送的构造函数
        //如果不想在这个类外面创建对象，构造函数前面的修饰符要变成私有修饰符private
        //简称构造函数私有化
        public Wife()
        {
            Console.WriteLine("成功调用构造函数");
        }

        //方法成员
        //public为公开的，一般方法成员都是公有的
        public void SetName(string name)
        {
            //方法内部，是局部变量，在内存的栈中创建
            int a = 1;  //成员变量与局部变量可以重名
            Console.WriteLine(a); //访问的a为上一行的a，因为就近原则
            Console.WriteLine(this.a);  //加上this代表是对象的引用，所以访问的是对象定义的a
            //this 代表这个对象（引用）
            this.name = name;
        }

        public string GetName()
        {
            return this.name;
        }

        public void SetAge(int age)
        {
            if (age <= 23)
            {
                this.age = age;
            }
            else
            {
                throw new Exception("异常，我不要");
            }
        }

        public int GetAge()
        {
                return this.age;
        }

        /*总结-类结构
         * 访问级别  class  类名
         * {
         *      字段：存储数据
         *      属性：保护字段
         *      构造函数：提供创建对象的方式，初始化类的数据成员
         *      方法：向类的外部提供某种功能。
         * }
         *
         *
         */

    }

分割线

//主程序cs文件
        /*类和对象
         * · 面向对象：一种软件开发的思想，指导程序员如何分析、解决问题。
         * · 类是一个抽象的概念，即为生活中的“类别”。（重点）
         *      -名词类型的共性，作为数据成员。
         *      （需要用变量存储的、数据的就是数据成员。如Console.Title="123";）
         *      
         *      
         *      -动词类型的共性，作为方法成员。
         *      （行为的,如Console.Write("123");）
         *
         * · 对象是类的具体实例，即归属于某个类别的“个体”。
         *      例如：学生是一个类，表示一种类型，“八戒同学”则是一个对象。
         *
         * 中间插入变量的另外一种：成员变量（之前的是局部变量）
         *成员变量
         * · 定义在类中方法外的变量
         * · 特点：
         *      - 具有默认值
         *      - 所在类被实例化后，存在堆中，对象被回收时，成员变量从堆中清楚。
         *      - 可以与局部变量重名。
         * · 值类型与引用类型：
         *      - 值类型：声明在堆中，数据存储在堆中。
         *      - 引用类型：声明在堆中，数据存储在堆的另一块空间中。
         *
         *
         *创建类
         * · 语法：
         *   访问级别  class  类名（类名首字母要大写）
         *   ｛
         *          类成员(数据成员、方法成员)......
         *    ｝
         *
         * · 通常每个类都在一个独立的cs源文件中。
         * · 创建新的类意味着在当前项目中产生了一种新的数据类型。
         *
         *创建对象
         * · 语法：
         *   类名  引用名；
         *   引用名 = new  构造函数（参数列表）;
         * · 创建对象的过程也称为“实例化”。
         *
         *
         */


        static void Main(string[] args)
        {
            //创建对象的声明(声明Wife类型的引用)
            //注意：为实例化前的创建对象，引用名为null（空）
            Wife wife01;

            //指向Wife类型的对象（实例化Wife类型对象）
            //实例化之后，引用名在栈上就有对象的引用存储了
            //在实例化时，在内存堆中开辟的空间，取决于类里面有多少个数据成员！
            wife01 = new Wife();


            wife01.SetName("123");
            string str1 = wife01.GetName();
            wife01.SetAge(190);


            int int1 = wife01.GetAge();
            Console.WriteLine(str1);
            Console.WriteLine(int1);
            Console.ReadLine();


            Wife Wife02;
            Wife02 = new Wife();
            Wife02.Name="jxm";                  //调用Wife类的Name的Set属性，直接赋值
            Console.WriteLine(Wife02.Name);     //调用Wife类的Name的Get属性，返回数据
            Wife02.Age = 19;                    //调用Wife类的Age的Set属性，直接赋值
            Console.WriteLine(Wife02.Age);      //调用Wife类的Age的Get属性，返回数据
            Console.ReadLine();

            Wife wife03;
            wife03 = new Wife("jxmm",19);  //使用自建的构造函数实例化
            Console.WriteLine(wife03.Name+" "+wife03.Age);
            Console.ReadLine();

        }