重学CSharp（二）

好了，今天我来总结一下类中的方法。

一说到类肯定得说道面向对象，说实话，我对于面向对象也不是很理解的，虽然例子我也说随意说出一些，但我指的是真正的掌握了那种面向对象的思维。也许我的经历和经验离理解还需要一段时间吧。

OOP（即Object-Oriented Programming）,这是我学习C#接触的一个概念，我是一点都不会C++和Java的，我的很多理解就是书上的例子，比如说交通工具，火车和汽车都属于交通工具，甚至自行车也可以算，但它们之间又存在不同的，就如同共性和个性，抽象出来的共性就可以说是类，而这些独立开来看的个体就可以说是一个对象。我们都希望继承共性重写个性，这样我们的程序就结构清晰，易读易写。

下面来看个书上简单的例子。

public class Authenticator

{

       private string Password;

      

       public bool IsPasswordCorrect(string password)

       {

              return (password == Password) ? true : false;

       }

       public bool ChangePassword(string oldPassword, string newPassword)

       {

              if(oldPassword == Password)

              {

                     Password == newPassword;

                     return true;

              }

              else

              {

                     return false;

              }

             

       }

}

 

这个Authenticator类里面定义了两个方法，一个是判断密码是否正确，一个是如果正确可以修改密码。

其实这些相信大家都是知道的，在调用这个类的时候我要实例化它，比如说在入口函数中：

public static void Main()

{

       Authenticator auth = new Authenticator();

       auth.IsPasswordCorrect(psd);

       ……

}

这样就可以调用那个类里面的方法了。

对于这些我不想过多的去说，我想说的是如果带有static的静态类的方法处理。

如果一个方法申明为static会稍微提高它的调用效率，因为它不会像实例方法一样产生一个隐式的外部参数。但是静态类不能实例化，如果实例化会编译错误。我们只能通过类的实例地址来访问。比如说：

public static class test

{

       public bool IsPasswordCorrect(string password)

       {

              return (password == Password) ? true : false;

       }

       ……

}

在入口函数中调用的时候

public static void Main()

{

       test.IsPasswordCorrect(psd);

       ……

}

 

下面再来说一下虚拟的方法，就是带virtual关键字的方法。如果方法不是virtual，编译器就会使用声明的引用类型，如果方法是virtual方法，编译器就会生成代码，在运行时检测方法指向哪个实例，然后确定这个实例属于哪个类。

virtual 关键字用于修饰方法、属性、索引器或事件声明，并且允许在派生类中重写这些对象。

这是MSDN上的一个例子：

using System;

class TestClass

{

    public class Dimensions

    {

        public const double PI = Math.PI;

        protected double x, y;

        public Dimensions() //构造函数

        {

        }

        public Dimensions(double x, double y)

        {

            this.x = x;

            this.y = y;

        }

 

        public virtual double Area() //虚方法

        {

            return x * y;

        }

    }

 

    public class Circle : Dimensions

    {

        public Circle(double r) : base(r, 0)

        {

        }

 

        public override double Area() //重写方法

        {

            return PI * x * x;

        }

    }

 

    class Sphere : Dimensions

    {

        public Sphere(double r) : base(r, 0)

        {

        }

 

        public override double Area()

        {

            return 4 * PI * x * x;

        }

    }

 

    class Cylinder : Dimensions

    {

        public Cylinder(double r, double h) : base(r, h)

        {

        }

 

        public override double Area()

        {

            return 2 * PI * x * x + 2 * PI * x * y;

        }

    }

 

    static void Main()

    {

        double r = 3.0, h = 5.0;

        Dimensions c = new Circle(r);

        Dimensions s = new Sphere(r);

        Dimensions l = new Cylinder(r, h);

        // Display results:

        Console.WriteLine("Area of Circle   = {0:F2}", c.Area());

        Console.WriteLine("Area of Sphere   = {0:F2}", s.Area());

        Console.WriteLine("Area of Cylinder = {0:F2}", l.Area());

    }

}

 

如果我们定义了一个非常基本的类，再从中派生出其他专用的类，但实际上我们又不想使用这个类，这是我们可以用abstract关键字定义为抽象的类。

在这个类中可以定义抽象的方法，但有一点注意，我们这么定义是假设它是要被重写的，所以不用给出方法体。例如：

abstract class MyBase

{

       public abstract int MyabstractMethod();//没有方法体

       ……

}

 

最后一个是密封的类和方法，就是使用sealed关键字的，如果试图从密封类中派生出其他类，就会编译错误，它是不允许派生的。同样一个方法如果申明为密封的，它是不允许重写的，不然也会编译错误。

好了，方法就说道这里吧，因为我自己的水平有限，有很多都说不清楚，望理解。