【译文】 C#面向对象的基本概念 (Basic C# OOP Concept) 第一部分（类，对象，变量，方法，访问修饰符）

译文出处：http://www.codeproject.com/Articles/838365/Basic-Csharp-OOP-Concept

相关文档：http://files.cnblogs.com/yplong/ShanuBasicCSharpOOPConceptV1.4.zip

列表:

1. 类
2. 对象
3. 变量
4. 方法/函数
5. 访问修饰符
6. 封装
7. 抽象化
8. 继承
9. 多态
10. 抽象类/方法
11. 虚方法
12. 密封类/方法
13. 静态类/方法
14. 接口

简介：

关于C#面向对象我们能在网上找到很多解释，但在我的文章中我会用一个非常简单的例子来解释。该文章我会用一个House（房子）就像我们居住的房子作为实际的例子来让大家更容易的理解c#面向对象概念。

 1.类(Class)

类就像一个设计图(BluePrint).

什么是设计图？

设计图就是把我们的真实想法用线条勾勒出来。比如我们想建造一个新的房子，设计师就会把我们的想法用设计图的方式画出来，就像下面的图片。

一旦我们最后同意了设计，设计师就会开始建造一个与设计图一样的房子。

类和设计图非常相似，只不过是用编程来画出类的设计图。通过类，我们就可以写自己的方法，定义自己的变量。通过使用对象，就可以读取我们类里面的 方法和变量。方法，变量和对象组成了一个类。

通过真实世界存在的物体-房子我们能够更容易的理解面向对象。我们可以把房子想象成一个类。在房子里我们有很多的房间，比如客厅、卧室、厨房，还有其他的比如电视，冰箱等。房子的主人能够获取和使用房子里的房间和其他的任何房间里的东西。就像类里面的一组方法和变量，房子里的所有屋子和房子里的所有东西 就像类里面的方法和变量。

有了房间和房间里的必需品，所有我们就有了一个完整的房子。使用一个类，存取和使用类里的方法和变量，这里我们就用到了对象。对象是类的一个实例。下一章节我们会详细的讨论对象。

如果在一个房子里面 没有房间和物品，会怎样？可想而知，在没有房间和物品之前，房子就是空的不能使用的。如下图就是一座空房子：

现在空房子就是一个类，没有方法和变量，我们如何使用这个类。

下面我们就看看一个包含方法和变量的完整的类。

这里我们就有了一个完整的房子，相似的类就有了方法，变量和对象。后面章节我们再详细说明。

类和对象就是面向对象的基本概念（Class and objects are the base concept of OOP – Object Oriented Programming.）

下面是一个类的例子-->类 必须以Class关键字开始，后面跟着类名(可以是任何意义的名称由你自己定义)，紧接着是开始和关闭括弧。（{}）。

 class ShanuHouseClass1
     {
     }

 2.对象(Object)

      前面我们已经看到了对象。房子的主人能够使用房子里的任何房间和任何物品。相似的，我们可以使用对象来存取和使用类里面的方法和变量。同一个类，我们可以创建一个或多个对象。

比如一个房子可以有多个主人。（爸爸，妈妈，孩子）等。

下面是一个对象-->"objHouseOwner"就是一个对象，我们可以来存取和使用类里面的方法和变量。

ShanuHouseClass1 objHouseOwner = new ShanuHouseClass1();

3.变量(Variable)

变量是用来存储我们的值。我们的值可以是数字类型（numeric）或者字符类型（ characters）等，比如要存储一个手机号码，我们可以用一个整型变量(int)，存在我们的姓名可以使用一个字符串类型的变量(String).

变量可以是局部的也可以是全局的。比如我们买了一个新的电视，电视服务商就会过来把电视安装到我们的家里。他会留下联系方式以便将来能够联系。一般我们会把他的联系方式写在便签纸上，放到常用的地方或者我们的钱包里。如果我们把便签放到一个公共的区域，任何一个进来的人都能够看到这个电话号码，全局或者公共(Public)变量就是这样。

如果我们申明一个全局变量，那么在类里面的所有方法都能够存取这个变量。如果我们把便签放到钱夹里，就只有我们自己能够看到该号码。局部或者私有变量(Private)就是这样。

变量的语法:

Access-Modifiers Data-Type Variable-Name

访问修饰符-变量类型-名称

变量的默认修饰符 是Private 私有变量。我们可以自己定义为public。

变量的例子：

   int noOfTV = ;
        public String yourTVName;
        private Boolean doYouHaveTV = true;
 
 // Example Program 
 
 class ShanuHouseClass
     {
         int noOfTV = ;
         public String yourTVName = "SAMSUNG";
 
         static void Main(string[] args)
         {
             ShanuHouseClass objHouseOwner = new ShanuHouseClass();
 
             Console.WriteLine("You Have total " + objHouseOwner.noOfTV + " no of TV :");
             Console.WriteLine("Your TV Name is :" + objHouseOwner.yourTVName);
 
         }
     }

上面的代码中，我在类里面申明了2个变量，在主方法（Main）中我创建了一个类的对象（实例，对象是累的实例）。这里我们就可以通过对象来访问类里面的变量来显示出来。

Main方法是c#里面的一个默认方法，所有应用程序的主入口方法。在主方法中我们申明一个类的对象并使用它。通过对象我们能够访问类中的可访问的方法和变量。可以说是进入每个房子的大门。通过大门我们就能够进入我们自己的房子里面。相似的，运行程序，就会有一个默认的入口函数。入口函数就是启动程序执行的关键点。不论我们执行的是控制台程序还是Windows应用程序，入口函数是最先执行的。从入口函数，我们可以创建一个类的对象来调用类里面的方法。

 4. 方法或函数(Method or Functions)

    方法是一组代码语句。我们看看上面例子中的方法代码：

class ShanuHouseClass
    {
        int noOfTV = ;
        public String yourTVName = "SAMSUNG";
 
        public void myFirstMethod()
        {
            Console.WriteLine("You Have total " + noOfTV + "no of TV :");
            Console.WriteLine("Your TV Name is :" + yourTVName);
            Console.ReadLine();
        }
 
        static void Main(string[] args)
        {
            ShanuHouseClass objHouseOwner = new ShanuHouseClass();
            objHouseOwner.myFirstMethod();
        }

注意：很多开发人员都很疑惑 方法和函数有什么不同。两个都是一样的。在这篇文章中我用方法代替函数。然而函数和方法有一点不同。在面向对象语言比如“c#，java”等，我们用的叫做方法。在非面向对象语言比如“C”，我们成函数。

方法有什么用途？

另一个实时例子我们用我们的手机号码来解释。比如我们有一部手机，我们里面存了好多歌曲。然而我们经常听的确实一下选中的歌曲。每次都很难选中我们自己最喜欢的歌曲。选中困难症哈哈~~

替代选择的就是 重复的听列表里的歌曲。列表里我们可以添加我们所喜爱的歌曲，只需要轻轻的点击列表，就可以聆听美妙的音乐。这让我们做起来简单，不需要每次重复的去搜索喜爱的歌曲。方法就像歌曲列表一样，我们可以在方法里面写一些经常要用的，要重复使用的代码，每次需要的时候，只需要调用即可，不需要重复的写代码。

下面我们来讲解一些方法的细节：

假如在一个大房子里，我们有一个大房间，和几个小房间。每个房间有不同的布置（东西，装饰）。相似的，在一个类里我们可以写一个或多个方法。

在一个房子里可以有几间卧室，他们的名字都叫卧室，但是每个卧室有不同的尺寸，颜色等。就是说，相同的卧室有不同的类型。相似的，在类中我们可以定义几个方法名相同，但是参数不同的方法。这在面向对象编程中就叫做“多态”。文章后面会详细介绍多态。

方法的语法：

Access-Modifiers Return-Type Method-Name (Parameter-List)

访问修饰符-返回类型-方法名（参数列表）

Access-Modifiers:后面会有详细的讲解

Return-Type:如果我们的方法有返回值，那么我们就要定义返回值的类型，比如string，int 等，如果不需要返回值，那么我们就使用“Void”类型。

Method-Name:我们要给我们创建的每一个方法 都要有名称。

Parameter-List:参数列表或参数，我们用来传递给函数。

接下来是一个方法的例子-->

Void类型的方法：void是一个关键字，用来表示不需要返回数据的方法。看下面的方法，在这个方法中我们显示我们所有的输出用"Console.WriteLine",使用"ReadLine()"来等待输入。这个方法包含了输出和输入，但是没有返回任何值。

 // Function with void and no parameter  -- here void means no return type
         public void veranda()
         {
             Console.WriteLine("Welcome to Veranda");
             Console.WriteLine("How Many Chairs Do you have in your Veranda");
             NoofChair = Convert.ToInt32(Console.ReadLine());
             Console.WriteLine("I have total " + NoofChair + " Chairs in my Veranda");
         }

有返回值类型的方法：

有返回值类型的方法，会返回一个结果供程序中使用。比如，下面有一个返回字符串(string)类型的方法TVNAME。我们可以假设在我们家里，客厅里有一台电视，在父母卧室有一台电视，在孩子房间也有一台电视，每个房间的电视品牌都不一样。假设我们想知道每个房间里面的电视品牌名称，我们需要写三次代码来获得。为了减少重复代码，我们可以给方法一个返回值。

 // Function with Return type as String
         public string TVNAME()
         {
             Console.WriteLine("Enter Your TV Brand NAME");
             YOURTVName = Console.ReadLine();
             return YOURTVName;
         }

带参数的方法：

到这之前，我们写的方法都是没有参数的。参数被用来传递数据到方法中，以便更好地执行方法。

比如我们家里要刷墙壁，每个人对自己的卧室墙壁颜色有不同的选择。我们就可以把每个人的名字，和选择的颜色以参数的方式传递到方法中。

 //Function with parameter
         public void BedRoom(String nameandColor)
         {
             Console.WriteLine(nameandColor);
         }

  // Same Function Name with Different Paramenter
         public void BedRoom(String MemberName,String Color)
         {
             Console.WriteLine(MemberName + " Like " + Color + "Color");
         }

相同的方法名称，不同的参数我们称为重载（OverLoad）。

上面的2个方法就是重载，有相同的方法名，不同的参数。

下面是完整的代码：

 class ShanuHouseClass1
     {
         int NoofChair = ;
        public String YOURTVName;
        private Boolean DoyouHaveTV = true;
 
         // Function with void and no parameter  -- here void means no return type
         public void veranda()
         {
             Console.WriteLine("Welcome to Veranda");
             Console.WriteLine("How Many Chairs Do you have in your Veranda");
             NoofChair = Convert.ToInt32(Console.ReadLine());
             Console.WriteLine("I have total " + NoofChair + " Chairs in my Veranda");
         }
 
         // Function with Return type as String
         public string TVNAME()
         {
             Console.WriteLine("Enter Your TV Brand NAME");
             YOURTVName = Console.ReadLine();
             return YOURTVName;
         }
 
         //Function with parameter
         public void BedRoom(String nameandColor)
         {
             Console.WriteLine(nameandColor);
         }
 
         // Same Function Name with Different Paramenter
         public void BedRoom(String MemberName,String Color)
         {
             Console.WriteLine(MemberName + " Like " + Color + "Color");
         }
 
         static void Main(string[] args)
         {
             ShanuHouseClass1 objHouseOwner = new ShanuHouseClass1();
 
             objHouseOwner.veranda();
             String returnvalue = objHouseOwner.TVNAME();
            Console.WriteLine("Your TV BRAND NAME IS: "+returnvalue);
            objHouseOwner.BedRoom("My Name is Shanu I like Lavender color");
            objHouseOwner.BedRoom("My Name is Afraz I like Light Blue color");
            objHouseOwner.BedRoom("SHANU", "Lavender");
             Console.ReadLine();
 
         }
     }

下面是输出的结果集：

5.访问修饰符

访问修饰符就是对方法，类，属性，变量等访问的安全限制。

private

public

internal

protected

protected internal

这6个访问修饰符是c#中方法，类，变量常用的访问修饰符。

Private:

继续我们的房间例子。家里有一个保安，他的职责就是守在房子的入口，他不能进入房子做任何事。此时我们可以创建一个SecurityGuardClass申明一个变量和一个私有方法。

Public:

房子的主人对class来说是public 的，能够访问所有与该类相关的任何东西。他们对房子里的东西没有任何限制。

Protected: 

只有main类和派生类能够访问 protected 类型的方法和变量。比如仆人和客人是Protected.仆人能够到所有房间打扫等做其他的事情。然而他们受到某些限制的比如不能再主人的床上睡觉。

Internal:

变量或方法被限制在一个项目中。比如我们的项目不止一个类，在某个类中申明一个internal 变量，让我们看下面的例子。

 public class sampleInternalClass
     {
         internal String myInternal = "Iam Internal Variable";
     }
     class ShanuHouseClass
     {
         int noOfTV = ;
         public String yourTVName = "SAMSUNG";
 
         public void myFirstMethod()
         {
             Console.WriteLine("You Have total " + noOfTV + "no of TV :");
             Console.WriteLine("Your TV Name is :" + yourTVName);
 
         }
 
         static void Main(string[] args)
         {
             ShanuHouseClass objHouseOwner = new ShanuHouseClass();
             objHouseOwner.myFirstMethod();
             sampleInternalClass intObj = new sampleInternalClass();
 
             Console.WriteLine("Internal Variable Example :" + intObj.myInternal);
             Console.ReadLine();
 
         }
     }

Protected Internal:

Protected Internal 类型的变量或方法被限制在一个工程中的类或继承类。接下来是一个Internal变量的工程的例子，在这个例子中我们用到了继承。后面章节会详细解说继承。

 public class sampleProtectedInternalClass
     {
         protected internal String myprotectedInternal = "Iam Protected Internal Variable";
 
         public void protectedInternalMethod()
         {
             Console.WriteLine("Protected Internal Variable Example :" + myprotectedInternal);
         }
     }
     public class derivedClass : sampleProtectedInternalClass
     {
         public void derivedprotectedInternal()
         {
             Console.WriteLine("Derived Protected Internal Variable Example :" + myprotectedInternal);
         }
     }
     class ShanuHouseClass
     {
         int noOfTV = ;
         public String yourTVName = "SAMSUNG";
 
         public void myFirstMethod()
         {
             Console.WriteLine("You Have total " + noOfTV + "no of TV :");
             Console.WriteLine("Your TV Name is :" + yourTVName);
 
         }
 
         static void Main(string[] args)
         {
             ShanuHouseClass objHouseOwner = new ShanuHouseClass();
             objHouseOwner.myFirstMethod();
             sampleProtectedInternalClass intObj = new sampleProtectedInternalClass();
 
             intObj.protectedInternalMethod();
 
             derivedClass proIntObj = new derivedClass();
             proIntObj.derivedprotectedInternal();
             Console.ReadLine();
 
         }
     }

注意：主函数main和主要做的事情我们需要先了解封装，抽象，多态和继承。后面章节详细解说。

~~初次翻译，语言组织能力差，自己都觉得尴尬，继续努力，一步步提高 。今天有点事儿，先翻译前面这些。重头戏还在后头，预知后事如何，且听下回分解。