后面的

类的方法

“方法”是包含一系列语句的代码块。在 C# 中，每个执行指令都是在方法的上下文中完成的。

方法在类或结构中声明，声明时，声明时需要指定访问级别、返回值、方法名称以及任何方法参数。方法参数放在括号中，并用逗号隔开。空括号表示方法不需要参数。下面的类包含五个方法：

class Test{
    void Method1() { }                      //无返回值、无参数的方法
    void Method2(int i) { }                 //无返回值、有一个参数的方法
    int Method3(bool b, string s) { }       //返回值为int、有二个参数的方法
    class class1 { }                        //定义一个类作为参数或者返回值
    class1 Method4(float f, class1 c) { }   //返回值为class、有二个参数的方法
}

继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了 属于（IS-A） 关系。例如，哺乳动物 属于（IS-A） 动物，狗 属于（IS-A） 哺乳动物，因此狗 属于（IS-A） 动物。

基类和派生类

一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和函数。

C# 中创建派生类的语法如下：

<访问修饰符符> class <基类>
{
 ...
}
class <派生类> : <基类>
{
 ...
}

假设，有一个基类 Shape，它的派生类是 Rectangle：

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }
 
   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      { 
         return (width * height); 
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
 
         Rect.setWidth(5);
         Rect.setHeight(7);
 
         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

总面积： 35

基类的初始化

派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。

下面的代码演示了这点：

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

长度： 4.5
宽度： 7.5
面积： 33.75
成本： 2362.5

多态

C# 多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态可以是静态的或动态的。在静态多态中，函数的响应是在编译时发生的。在动态多态中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。

静态多态

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

下面的代码演示了几个相同的函数 Add()，用于对不同个数参数进行相加处理：
 

using System;
namespace PolymorphismApplication
{
    public class TestData  
    {  
        public int Add(int a, int b, int c)  
        {  
            return a + b + c;  
        }  
        public int Add(int a, int b)  
        {  
            return a + b;  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            TestData dataClass = new TestData();
            int add1 = dataClass.Add(1, 2);  
            int add2 = dataClass.Add(1, 2, 3);
 
            Console.WriteLine("add1 :" + add1);
            Console.WriteLine("add2 :" + add2);  
        }  
    }  
}

下面的实例演示了几个相同的函数 print()，用于打印不同的数据类型：

using System;
namespace PolymorphismApplication
{
   class Printdata
   {
      void print(int i)
      {
         Console.WriteLine("输出整型: {0}", i );
      }
 
      void print(double f)
      {
         Console.WriteLine("输出浮点型: {0}" , f);
      }
 
      void print(string s)
      {
         Console.WriteLine("输出字符串: {0}", s);
      }
      static void Main(string[] args)
      {
         Printdata p = new Printdata();
         // 调用 print 来打印整数
         p.print(1);
         // 调用 print 来打印浮点数
         p.print(1.23);
         // 调用 print 来打印字符串
         p.print("Hello Runoob");
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

输出整型: 1
输出浮点型: 1.23
输出字符串: Hello Runoob

封装

C# 封装

封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。
Public 访问修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

下面的代码说明了这点：
 

using System;
 
namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        public double length;
        public double width;
 
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }// Rectangle 结束
 
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

长度： 4.5
宽度： 3.5
面积： 15.75

在上面的实例中，成员变量 length 和 width 被声明为 public，所以它们可以被函数 Main() 使用 Rectangle 类的实例 r 访问。

成员函数 Display() 和 GetArea() 可以直接访问这些变量。

成员函数 Display() 也被声明为 public，所以它也能被 Main() 使用 Rectangle 类的实例 r 访问。

Private 访问修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

下面的代码说明了这点：

using System;
 
namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        private double length;
        private double width;
 
        public void Acceptdetails()
        {
            Console.WriteLine("请输入长度：");
            length = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入宽度：");
            width = Convert.ToDouble(Console.ReadLine());
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }//end class Rectangle    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

请输入长度：
4.4
请输入宽度：
3.3
长度： 4.4
宽度： 3.3
面积： 14.52

在上面的实例中，成员变量 length 和 width 被声明为 private，所以它们不能被函数 Main() 访问。

成员函数 AcceptDetails() 和 Display() 可以访问这些变量。

由于成员函数 AcceptDetails() 和 Display() 被声明为 public，所以它们可以被 Main() 使用 Rectangle 类的实例 r 访问。

Protected 访问修饰符

Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。

Internal 访问修饰符

Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。
 

xml

什么是XML?

XML 指可扩展标记语言（EXtensible Markup Language）。
XML 是一种很像HTML的标记语言。
XML 的设计宗旨是传输数据，而不是显示数据。
XML 标签没有被预定义。您需要自行定义标签。
XML 被设计为具有自我描述性。
XML 是 W3C 的推荐标准。

XML的头部声明和注释怎么写？

声明
XML规定每一个正规的XML文档都应当由一个XML声明开始，不允许在前面再有其他字符，甚至空格或者注释。也就是说，XML声明必须是XML文档的第一个内容。

XML声明的一般语法格式为：
 

<?xml version="1.0" encoding="gb2312" standalone="yes"?>

这些属性已经在XML 1.0规范中做出了定义：
(1) 像所有的处理指令一样，XML声明也是由“<?”开始，以“?>”结束。

(2) “<?”之后的“xml”表示该文件 是一个XML文件。
(3) version——不能省略，其值必须为“1.0”。该属性用来保证对XML未来版本的支持。
(4) encoding——可选，其值必须是一种合法的字符编码，例如“UTF-8”、“UTF-16”或“ISO-8859-1”(即Latin-1字符编码)。所有XML解析器都要求至少支持“UTF-8”或“UTF-16”。如果没有包含这个属性，就假设是“UTF- 8”或“UTF-16”编码，这取决于开始的“<?xml”字符串的格式。采用哪种编码取决于文档中用到的字符集。

下面是几个常见的编码：
简体中文码：GB2312。
繁体中文码：BIG5。
压缩的Unicode编码：UTF-8。
压缩的UCS编码：UTF-16。
(5)standalone——可选，其值必须是“yes”或“no”。如果是“yes”，就意味着所有必需的实体声明都包含在文档中；如果是“no”，就意味着需要外部的DTD。

注释
在XML文档中适当地添加一些有意义的注释文字，可以大大增进文档的可读性。XML处理器通常会忽略文档中的这些注释语句，不对其作出任何处理。

XML文档中的注释语句格式如下：
 

  <!--注释文字-->

注意：
1、注释可以输入除了“–”之外的文字。

2、注释可以放在除元素标记之内的任何地方。

3、注释语句放在文档的元素内容之中是可以的。

4、可以对标记进行注释。

5、注释不能嵌套使用。

处理指令
处理指令（Processing Instruction，PI）是XML 文档中为XML 处理程序提供必要的处理信息的指令描述。XML 解析器会把它原封不动地传递给XML 应用程序，由应用程序来根据该指令进行必要处理，或者再把它原封不动地传递给下一个应用程序。
如例 XML声明之后的 <?xml-stylesheet type=“text/xsl” href=“1-4.xsl”?>。
处理指令一般具有下列语法格式：
<?处理指令名称 处理指令信息?>
说明：
1）处理指令必须以“<?”开始，以“?>”结束。
2）“处理指令名称” 可以是应用程序的实际名称，也可以是其它能被应用程序正确识别处理的名称。指令名的大小 写必须注意。
3）“处理指令信息”是指被传送到处理软件或脚本程序的信息，可由除了“?>”之外的任何连续字符组成。

XML 文档实例
 

<?xml version="1.0" encoding="UTF-8"?>
<note>
  <to>Tove</to>
  <from>Jani</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend!</body>
</note>