C#面向对象编程-类和对象（2）

方法的使用

类与对象

类的定义

类是一种数据结构，可以包含数据成员(常域和字段)、函数成员(方法、属性、事件、索引器、运算符、实例构造函数、静态构造函数和析构函数)以及嵌套类型。
C#中一切类型都为类，除了引用的命名空间外，所有的语句都必须位于类(或者结构)内，不存在任何处于类(或结构)之外的语句。因此，类是C#语言的核心和基本构成模块。默认代码中包含一个Program类。
类定义的语法结构如下：
<访问修饰符> class <类名> { 类成员（字段、属性、方法、事件）}

类的实例化

类的实例化就是创建一个真实的对象。可通过使用new关键字，后跟对象要基于的类的名称。
实例化对象的语法格式如下：
<类名> <对象名> = new <类名>([构造函数的参数])
比如定义一个关于人类的类，而具体的某一个人，就是人类的实例,从类到类的实例的这个过程，叫类的实例化。例如：
Person p = new Person();
(1) 把定义好的类当作类型来使用，称为引用类型。如果声明引用类型的变量，此变量就会一直包含值null。例如：
Person p; //引用类型的变量p是一个null值
(2) 使用new运算符能显式创建出类的实例。例如：
Person p = new Person(); //创建对象p
或者为引用类型的变量分配已在其他位置创建的对象，例如：
Person p2= p;

类的成员

类具有表示其数据和行为的成员。类的成员包括在类中声明的所有成员，以及在该类的继承层次结构中的所有类中声明的所有成员(构造函数和析构函数除外)。基类中的私有成员被继承，但不能从派生类访问。类的成员如下表所示。

字段的使用

字段是在类或结构中直接声明的任意类型的变量。通常字段是用来存放数据，它可以存放多个值，而变量只能存放一个值。字段的命名规范采用的是cameCase，为了与变量区分，最好在前面加一个下划线“_”。

1. 声明字段
   声明字段时，可以使用赋值运算符为字段指定一个初始值。
   例如，为_day字段赋值“Monday”：
2. 访问字段
   若要访问对象中的字段，需要在对象名称后添加一个句点，后跟字段的名称。

using System;
namespace Project10
{
    enum Gender//将性别最好声明为一个枚举
    {
        男,
        女
    }
    class Clerk
    {
        public string _name;  //姓名
        public Gender _gender;   //性别
        public int _age;       //年龄
        public string _department;  //部门
        public int _workYears;  //工作年限
        public void Write()    //定义非静态方法
        {
            Console.WriteLine("我叫{0}，我是{1}生，我{2}岁了，我在{3}任职，我工作了{4}年", _name, _gender, _age, _department, _workYears);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //将类实例化
            Clerk zs = new Clerk();
            zs._name = "张三";
            zs._gender = Gender.男;
            zs._age = 25;
            zs._department = "人力部";
            zs._workYears = 5;
            zs.Write();  //调用非静态方法 
            Clerk ls = new Clerk();
            ls._name = "李四";
            ls._gender = Gender.女;
            ls._age = 35;
            ls._department = "财务部";
            ls._workYears = 3;
            ls.Write();  //调用非静态方法
            Console.WriteLine(zs._name);   //字段
            Console.WriteLine(ls._name);
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示了字段的使用。在代码中，首先自定义一个关于职员的类Clerk，并且在该类中声明了五个字段和一个非静态的方法；接着，在类Program中的Main方法里，将类Clerk进行实例化；然后创建两个对象，分别为zs和ls；最后使用对象名，为每个字段进行赋值并输出。

我叫张三，我是男生，我25岁了，我在人力部任职，我工作了5年
我叫李四，我是女生，我35岁了，我在财务部任职，我工作了3年
张三
李四

字段是在类或结构中直接声明的任意类型的变量。通常情况下，应仅对具有private或protected可访问性的变量使用字段。

属性

使程序员可以创造新的声明性信息的种类，称为属性。属性是对现实世界中实体特征的抽象，是为访问自定义类型的注释信息提供通用的访问方式。
属性是字段的自然扩展。属性和字段都是类的成员，都具有相关的类型，并且用于访问字段和属性的语法也相同。然而，与字段不同是属性不会被归类为变量。因此，不能将属性作为ref或out参数传递。但是，属性有访问器，这些访问器指定在它们的值被读取或写入时需执行的语句。
对于类的实现者来说，属性是两个代码块，表示get访问器和set访问器。读取属性时，执行get访问器的代码块；向属性赋予新值时，执行set访问器的代码块。将不带set访问器的属性视为只读。将不带get访问器的属性视为只写。将具有以上两个访问器的属性视为读写。

using System;
namespace Project11
{
    public class Clerk    //创建一个员工的类
    {
        private string _name = "张三"; //定义string类型的字段，用来记录员工姓名呢
        private int _age;     //定义int类型的字段_age，用来记录员工年龄
        public int Age         //用户定义年龄属性，该属性用于对输入的年龄进行限定
        {
            get
            {
                return _age;
            }
            set     //可以用于对赋值进行限定 value
            {
                //如果输入的年龄不在18到60的之间，就给value赋值为0
                if (value < 18 || value > 60)
                {
                    value = 0;
                }
                _age = value;
            }
        }
        private char _gender;     //定义char类型的字段_gender，用来记录员工性别
        public char Gender     //用户定义性别属性，该属性用于选取员工的性别进行限定
        {
            get        //可以用于对取值进行限定
            {
                //员工性别只有‘男’和‘女’，不管输入什么，性别只选取‘男’
                if (_gender != '男' || _gender != '女')
                {
                    _gender = '男';
                }
                return _gender;
            }
            set
            {
                _gender = value;
            }
        }
        public void Write()   //非静态方法
        {
            Console.WriteLine("新入职员工：\n姓名：{0}\t年龄：{1}\t性别：{2}", _name, Age, Gender);
        }
    }
    class Program
    {
        static void Main()
        {
            Clerk n = new Clerk();   //创建对象
            n.Age = 66;   //通过属性名来为字段进行赋值
            n.Gender = '女';
            n.Write();
            Console.WriteLine("修改员工信息");
            n.Age = 45;
            n.Write();
            Console.ReadKey();
        }
    }
}

程序分析】本例演示属性的使用。在代码中，首先创建一个关于员工的类Clerk，在该类中定义了三个字段_name、_age、_gender，并对_age和_gender进行属性定义，同时还定义了一个非静态方法Write，用于输出员工信息。当字段_age和_gender有了属性以后，用户一般都会通过属性来访问字段，所以在类Program的Main方法中，员工的年龄和性别使用Age和Gender来进行赋值。

新入职员工：
姓名：张三      年龄：0 性别：男
修改员工信息
新入职员工：
姓名：张三      年龄：45        性别：男

分部类与方法

将同一个类编写在多个文件中，类的各个文件名不同，类名相同，类名前加partial关键字，这种类型叫分部类。在分部类中可以建立分部方法，也需要方法名前加关键字partial。分部方法只能将方法分成两部分，即声明部分和实现部分。分部方法必须在分部类或分部结构中声明,并且必须私有访问。
分部方法有着严格的限制：
(1) 方法必须返回void，只能默认为private。
(2) 分部方法不能为virtual和extern方法。
(3) 分部方法可以有ref参数，但不能有out参数。
因为任何针对没有被实现的分部方法的调用，都会简单地被忽略。所以说这些限制是非常有必要的。

using System;
namespace Project12
{
    public partial class Program
    {
        partial void Write();  //分部方法的声明
        partial void Write()   //分部方法的实现
        {
            Console.WriteLine("这是一个分部方法");
        }
    }
    public partial class Program
    {
        static void Main(string[] args)
        {
            //调用分部方法
            Program p = new Program();
            p.Write();
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示分部类的使用。在代码中，首先通过partial修饰符把Program类分为两部分，在第一部分中定义一个分部方法，然后在另一部分中去引用该方法。

这是一个分部方法

构造函数与析构函数的使用

虚方法的使用

方法的重载

结构体与类的区别