C#基础 类（class）

转：c#中类和对象详解 - 孔小爽 - 博客园 (cnblogs.com)

类 (class) 是最基础的 C# 类型。类是一个数据结构，将状态（字段）和操作（方法和其他函数成员）组合在一个单元中。

类为动态创建的类实例 (instance) 提供了定义，实例也称为对象 (object)。

P:万物皆对象，实例是对象中的一种，eg创建类的一个实例，这个实例叫实例对象

类支持继承 (inheritance) 和多态性 (polymorphism)，这是派生类 (derived class) 可用来扩展和专用化基类 (base class) 的机制。

类的属性  类的修饰符  类的名称  （该类实现的接口）

public    class     Point   （，）

{
public int x, y;

public Point(int x, int y) {
     this.x = x;
     this.y = y;
}
}

类的实例使用 new 运算符创建，该运算符为新的实例分配内存，调用构造函数初始化该实例，并返回对该实例的引用。下面的语句创建两个 Point 对象，并将对这两个对象的引用存储在两个变量中：

Point p1 = new Point(0, 0);
Point p2 = new Point(10, 20);

当不再使用对象时，该对象占用的内存将自动收回。在 C# 中，没有必要也不可能显式释放分配给对象的内存。

• 成员：

类的成员或者是静态成员 (static member)，或者是实例成员 (instance member)。静态成员属于类，实例成员属于对象（类的实例）。（P:类class不分静态实例）

成员	说明
常量	与类关联的常数值
字段	类的变量
方法	类可执行的计算和操作
属性	与读写类的命名属性相关联的操作
索引器	与以数组方式索引类的实例相关联的操作
事件	可由类生成的通知
运算符	类所支持的转换和表达式运算符
构造函数	初始化类的实例或类本身所需的操作
析构函数	在永久丢弃类的实例之前执行的操作
类型	类所声明的嵌套类型

• 可访问性

类的每个成员都有关联的可访问性，它控制能够访问该成员的程序文本区域。有五种可能的可访问性形式。下表概述了这些可访问性。

 

可访问性	含义
public	访问不受限制
protected	访问仅限于此类和从此类派生的类
internal	访问仅限于此程序
protected internal	访问仅限于此程序和从此类派生的类
private	访问仅限于此类

• 基类

类声明可通过在类名称后面加上一个冒号和基类的名称来指定一个基类。省略基类的指定等同于从类型 object 派生。在下面的示例中，Point3D 的基类为 Point，而 Point 的基类为 object：

public class Point
{
public int x, y;

public Point(int x, int y) {
     this.x = x;
     this.y = y;
}
}

public class Point3D: Point
{
public int z;

public Point3D(int x, int y, int z): Point(x, y) {
     this.z = z;
}
}

一个类继承它的基类的成员。继承意味着一个类隐式地包含其基类的所有成员，但基类的构造函数除外。派生类能够在继承基类的基础上添加新的成员，但是它不能移除继承成员的定义。在前面的示例中，Point3D 类从 Point 类继承了 x 字段和 y 字段，每个 Point3D 实例都包含三个字段 x、y 和 z。

从某个类类型到它的任何基类类型存在隐式的转换。因此，类类型的变量可以引用该类的实例或任何派生类的实例。例如，对于前面给定的类声明，Point 类型的变量既可以引用 Point 也可以引用 Point3D：

Point a = new Point(10, 20);
Point b = new Point3D(10, 20, 30);

• 字段

字段是与类或类的实例关联的变量。

使用 static 修饰符声明的字段定义了一个静态字段 (static field)。一个静态字段只标识一个存储位置。对一个类无论创建了多少个实例，它的静态字段永远都只有一个副本。

不使用 static 修饰符声明的字段定义了一个实例字段 (instance field)。类的每个实例都包含了该类的所有实例字段的一个单独副本。

在下面的示例中，Color 类的每个实例都有实例字段 r、g 和 b 的单独副本，但是 Black、White、Red、Green 和 Blue 静态字段只存在一个副本：

public class Color
{
public static readonly Color Black = new Color(0, 0, 0);
public static readonly Color White = new Color(255, 255, 255);
public static readonly Color Red = new Color(255, 0, 0);
public static readonly Color Green = new Color(0, 255, 0);
public static readonly Color Blue = new Color(0, 0, 255);

private byte r, g, b;

public Color(byte r, byte g, byte b) {
     this.r = r;
     this.g = g;
     this.b = b;
}
}

如上面的示例所示，可以使用 readonly 修饰符声明只读字段 (read-only field)。给 readonly 字段的赋值只能作为字段声明的组成部分出现，或在同一类中的实例构造函数或静态构造函数中出现。

• 方法

方法 (method) 是一种用于实现可以由对象或类执行的计算或操作的成员。静态方法 (static method) 通过类来访问。实例方法 (instance method) 通过类的实例来访问。

方法具有一个参数 (parameter) 列表（可能为空），表示传递给该方法的值或变量引用；方法还具有一个返回类型 (return type)，指定该方法计算和返回的值的类型。如果方法不返回值，则其返回类型为 void。

方法的签名 (signature) 在声明该方法的类中必须唯一。方法的签名由方法的名称及其参数的数目、修饰符和类型组成。方法的签名不包含返回类型

• 静态方法和实例方法

使用 static 修饰符声明的方法为静态方法 (static method)。静态方法不对特定实例进行操作，并且只能访问静态成员。

不使用 static 修饰符声明的方法为实例方法 (instance method)。实例方法对特定实例进行操作，并且能够访问静态成员和实例成员。在调用实例方法的实例上，可以通过 this 显式地访问该实例。而在静态方法中引用 this 是错误的。

下面的 Entity 类具有静态成员和实例成员。

class Entity
{
static int nextSerialNo;

int serialNo;

public Entity() {
     serialNo = nextSerialNo++;
}

public int GetSerialNo() {
     return serialNo;
}

public static int GetNextSerialNo() {
     return nextSerialNo;
}

public static void SetNextSerialNo(int value) {
     nextSerialNo = value;
}
}

每个 Entity 实例都包含一个序号（并且假定这里省略了一些其他信息）。Entity 构造函数（类似于实例方法）使用下一个可用的序号初始化新的实例。由于该构造函数是一个实例成员，它既可以访问 serialNo 实例字段，也可以访问 nextSerialNo 静态字段。

GetNextSerialNo 和 SetNextSerialNo 静态方法只可以访问 nextSerialNo 静态字段，但是如果访问 serialNo 实例字段就会产生错误。

下面的示例演示 Entity 类的使用。

using System;

class Test
{
static void Main() {
     Entity.SetNextSerialNo(1000);   //静态方法的使用

     Entity e1 = new Entity();
     Entity e2 = new Entity();

     Console.WriteLine(e1.GetSerialNo());             // Outputs "1000"
     Console.WriteLine(e2.GetSerialNo());             // Outputs "1001"
     Console.WriteLine(Entity.GetNextSerialNo());     // Outputs "1002"
}
}

注意：SetNextSerialNo 和 GetNextSerialNo 静态方法是在类上调用的，而 GetSerialNo 实例方法是在该类的实例上调用的。

• 构造函数

C# 支持两种构造函数：实例构造函数和静态构造函数。实例构造函数 (instance constructor) 是实现初始化类实例所需操作的成员。静态构造函数 (static constructor) 是一种用于在第一次加载类本身时实现其初始化所需操作的成员。

构造函数的声明如同方法一样，不过它没有返回类型，并且它的名称与其所属的类的名称相同。如果构造函数声明包含 static 修饰符，则它声明了一个静态构造函数。否则，它声明的是一个实例构造函数。

实例构造函数可以被重载。例如，List 类声明了两个实例构造函数，一个无参数，另一个接受一个 int 参数。实例构造函数使用 new 运算符进行调用。下面的语句分别使用 List 类的每个构造函数分配两个 List 实例。

List list1 = new List();
List list2 = new List(10);

实例构造函数不同于其他成员，它是不能被继承的。一个类除了其中实际声明的实例构造函数外，没有其他的实例构造函数。如果没有为某个类提供任何实例构造函数，则将自动提供一个不带参数的空的实例构造函数。

• 属性

属性 (propery) 是字段的自然扩展。属性和字段都是命名的成员，都具有相关的类型，且用于访问字段和属性的语法也相同。然而，与字段不同，属性不表示存储位置。相反，属性有访问器 (accessor)，这些访问器指定在它们的值被读取或写入时需执行的语句。

属性的声明与字段类似，不同的是属性声明以位于定界符 { 和 } 之间的一个 get 访问器和/或一个 set 访问器结束，而不是以分号结束。同时具有 get 访问器和 set 访问器的属性是读写属性 (read-write property)，只有 get 访问器的属性是只读属性 (read-only property)，只有 set 访问器的属性是只写属性 (write-only property)。

get 访问器相当于一个具有属性类型返回值的无参数方法。除了作为赋值的目标，当在表达式中引用属性时，将调用该属性的 get 访问器以计算该属性的值。

set 访问器相当于具有一个名为 value 的参数并且没有返回类型的方法。当某个属性作为赋值的目标被引用，或者作为 ++ 或 -- 的操作数被引用时，将调用 set 访问器，并传入提供新值的实参。（P:值被改变了）

List 类声明了两个属性 Count 和 Capacity，它们分别是只读属性和读写属性。下面是这些属性的使用示例。

object[] items;

int count;

 public int Count {
       get { return count; }
    }

 public string Capacity {
       get {
           return items.Length;
       }
       set {
           if (value < count) value = count;
           if (value != items.Length) {
              object[] newItems = new object[value];
              Array.Copy(items, 0, newItems, 0, count);
              items = newItems;
           }
       }
    }

 

List names = new List();
names.Capacity = 100;        // Invokes set accessor，value=100
int i = names.Count;             // Invokes get accessor
int j = names.Capacity;          // Invokes get accessor

与字段和方法相似，C# 同时支持实例属性和静态属性。静态属性使用 static 修饰符声明，而实例属性的声明不带该修饰符。

属性的访问器可以是虚的。当属性声明包括 virtual、abstract 或 override 修饰符时，修饰符应用于该属性的访问器。

• 索引器

索引器 (indexer) 是这样一个成员：它使对象能够用与数组相同的方式进行索引。索引器的声明与属性类似，不同的是该成员的名称是 this，后跟一个位于定界符 [ 和 ] 之间的参数列表。在索引器的访问器中可以使用这些参数。与属性类似，索引器可以是读写、只读和只写的，并且索引器的访问器可以是虚的。

该 List 类声明了单个读写索引器，该索引器接受一个 int 参数。该索引器使得通过 int 值对 List 实例进行索引成为可能。例如

List numbers = new List();
names.Add("Liz");
names.Add("Martha");
names.Add("Beth");
for (int i = 0; i < names.Count; i++) {
string s = (string)names[i];
names[i] = s.ToUpper();
}

索引器可以被重载，这意味着一个类可以声明多个索引器，只要它们的参数的数量和类型不同即可。

• 事件

事件 (event) 是一种使类或对象能够提供通知的成员。事件的声明与字段类似，不同的是事件的声明包含 event 关键字，并且类型必须是委托类型。

在声明事件成员的类中，事件的行为就像委托类型的字段（前提是该事件不是抽象的并且未声明访问器）。该字段存储对一个委托的引用，该委托表示已添加到该事件的事件处理程序。如果尚未添加事件处理程序，则该字段为 null。

List 类声明了一个名为 Changed 的事件成员，它指示有一个新的项已被添加到列表中。Changed 事件由 OnChanged 虚方法引发，后者先检查该事件是否为 null（表明没有处理程序）。“引发一个事件”与“调用一个由该事件表示的委托”完全等效，因此没有用于引发事件的特殊语言构造。

客户端通过事件处理程序 (event handler) 来响应事件。事件处理程序使用 += 运算符添加，使用 -= 运算符移除。下面的示例向 List 类的 Changed 事件添加一个事件处理程序。

public event EventHandler Changed;

using System;

class Test
{
static int changeCount;

static void ListChanged(object sender, EventArgs e) {
     changeCount++;
}

static void Main() {
     List names = new List();
     names.Changed += new EventHandler(ListChanged);
     names.Add("Liz");
     names.Add("Martha");
     names.Add("Beth");
     Console.WriteLine(changeCount);    // Outputs "3"
}
}

对于要求控制事件的底层存储的高级情形，事件声明可以显式提供 add 和 remove 访问器，它们在某种程度上类似于属性的 set 访问器。

•  运算符

运算符 (operator) 是一种类成员，它定义了可应用于类实例的特定表达式运算符的含义。可以定义三种运算符：一元运算符、二元运算符和转换运算符。所有运算符都必须声明为 public 和 static。

List 类声明了两个运算符 operator == 和 operator !=，从而为将那些运算符应用于 List 实例的表达式赋予了新的含义。具体而言，上述运算符将两个 List 实例的相等关系定义为逐一比较其中所包含的对象（使用所包含对象的 Equals 方法）。下面的示例使用 == 运算符比较两个 List 实例。

  public static bool operator ==(List a, List b) {
       return Equals(a, b);
    }

    public static bool operator !=(List a, List b) {
       return !Equals(a, b);
    }

using System;

class Test
{
static void Main() {
     List a = new List();
     a.Add(1);
     a.Add(2);
     List b = new List();
     b.Add(1);
     b.Add(2);
     Console.WriteLine(a == b);      // Outputs "True"
     b.Add(3);
     Console.WriteLine(a == b);      // Outputs "False"
}
}

第一个 Console.WriteLine 输出 True，原因是两个列表包含的对象数目和值均相同。如果 List 未定义 operator ==，则第一个 Console.WriteLine 将输出 False，原因是 a 和 b 引用的是不同的 List 实例。

•  析构函数

析构函数 (destructor) 是一种用于实现销毁类实例所需操作的成员。析构函数不能带参数，不能具有可访问性修饰符，也不能被显式调用。垃圾回收期间会自动调用所涉及实例的析构函数。

垃圾回收器在决定何时回收对象和运行析构函数方面允许有广泛的自由度。具体而言，析构函数调用的时机并不是确定的，析构函数可能在任何线程上执行。由于这些以及其他原因，仅当没有其他可行的解决方案时，才应在类中实现析构函数。

• 虚方法、重写方法和抽象方法

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

在调用一个虚方法时，该调用所涉及的那个实例的运行时类型 (runtime type) 确定了要被调用的究竟是该方法的哪一个实现。在非虚方法调用中，实例的编译时类型 (compile-time type) 是决定性因素。

虚方法可以在派生类中重写 (override)。当某个实例方法声明包括 override 修饰符时，该方法将重写所继承的具有相同签名的虚方法。虚方法声明用于引入新方法，而重写方法声明则用于使现有的继承虚方法专用化（通过提供该方法的新实现）。

抽象 (abstract) 方法是没有实现的虚方法。抽象方法使用 abstract 修饰符进行声明，并且只有在同样被声明为 abstract 的类中才允许出现。抽象方法必须在每个非抽象派生类中重写。

下面的示例声明一个抽象类 Expression，它表示一个表达式树节点；它有三个派生类 Constant、VariableReference 和 Operation，它们分别实现了常量、变量引用和算术运算的表达式树节点。

using System;
using System.Collections;

public abstract class Expression
{
public abstract double Evaluate(Hashtable vars);
}

//常量

public class Constant: Expression
{
double value;

public Constant(double value) {
     this.value = value;
}

public override double Evaluate(Hashtable vars) {
     return value;
}
}

//变量

public class VariableReference: Expression
{
string name;

public VariableReference(string name) {
     this.name = name;
}

public override double Evaluate(Hashtable vars) {
     object value = vars[name];
     if (value == null) {
        throw new Exception("Unknown variable: " + name);
     }
     return Convert.ToDouble(value);
}
}

//操作符

public class Operation: Expression
{
Expression left;
char op;
Expression right;

public Operation(Expression left, char op, Expression right) {
     this.left = left;
     this.op = op;
     this.right = right;
}

public override double Evaluate(Hashtable vars) {
     double x = left.Evaluate(vars);
     double y = right.Evaluate(vars);
     switch (op) {
        case '+': return x + y;
        case '-': return x - y;
        case '*': return x * y;
        case '/': return x / y;
     }
     throw new Exception("Unknown operator");
}
}

上面的四个类可用于为算术表达式建模。例如，使用这些类的实例，表达式 x + 3 可如下表示。

Expression e = new Operation(
new VariableReference("x"),
'+',
new Constant(3));

Expression 实例的 Evaluate 方法将被调用，以计算给定的表达式的值，从而产生一个 double 值。该方法接受一个包含变量名称（作为哈希表项的键）和值（作为项的值）的 Hashtable 作为参数。Evaluate 方法是一个虚抽象方法，意味着非抽象派生类必须重写该方法以提供具体的实现。

Constant 的 Evaluate 实现只是返回所存储的常量。VariableReference 的实现在哈希表中查找变量名称，并返回产生的值。Operation 的实现先对左操作数和右操作数求值（通过递归调用它们的 Evaluate 方法），然后执行给定的算术运算。

下面的程序使用 Expression 类，对于不同的 x 和 y 值，计算表达式 x * (y + 2) 的值。

using System;
using System.Collections;

class Test
{
static void Main() {

     Expression e = new Operation(
        new VariableReference("x"),
        '*',
        new Operation(
            new VariableReference("y"),
            '+',
            new Constant(2)
        )
     );

     Hashtable vars = new Hashtable();

     vars["x"] = 3;
     vars["y"] = 5;
     Console.WriteLine(e.Evaluate(vars));      // Outputs "21"

    vars["x"] = 1.5;
     vars["y"] = 9;
     Console.WriteLine(e.Evaluate(vars));      // Outputs "16.5"
   }
}