《C#4.0程序设计与项目实战》——类和对象

静态成员的执行顺序（下面例子中给出了两个类，分别包含一个静态字段和静态构造函数）

class Program
    {                  
        static void Main(string[] args)
        {
            Console.WriteLine("X={0},Y={1}",A.X,B.Y);
        }
    }
    class A
    {
        public static int X;
        static A()
        {
            X = B.Y + 1;
            Console.WriteLine("static A()");
        }
    }
    class B
    {
        public static int Y = A.X +1;
        static B()
        {
            Console.WriteLine("static B()");
        }
    }

运行效果如下：

 

继承的实现（下面给出两个类，Student类从Person派生）

 class Person
    {
        private string Name;
        public string _Name
        {
            get { return Name; }
            set { Name = value; }
        }
        public Person(string name)
        {
            Name = name;
        }
    }
    class Student:Person
    {
        private double Credit;
        public double _Credit
        {
            get{ return Credit;}
            set{ Credit=value;}
        }
        public Student(string name,double credit): base (name)
        {
            Credit=credit;
        }
    }

由于字段Name为Person类的私有成员，因此在派生类Student类并不能访问。在定义Student类构造函数时，一定要按照上面代码那样编写，否则会出现错误。这是因为基类Person中并没有显式定义不包含参数的构造函数，因此在定义派生类Student的构造函数时需要显式指出继承的参数。若基类中显示定义了不包含参数的构造函数则public Student(string name,double credit)也是正确的

 

多态性

若要在派生类中更改从基类继承来的数据和行为，C#为程序员提供了两种选择：使用新的派生类成员替换基类成员，或者重写虚拟的基类成员。

（1）使用新的派生类成员替换基类成员

namespace Test
{
    //class BaseClass
    //{
    //    public void Method()
    //    {
    //        Console.WriteLine("这是基类的方法");
    //    }
    //}
    //class DerivedClass : BaseClass
    //{
    //    public new void Method()//使用新的派生类的成员替换基类成员，注意new 关键字
    //    {
    //        Console.WriteLine("这是派生类的方法");
    //    }
    //}
    //class Program
    //{
    //    static void Main(string[] args)
    //    {
    //        DerivedClass d = new DerivedClass();
    //        d.Method();
    //        BaseClass b = (BaseClass)d;
    //        b.Method();
    //    }
    //}


    class BaseClass
    {
        public void Method()
        {
            Console.WriteLine("这是基类的方法");
        }
    }
    class DerivedClass : BaseClass
    {
        public void Method()//使用新的派生类的成员替换基类成员，注意new 关键字  不使用new关键字会产生下图所示的提示
        {
            Console.WriteLine("这是派生类的方法");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DerivedClass d = new DerivedClass();
            d.Method();
            BaseClass b = (BaseClass)d;
            b.Method();
        }
    }


}

 

（2）重写虚拟的基类成员

class BaseClass
    {
        public virtual void Method()
        {
            Console.WriteLine("这是基类的方法");
        }
    }
    class DerivedClass : BaseClass
    {
        public override void Method()
        {
            Console.WriteLine("这是派生类的方法");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DerivedClass d = new DerivedClass();
            d.Method();
            BaseClass b = (BaseClass)d;
            b.Method();
        }
    }

 重载：是在同一个类中多个方法有同样的函数名，要实现方法重载，要求方法的参数的个数或类型上有差异

重写：是基类中的虚拟成员或抽象成员在派生类中有新的实现

覆盖：是基类中定义的成员在派生类中有新的定义，并且隐藏了基类中的实现