C#类（Class）

C#是一个面向对象的语言，所以能够理解什么是对象时，你已经成功了一半。对象是类的实例。构成类的方法和变量称为类的成员。举个简单的例子：我们总说人类、人类，所以可以把人当做一个类；而每个人的高矮胖瘦就属于我们的属性，人会吃饭、运功、工作等这些是我们的方法。当我们实例化这个类时，就生成了一个对象(人)；

类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。下面是类定义的一般形式：

// <访问修饰符> class class类名
 class  class_name
{
    // 成员属性
      variable1;
	// 成员方法
      methodN(parameter_list)
    {
        // method body
    }
}

注意：

• 访问标识符 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
• 数据类型 指定了变量的类型，返回类型 指定了返回的方法返回的数据类型。
• 如果要访问类的成员，你要使用点（.）运算符。
• 点运算符链接了对象的名称和成员的名称。

使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。

特征：

1. 类的静态成员是属于类而不属于对象，静态成员只存在一个，所以他不是类的单个对象所有。
2. 静态方法不能作用于对象，静态方法中不能直接使用实例成员，必须要通过对象名引用访问，但是可以直接访问本类的静态成员
3. 类的非静态成员函数中可以引用类的静态成员。反之不可以。
4. 父类中定义了静态成员，则整个继承体系中只有一个这样的成员，无论派生出多少个子类。静态成员是存储在全局区的。
5. 静态的成员速度快，但占内存，就像数据的缓存一样，经常使用的数据我们应该将它们缓存。

成员属性是一个类中的变量属性，可以在函数中访问和使用。并且保持私有性来实现封装。

成员函数是一个在类定义中有它的定义或原型的函数，就像其他变量一样。作为类的一个成员，它能在类的任何对象上操作，且能访问该对象的类的所有成员。

通过不同访问修饰符创建的成员属性和方法，有这不同的访问作用域。这个就要求对于访问修饰符的深入了解。

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。构造函数的名称与类的名称完全相同，它没有任何返回类型。

注意：默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。

class Person
{
	// 参数化构造函数
	public Person(string serial)
	{
     	Console.WriteLine("编号：{0}人类已创建", serial);
    }
}

类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。

析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

class Person
{
	// 参数化构造函数
	public Person(string serial)
	{
     	Console.WriteLine("编号：{0}人类已创建", serial);
    }
    // 析构函数
	~Person()
	{
     	Console.WriteLine("当前人类已消失！");
    }
}

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

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

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

class <派生类名称> : <基类名称>

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

using System;
namespace testDemo
{
   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);
      }
   }
   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();
      }
   }
}

多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。

C# 不支持多重继承。但是，您可以使用接口来实现多重继承。下面的程序演示了这点：

class Shape
{
  public void setLen(int w, int h)
  {
     width = w;
     height = h;
  }
  protected int width;
  protected int height;
}

// 基类 PaintCost
public interface PaintCost
{
   int getCost(int area);

}
// 派生类
class Rectangle : Shape, PaintCost
{
  public int getArea()
  {
    return (width * height);
  }
  public int getCost(int area)
    {
       return area * 70;
    }
   }
class RectangleTester
{
  static void Main(string[] args)
  {
     Rectangle Rect = new Rectangle();
     int area;
     Rect.setLen(55);
     area = Rect.getArea();
     // 打印对象的面积
     Console.WriteLine("面积： {0}",  Rect.getArea());
     Console.WriteLine("成本： ${0}" , Rect.getCost(area));
     Console.ReadKey();
  }
}