C#类和继承（扩展方法、静态类、抽象类、构造函数初始化等）

分部类和分部方法

namespace jiayou1
{
    /*定义分部类需要注意以下问题：在申明
     和实现申明中都必须包含上下文关键字partial，直接放在
     关键字void的后面，返回类型必须是void
     参数列表不能包含out参数*/
    partial class MyClass
    {
        partial void PrintSum(int x,int y);
        //申明分部方法，没有实现部分
        public void Add(int x,int y)
    {
        PrintSum(x,y);
    }
    }
    partial class MyClass
    {
        partial void PrintSum(int x, int y)
            //申明分部方法，实现部分
        {
            Console.WriteLine("sum is {0}",x+y);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var mc = new MyClass();
            mc.Add(5,6);
        }
    }
}

类继承

namespace 类继承
{
    class SomeClass//基类
    {
        public string Field1 = "base class field";
        public void Method1(string value)
        {
            Console.WriteLine("base class--Method1:{0}",value );
        }
    }
    class OtherClass : SomeClass//派生类
    {
        public string Field2 = "derived class field";
        public void Method2(string value)
        {
            Console.WriteLine("Derived class--Method2:{0}",value);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            OtherClass oc = new OtherClass();
            oc.Method1(oc.Field1 );//以基类字段为参数的基类方法
            oc.Method2(oc.Field2);//以基类字段为参数的基类方法
            oc.Method1(oc.Field2);//以基类字段为参数的基类方法
            oc.Method2(oc.Field1);//以基类字段为参数的基类方法
        }
    }
}

隐藏基类成员

namespace 隐藏基类的成员
{
    /*要隐藏一个继承的数据成员，需要声明一个新的new相同的
     类型成员，并使用相同的名称
     要让编译器知道你在故意隐藏继承成员，使用New修饰符。
     没有它，程序可以成功编译，但编译器会警告你隐藏了
     一个继承的成员*/
    class SomeClass//基类
    {
        public string Field1 = "SomeClass Field1";
        public void Method1(string value)
        {
            Console.WriteLine("SomeClass.Method1:{0}",value);
        }
    }
    class OtherClass : SomeClass//派生类
    {
        new public string Field1 = "OtherClass Field1";//掩盖基类成员
        new public void Method1(string value)//掩盖基类成员
        {
            Console.WriteLine("OtherClass.Method1:{0}", value);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            OtherClass oc = new OtherClass();//使用掩盖成员
            oc.Method1(oc.Field1 );//使用掩盖成员
        }
    }
}

基类访问

namespace 基类访问
{
    class SomeClass//基类
    {
        public string Field1 = "Field1--In the base class";
    }
    class OtherClass : SomeClass//派生类
    {
        new public string Field1 = "Field1--In the base class";//隐藏基类中的字段
        public void PrintField1()
        {
            Console.WriteLine(Field1 );//访问派生类
            Console.WriteLine(base.Field1 );//访问基类，运用base
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            OtherClass oc = new OtherClass();
            oc.PrintField1();
        }
    }
}

使用基类引用

namespace 使用基类的引用
{
    class MyBaseClass
    {
        public void Print()
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass
    {
        new public void Print()
        {
            Console.WriteLine("This is the derived class");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDerivedClass derived = new MyDerivedClass();
            MyBaseClass mybc = (MyBaseClass)derived;//转换成基类
            derived.Print();//从派生类部分调用Print
            mybc.Print();//从基类部分调用Print
        }
    }
}

虚方法和覆写方法

namespace 虚方法和覆写方法
{
    /*基类的方法被标记为virtual,在派生类中有匹配的override
     覆写方法和被覆写方法须有相同的可访问性。不能有关键词
     private出现，不能覆写static方法或非虚方法。*/
    class MyBaseClass
    {
        virtual public void Print()//虚方法
        {
            Console.WriteLine("This is the base class.");
        }
    }
    class MyDerivedClass : MyBaseClass
    {
        override public void Print()//覆写方法
        {
            Console.WriteLine("This is the derived class.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDerivedClass derived = new MyDerivedClass();
            MyBaseClass mybc = (MyBaseClass)derived;//强制转换为基类
            derived.Print();
            mybc.Print();
        }
    }
}

构造函数初始化语句

namespace 构造函数的初始化语句
{
    class MyClass
    {
        readonly int firstVar;
        readonly double secondVar;
        //readonly字段只可以在构造函数中初始化
        public string UserName;
        public int UserIdNumber;
        private MyClass()
            //私有的构造函数进行其他
            //构造函数共同初始化
        {
            firstVar = 20;
            secondVar = 30.5;
        }
        public MyClass(string firstName)
            : this()//使用构造函数初始化语句
        {
            UserName = firstName;
            UserIdNumber = -1;
        }
        public MyClass(int idNumber)
            : this()//使用构造函数初始化语句
        {
            UserName = "Anonymous";
            UserIdNumber = idNumber;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {

        }
    }
}

程序集间的继承【包括（1）和（2）】

（1）

namespace BaseClassNS
{
    public class MyBaseClass
    //该声明为公有的，以使他能被从程序集的外部看见
    {
        public void PrintMe()
        {
            Console.WriteLine("I am MyBaseClass");
        }
    }
}

（2）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BaseClassNS;
//包含基类申明的命名空间

namespace 程序集继承2
{
    class DerivedClass:MyBaseClass  
        //在其他程序集中的基类
    { 
    
    }
    class Program
    {
        static void Main(string[] args)
        {
            DerivedClass mdc = new DerivedClass();
            mdc.PrintMe();
        }
    }
}

抽象类和抽象方法

namespace 抽象类和抽象方法1
{
    abstract class ABClass//抽象类声明
    {
        public void IdentifyBase()//普通方法
        {
            Console.WriteLine("I am ABClass");
        }
        abstract public void IdentifyDerived();//抽象方法
    }
    class DerivedClass : ABClass//派生类
    {
        public override void IdentifyDerived()//抽象方法实现
        {
            Console.WriteLine("I am DerivedClass");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //ABClass a=new ABClass();错误：抽象类不能实例化
            //a.IdentifyBase();
            DerivedClass b = new DerivedClass();//实例化派生类
            b.IdentifyBase();//调用继承方法
        }
    }
}

另一个抽象类例子

namespace 抽象类2
{
    abstract class MyBase//抽象和非抽象成员的组合
    {
        public int SideLength = 10;//数据成员
        const int TriangleSideCount = 3;//数据成员
        abstract public void PrintStuff(string s);//抽象方法
        abstract public int MyInt { get; set; }//抽象属性
        public int PerimeterLength()//普通非抽象方法
        {
            return TriangleSideCount * SideLength;
        }
    }
    class MyClass : MyBase
    {
        public override void PrintStuff(string s)//覆盖抽象方法
        {
            Console.WriteLine(s);
        }
        private int   _MyInt;
        public override int  MyInt//覆盖抽象属性
{
      get 
    { 
        return _MyInt;
    }
      set 
    { 
        _MyInt=value ;
    }
}
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            mc.PrintStuff("This is a string .");
            mc.MyInt = 28;
            Console.WriteLine(mc.MyInt );
            Console.WriteLine("Perimeter Length:{0}",mc.PerimeterLength ());
        }
    }
}

静态类

namespace 静态类
{
    /*类的本身必须标记static
     类的所有成员必须是静态的。
     类可以有一个静态构造函数，但没有实例构造函数
     不能创建该类的实例。静态类是隐式是封闭的，不能
     继承静态类。*/
    static public class MyMath
    {
        public static float PI = 3.14f;
        public static bool IsOdd(int x)
        {
            return x % 2 == 1;
        }
        public static int Times2(int x)
        {
            return 2 * x;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            int val = 3;
            Console.WriteLine("{0} is odd is {1}",val,MyMath .IsOdd (val ));
            Console.WriteLine("{0}*2={1}.",val,MyMath .Times2 (val ));
        }
    }
}

扩展方法

namespace 声明扩展方法
{
    /*声明扩展方法必须声明为static
     扩展方法本身必须声明为static
     扩展方法必须包含关键字this作为他的一个参数类型
     并在后面跟着所扩展类的名称。*/
    sealed class MyData
    {
        private double D1, D2, D3;
        public MyData(double d1, double d2, double d3)
        {
            D1 = d1; D2 = d2; D3 = d3;
        }
        public double sum()
        {
            return D1 + D2 + D3;
        }
    }
    static class ExtendMyData//声明扩展方法
    {
        public static double Average(this MyData md)//this关键字和类型（相当于实例化）
        {
            return md.sum() / 3;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyData md = new MyData(3, 4, 5);
            Console.WriteLine("Sum:{0}",md.sum ());//当作实例化成员来调用
            Console.WriteLine("Average:{0}",md.Average ());
        }
    }
}