C#拾遗之方法(一)

        在类中自定义的“函数”称为“方法”，由于C#是完全面向对象的语言，同时为了便于解释后面要学的C#类，这里的“方法”来称呼“函数”。

        方法是一种用于实现可以有对象或类执行的计算机或操作的成员，是一个已命名的语句集。每个方法都有一个名称和主体。方法名应该是一个有意义的标识符，应描述出方法的用途。方法主体包含了调用方法时实际执行的语句。用户可以为大多数方法提供一些数据来进行处理，并让其返回一些信息(通常是处理结果)。方法是一种基本的，功能强大的编程机制。

       方法的声明格式为：

       修饰符  返回值类型  方法名称(参数列表)

        {
                 方法体

        }

        其中的修饰符和参数列表都是可选的，修饰符如下：new，public，protected，internal，private，static，virtual，sealed，override，abstract，extern，partial

          如果以下所有条件都为真，则所述的声明就具有一个有效的修饰符组合：

       (1)该声明包含一个由访问修饰符组成的有效组合

       (2)该声明中所含的修饰符没有彼此相同的

       (3)该声明最多包含下列修饰符中的一个：static，virtual和override

       (4)该声明最多包含下列修饰符中的一个：new和override

       (5)如果声明中包含abstract修饰符，则该声明不包含下列任何修饰符：static，virtual，sealed或extern

       (6)如果声明中包含private修饰符，则该声明不包含下列任何修饰符：virtual，override或abstract

       (7)如果声明包含sealed修饰符，则该声明还包含override修饰符

       (8)如果声明中包含partial修饰符，则该声明不包含下列任一修饰符：new，public，protected，internal，private，static，virtual，sealed，override，abstract，extern

        返回值类型是一个类型名，它指定了返回的信息是什么类型。这可以是任何类型，如果要返回值，则在方法体运行后必须由return语句返回一个和“返回值类型”相同类型的值，如果要写一个不返回值的方法，那么必须用关键字void来取代返回类型。如果声明包含partial修饰符，则返回类型必须为void。

        一个方法的名称必须不同于在一个类中声明的所有其他非方法的名称。此外，必须不同于在同一类中声明的所有其他方法的签名。在写参数列表时，所有形参和类型形参都不能同名。

        下面编写一个简单的返回两个整型数的和的方法：

         public  int  add(int a, int  b)

         {

                 return  a+b;

         }

         下面就具体介绍C#语言中的一些重要的基础的方法

          一，静态方法和实例方法

          静态方法是一个特殊的成员方法，不属于类的某一个具体的实例或对象，而属于类本身。静态方法不对特定实例进行操作，只能访问类中的静态成员。访问静态方法只能使用类名，而不需要创建对象，也不能使用对象名类引用，声明静态方法修饰符中必须有static关键字。

        实例方法可以使用类的任何成员。调用实例方法时，必须使用类的实例或对象来引用。实例方法对类的某个给定的实例进行操作，在实例方法类中可以使用this来访问实例。调用实例方法时，必须先创建一个对象。

        简单的说，静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许静态方法使用实例成员变量，这是错误的。基于同样的道理，静态方法中不能使用关键字this。

        例一，编程使用静态方法和实例方法

<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Text
{
    class A
    {
        int exaVar;//创建的一个为实例成员变量
        static int stVar;//创建的一个静态成员变量
        void tM()//实例方法
        {
            exaVar = 1;//等价于this.exVar=1
            stVar = 1;//等价于A.stVar=1
        }
         static void sM()//静态方法
        {
            //exaVar = 1;//错误，静态方法不可以调用实例成员变量
            stVar = 1;//等价于A.stVar=1
        }
        static void Main(string[] args)
        {
            A text = new A();//创建类A的对象为text
            text.exaVar = 1;//对象text访问实例成员变量
            A.stVar = 1;//只能使用类访问静态成员变量
            //text.stVar = 1;//不能使用对象text访问静态成员变量
            text.tM();//使用对象text访问实例成员方法
            //text.sM();//不能使用对象text访问静态成员方法
            A.sM();//使用类访问静态成员方法
            Console.WriteLine(text.exaVar + A.stVar);
            Console.ReadLine();
        }
    }
}</span>

         输出的结果为：2
         二，虚方法和非虚方法

         若一个实例方法的声明中含有virtual修饰符，则称该方法为虚方法。若其中没有virtual修饰符，则称该方法为非虚方法。

        非虚方法的实现是一成不变的，无论该方法是在声明它的类的实例上调用还是在派生类的实例上调用，实现均相同。与此相反，虚方法的实现可以由派生类取代。取代所继承的虚方法的实现的过程称为重写该方法。在虚方法调用中，该调用所涉及的那个实例运行时类型确定了要被调用的究竟是该方法的哪一种实现。在非虚方法调用中，相关的实例的编译时类型是决定性因素。

        例二，使用虚方法和非虚方法在派生类中调用

<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Text
{
    public class A
    {
        public virtual void ab()//定义的类A的虚方法        </span>

<span style="font-size:18px;">        {
            Console.WriteLine("这是虚方法");
        }
        public void ac()//定义的类A的非虚方法
        {
            Console.WriteLine("这是非虚方法");
        }
    }
    public class B:A//类B私有继承类A
    {
        public override void ab()//重写继承的ab方法
</span>       <span style="font-size:18px;"> {
            Console.WriteLine("这是新的方法");
        }
        public new void ac()//创建一个新的方法覆盖原来的ac方法
        {
            Console.WriteLine("这是另一个新的方法");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            B b = new B();//创建类B的对象b
            A a = b;//将对象b赋值给类A的对象a
            a.ab();//调用原ab虚方法
            b.ab();//调用ab方法
            a.ac();//调用原ac非虚方法
            b.ac();//调用ac方法
            Console.ReadLine();
        }
    }
}</span>

         输出的结果为：

 

        从输出的结果中可以看出虚方法的实现是由派生类取代并且由它的方法实现，而非虚方法的实现是定义的类和派生类的各自由它们的方法实现。