第五章 类

1 面向对象程序设计基础

如果一个软件系统是使用这4个概念来设计和实现的，就认为这个软件系统是面向对象的

1.1 对象

1.2 类

类是一组具有相同数据结构和相同操作的对象的集合

1.3 继承

继承是以现有类型定义为基础创建新类型的技术。

1.4 消息通信

对象与对象之间，通过消息进行通信。

2 类的生命周期

2.1 构造函数

对象的初始化通常由类的构造函数来完成。

a、构造函数的名称与类名相同

b、构造函数不声明返回类型

c、构造函数通常是公有的，如果声明为保护的或私有的，则该构造函数不能用于类的实例化

d、构造函数的代码中通常中只进行对象初始化工作，而不应执行其它操作

e、构造函数在创建对象时被自动调用，不能像其它方法那样显式的调用

    public class ConstructSample
    {
        public static void Main()
        {
        Person p = new Person();
        Console.WriteLine(p.m_name);
        }
    }

    public class Person
    {
        public string m_name;
        protected int m_age;
        protected bool m_gender;

        //构造函数
        public Person()
        {
            m_name = "Unknown";
            m_age = 0;
            m_gender = false;
        }
    }

带参数的构造函数（构造函数的重载）

    public class Person
    {
        public string m_name;
        protected int m_age;
        protected bool m_gender;

        //构造函数
        public Person()
        {
            m_name = "Unknown";
            m_age = 0;
            m_gender = false;
        }
        //构造函数重载
        public Person(string Name)
        {
            m_name = Name;
            m_age = 0;
            m_gender = true;
        }
    }

2.2 静态构造函数

如果使用了关键字static来定义构造函数，那么该构造函数就属于类而不是类的实例所有。

在程序第一次用到某个类时，类的静态构造函数自动被调用，而且是仅此一次。

静态构造函数通常用于对类的静态字段进行初始化

静态构造函数不使用任何访问限制修饰符。

    public class StaticConstructSample
    {
        public static void Main()
        {
            Person p1 = new Person("Mike");
            Person p2 = new Person("John");
            Person p3 = new Person("Mary");
        }
    }

    public class Person
    {
        public string m_name;
        public static int m_object=0;
        public static int m_classes = -1;

        //构造函数
        public Person(string Name)
        {
            m_name = Name;
            Console.WriteLine(m_name);
            Console.WriteLine("Object before:{0}", m_object);
            m_object++;
            Console.WriteLine("Object after:{0}", m_object);
        }
        //静态构造函数
        public Person()
        {
            Console.WriteLine("Classes before:{0}", m_classes);
            m_classes++;
            Console.WriteLine("Classes after:{0}", m_classes);
        }
    }

程序输出结果

Mike
Object before:0
Object after:1
John
Object before:1
Object after:2
Mary
Object before:2
Object after:3
请按任意键继续. . .

2.3 析构函数

对象使用完毕后，释放对象时就会自动调用类的析构函数

--析构函数的名称与类名相同，但在名称前面加了一个符号"~"

--析构函数不接受任何参数，也不返回任何值

--析构函数不能使用任何访问限制修饰符

--析构函数中的代码通常只进行销毁对象的工作，而不应执行其它的操作

--析构函数不能被继承，也不能被显示的调用

--如果类中没有显式的定义一个析构函数，编译时也会生成一个默认的析构函数，其执行代码为空。

--不存在静态的析构函数

3 属性

--为了实现良好的数据封装和数据隐藏，C#为类提供了属性（Property）成员。

--属性是对字段的扩展，它通过属性访问函数来控制对字段的访问。

--属性访问函数包括get访问函数和set访问函数，分别用于对字段的读取和修改。

例如Person类中可以使用Name属性来封装对私有字段name的访问

public class Person
{
    //字段
    private string name;
    //属性
    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name=value;
        }
    }
}

public static void Main()
{
    person p1=new Person();
    p1.Name="Mike";//set
    Console.WriteLine(p1.Name);//get
}    

--定义属性时可以只声明一个访问函数。如果只有get，则表明属性的值不能为修改；如果只有set，则表明属性的值只能写入。

--和方法一样，属性可以声明为静态的，也可以使用各种访问限制修饰符

--属性可以作为特殊的方法来使用，而不必和字段一一对应

public class Person
{
    private DateTime birthday;

    public int Age
    {
        get
        {
            return DataTime.Now.Year-birthday.year;
        }
    }
}

4 索引函数

--索引函数对属性做了进一步的扩展，它能够以数组的方式来控制对多个变量的读写访问。

--和属性一样，索引函数可以被看作是get访问函数和set访问函数的组合，不同之处在于：

　　--索引函数以this关键字加数组形式的下标进行定义，并通过数组形式的下标进行访问；

　　--索引函数的get和set带用参数（一般为整型或字符串类型）

　　--索引函数不能是静态的

　　--和属性类似，索引函数的get和set访问函数中可以增加控制代码

下面的代码示例了一个Per    public class PersonTable

    {
        private Person[] m_list;

        public int Length
        {
            get
            {
                return m_list.Length;
            }
        }

        //索引函数
        public Person this[int index]
        {
            get
            {
　　　　　　　　　if(index>=0 && index <Length)
                　　return m_list[index];
　　　　　　　　  else
　　　　　　　　　　　 return null;
            }
            set
            {
　　　　　　　　　if(index>=0 && index <Length)
　　                m_list[index] = value;
　　　　　　　　  else
　　　　　　　　　　　throw new IndexOutOfRangeException();
            }
        }
    }

这样对类的使用和数组的使用就非常类似了

PersonTable pt = new PersonTable(3);
pt[1]=new Person("Mike");
...
...

索引函数的访问对象不一定要是连续的数据，也可以是多个离散的字段。例如

    public class IndexerSample
    {
        static void Main()
        {
            Person p1 = new Person("李四");
            p1["BusinessPhone"] = "010888888";
            p1["BusinessFax"] = "0108888888";
            p1["MobilePhone"]="13988888888";
            p1.Output();
        }
    }

    public class Person
    {
        private string m_name;
        private string m_busiPhone;
        private string m_busiFax;
        private string m_homePhone;
        private string m_mobilePhone;

        public string Name
        {
            get
            {
                return m_name;
            }
            set
            {
                m_name = value;
            }
        }

        //索引函数
        public string this[string Stype]
        {
            get
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        return m_busiPhone;
                    case "BUSINESSFAX":
                        return m_busiFax;
                    case "HOMEPHONE":
                        return m_homePhone;
                    case "MOBILEPHONE":
                        return m_mobilePhone;
                    default:
                        return null;
                }
            }
            set
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        m_busiPhone = value;
                        break;
                    case "BUSINESSFAX":
                        m_busiFax = value;
                        break;
                    case "HOMEPHONE":
                        m_homePhone = value;
                        break;
                    case "MOBILEPHONE":
                        m_mobilePhone = value;
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        //构造函数
        public Person()
        {
        }

        public Person(string sName)
        {
            m_name = sName;
        }

        //方法
        public void Output()
        {
            Console.WriteLine(m_name);
            Console.WriteLine("商务电话:{0}", m_busiPhone);
            Console.WriteLine("商务传真:{0}", m_busiFax);
            Console.WriteLine("家庭电话:{0}", m_homePhone);
            Console.WriteLine("移动电话:{0}", m_mobilePhone);
        }
    }

5 事件

通过事件（Event），对象可以对发生的情况做出反映。

在C#的事件处理模型中，某个事件发生后，对象通过该事件的代表（delegate）调用适当的事件处理代码，此时代表充当了产生事件的对象与处理事件的方法之间的“中间人”。

System程序集中定义了一个EventArgs的类，用来封装事件中所包含的数据：此外还定义了一个名为EventHandler的delegate对象，用来作为所有事件的代表，其原型为：

public delegate void EventHandler(object sender,EventArgs e)

其中的参数sender表示发生事件的对象，而e表示事件中包含的数据。

C#中的事件也是一种特殊的方法，它包含一对内部函数add和remove,add函数将代表附加到事件上，而remove函数将移除已附加到事件上的代表。

    public class EventSample
    {
        static void Main()
        {
            Person p1 = new Person("李四");
            p1.Name = "李明";
            Console.WriteLine("当前姓名为:{0}", p1.Name);
        }
    }

    public class Person
    {
        //字段
        private string m_name;
        private string m_busiPhone;
        private string m_busiFax;
        private string m_homePhone;
        private string m_mobilePhone;

        //属性
        public string Name
        {
            get
            {
                return m_name;
            }
            set
            {
                if(m_name!=value)
                {
                    OnNameChange(this, new EventArgs());
                    m_name = value;
                }
            }
        }

        //代表
        internal EventHandler eh;

        //索引函数
        public string this[string Stype]
        {
            get
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        return m_busiPhone;
                    case "BUSINESSFAX":
                        return m_busiFax;
                    case "HOMEPHONE":
                        return m_homePhone;
                    case "MOBILEPHONE":
                        return m_mobilePhone;
                    default:
                        return null;
                }
            }
            set
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        m_busiPhone = value;
                        break;
                    case "BUSINESSFAX":
                        m_busiFax = value;
                        break;
                    case "HOMEPHONE":
                        m_homePhone = value;
                        break;
                    case "MOBILEPHONE":
                        m_mobilePhone = value;
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        //构造函数
        public Person()
        {
        }

        public Person(string sName)
        {
            m_name = sName;
        }

        //方法
        public void Output()
        {
            Console.WriteLine(m_name);
            Console.WriteLine("商务电话:{0}", m_busiPhone);
            Console.WriteLine("商务传真:{0}", m_busiFax);
            Console.WriteLine("家庭电话:{0}", m_homePhone);
            Console.WriteLine("移动电话:{0}", m_mobilePhone);
        }

        //事件
        public event EventHandler NameChange
        {
            add
            {
                eh += (EventHandler)Delegate.Combine(eh, value);
            }
            remove
            {
                eh -= (EventHandler)Delegate.Combine(eh, value);
            }
        }

        //事件处理方法
        protected void OnNameChange(object sender, EventArgs e)
        {
            Console.WriteLine("人员姓名:{0},已经被修改", m_name);
        }
    }

 这样，每次修改Person的Name属性，将触发NameChange事件，程序输出为：

人员姓名:李四,已经被修改
当前姓名为:李明
请按任意键继续. . .

C#还提供了事件定义的简写方式，可以不用写出事件的add和remove函数，也不用写出代表的定义。上例中的事件和代表的定义就可以简化为一行代码：

public event EventHandler NameChange;

输出效果相同。

更多的时候，开发人员需要自定义EventArgs的派生类，并在其中自定义事件数据。对Person类进行如下修改：

    public class Person
    {
        //字段
        private string m_name;
        private string m_busiPhone;
        private string m_busiFax;
        private string m_homePhone;
        private string m_mobilePhone;

        //属性
        public string Name
        {
            get
            {
                return m_name;
            }
            set
            {
                if(m_name!=value)
                {
                    PersonEventArgs e = new PersonEventArgs();
                    e.m_oldName = m_name;
                    e.m_newName = value;
                    OnNameChange(this, e);
                }
            }
        }

        //索引函数
        public string this[string Stype]
        {
            get
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        return m_busiPhone;
                    case "BUSINESSFAX":
                        return m_busiFax;
                    case "HOMEPHONE":
                        return m_homePhone;
                    case "MOBILEPHONE":
                        return m_mobilePhone;
                    default:
                        return null;
                }
            }
            set
            {
                string type=Stype.ToUpper();
                switch (type)
                {
                    case "BUSINESSPHONE":
                        m_busiPhone = value;
                        break;
                    case "BUSINESSFAX":
                        m_busiFax = value;
                        break;
                    case "HOMEPHONE":
                        m_homePhone = value;
                        break;
                    case "MOBILEPHONE":
                        m_mobilePhone = value;
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }
        }

        //构造函数
        public Person()
        {
            NameChange += new EventHandler(OnNameChange);
        }

        public Person(string sName)
        {
            m_name = sName;
            NameChange+=new EventHandler(OnNameChange);
        }

        //方法
        public void Output()
        {
            Console.WriteLine(m_name);
            Console.WriteLine("商务电话:{0}", m_busiPhone);
            Console.WriteLine("商务传真:{0}", m_busiFax);
            Console.WriteLine("家庭电话:{0}", m_homePhone);
            Console.WriteLine("移动电话:{0}", m_mobilePhone);
        }

        //事件
        public event EventHandler NameChange;

        //事件参数类
        public class PersonEventArgs : EventArgs
        {
            public string m_oldName;
            public string m_newName;
        }

        //事件处理方法
        protected void OnNameChange(object sender, EventArgs e)
        {
            Console.WriteLine("人员姓名:{0},已经被修改为{1}!", ((PersonEventArgs)e).m_oldName,((PersonEventArgs)e).m_newName);
            Console.WriteLine("确定修改(Y/N)?");
            char key = Console.ReadKey().KeyChar;
            Console.WriteLine();
            if (key == 'y' || key == 'Y')
            {
                m_name = ((PersonEventArgs)e).m_newName;
                Console.WriteLine("姓名修改成功");
            }
        }
    }

程序输出结果为：

人员姓名:李四,已经被修改为李明!
确定修改(Y/N)?
y
姓名修改成功
当前姓名为:李明
请按任意键继续. . .

6 操作符重载

操作符重载可用于对自定义的数据类型进行基本操作

允许被重载的操作符包括

-- 一元操作符：+ - ! ~ ++ -- (T) true false

-- 二元操作符：+ - * / % & | ^ << >> == != > < >= <=

考虑到操作符的对称性，下列操作符要求成对重载

-- 一元操作符：true和false

-- 二元操作符：==和 !=、>和<、>=和<=

class Prime
{
    private uint m_value;
    public Prime(uint iValue)
    {
        m_value=iValue;
    }
}

public static uint operator+(Prime p1,Prime P2)
{
    return p1.m_value+p2.m_value;
}

如果添加了以上方法，则p1+p2是合法的，而不用繁琐的写法p1.m_value+p2.m_value;

对于复合赋值操作符，只要左部操作符是可重载的二元操作符，并且操作符的返回类型也可以隐式的转换成当前类，那么相应的斌值操作符也被隐式重载。例如将上面的重载定义改写为：

public static Prime operator+(Prime p1,Prime p2)
{
    return new Prime(p1.m_value+p2.m_value);
}

此时p1+=p2这样的表达式也是合法的。

--被重载的操作符也是一种特殊的方法，且必须被声明为公有的和静态的。

--重载一元操作符时需提供一个参数，且参数类型应为当前类型，或者是可以隐式转换为当前类型

--重载二元操作符时需提供两个参数，且至少有一个参数类型为当前类型，或者是可以隐式转换为当前类型

--对于类型转换操作符(T),在定义重载时需要为T指定一个数据类型。类型转换的重载有一个特殊的地方，就是它不显式的定义返回类型，而认为操作符的返回类型始终为T所代表的类型。此外，需要使用关键字explicit或implicit来指明转换是显式的还是隐式的。

例如可以定义从Prime类到uint类的隐式转换

public static implicit operator uint(prime p)
{
    return p.m_value;
}

下面的代码为一个完整的示例：

    public class OperatorSample
    {
        static void Main()
        {
            //输出前20个素数
            Prime p1 = new Prime(2);
            for (int i = 0; i < 20; i++)
            {
                Console.WriteLine(p1++);
            }

            //输出500~1000之间的所有素数
            for (uint j = 500; j < 1000; j++)
            {
                Prime p2 = new Prime(j);
                if (p2)
                    Console.WriteLine(p2 + ",");
            }
        }
    }


    public class Prime
    {
        private uint m_value;

        public uint Value
        {
            get
            {
                return m_value;
            }
        }

        //构造函数
        public Prime(uint iValue)
        {
            m_value = iValue;
        }

        //重载二元操作符+
        public static uint operator +(Prime p1, Prime p2)
        {
            return p1.m_value + p2.m_value;
        }

        //重载二元操作符-
        public static int operator -(Prime p1, Prime p2)
        {
            return (int)(p1.m_value - p2.m_value);
        }

        //重载一元操作符++
        public static Prime operator ++(Prime p)
        {
            for (uint i = p.m_value + 1; ; i++)
            {
                if (IsPrime(i))
                    return new Prime(i);
            }
        }

        //重载一元操作符--
        public static Prime operator --(Prime p)
        {
            for (uint i = p.m_value - 1;i>2; i--)
            {
                if (IsPrime(i))
                    return new Prime(i);
            }
            return new Prime(2);
        }

        //重载类型转换操作符(uint)
        public static implicit operator uint(Prime p)
        {
            return p.m_value;
        }

        //重载一元操作符true
        public static bool operator true(Prime p)
        {
            return IsPrime(p.m_value);
        }

        //重载一元操作符false
        public static bool operator false(Prime p)
        {
            return IsPrime(p.m_value);
        }

        //方法，判断一个整数是否为素数
        public static bool IsPrime(uint x)
        {
            for (uint i = 2; i <= x / 2; i++)
            {
                if (x % i == 0)
                    return false;
            }
            return true;
        }

        //重写ToString()
        public override string ToString()
        {
            return m_value.ToString();
        }
    }

7 this关键字

this用于代一个变量

--它仅限于在类的非静态方法成员中使用，包括类的构造函数、非静态方法、属性、索引函数及事件

--在类的构造函数中出现时，它表示正在构造的对象本身

--在类的方法成员中出现时，它表示调用该方法成员的对象

上例中的prime类的带参数的构造函数可以写成以下形式

public Prime(uint iValue)
{
    this.m_value=iValue;
}