C#简介-类和对象_

1、C#简介-类和对象_ 类(class)是C#类型中最基础的类型。类是一个数据结构，将状态(字段)和行为(方法和其他函数成员)组合在一个单元中。类供应了用于动态创建类实例的定义，也就是对象(object)。类支持继承(inheritance)和多态(polymorphism)，即派生类能够扩展和特别化基类的机制。 用法类声明可以创建新的类。类声明以一个声明头开头，其组成方式如下：先是指定类的特性和修饰符，后跟类的名字，基类(假如有的话)的名字，以及被该类实现的接口名。声明头后面就是类体了，它由一组包含在大括号()中的成员声明组成。 下面是一个名为Point的简洁类的声明： public clas

2、s 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#中，没有必要也不行能显式地释放对象。 1.6.1 成员 类的成员或者是静态成员(static membe

3、r)，或者是实例成员(instance member)。静态成员属于类，实例成员属于对象(类的实例)。 表1.6供应了类所能包含的各种成员的描述。 表1.6 类 的 成 员 成 员 描 述 常数 与类关联的常量值 字段 类的变量 方法 能够被类执行的计算和行为 属性 使对象能够读取和写入类的命名属性 索引器 使对象能够用与数组相同的方式进行索引 大事 能够被类产生的通知 运算符 类支持的转换和表达式运算符 构造函数 初始化类的实例或者类本身 析构函数 在永久销毁类的实例之前执行的行为 类型 被类声明的嵌套类型 1.6.2 可访问性 类的每个成员都有关联的可访问性，它掌握能够访问该成员的程序文本

4、区域。有5种可能的可访问性形式。表1.7概述了类的可访问性的意义。 表1.7 类的可访问性 可访问性 意 义 public 访问不受限制 protected 访问仅限于包含类或从包含类派生的类型 internal 访问仅限于当前程序集 protected internal 访问仅限于从包含类派生的当前程序集或类型 private 访问仅限于包含类 1.6.3 基类 类的声明可能通过在类名后加上冒号和基类的名字来指定一个基类译注4。省略基类等同于挺直从object类派生。在下面的示例中，Point3D的基类是Point，而Point的基类是object： public class Point p

5、ublic 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类继承了其基类的成员。继承意味着类将隐式地包含其基类的全部成员(除了基类的构造函数)。派生类能够在继承基类的基础上增加新的成员，但是它不能移除继承成员的定义。在前面的示例中，Point3D类从Point类中继承了x字段和y字段，并且每一个Poin

6、t3D实例都包含三个字段x，y和z。 从类类型到它的任何基类类型都存在隐式的转换。并且，类类型的变量能够引用该类的实例，或者任何派生类的实例。例如，对于前面给定的类声明，Point类型的变量能够引用Point实例或者Point3D实例： Point a = new Point(10, 20); Point b = new Point3D(10, 20, 30); 1.6.4 字段 字段是与对象或类相关联的变量。 当一个字段声明中含有static修饰符时，由该声明引入的字段为静态字段(static field)。它只标识了一个存储位置。不管创建了多少个类实例，静态字段都只会有一个副本。 当一个字

7、段声明中不含有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

8、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修饰符声明只读字段。给readonly

9、字段的赋值只能作为声明的组成部分消失，或者在同一类中的实例构造函数或静态构造函数中消失。 1.6.5 方法 方法(method)是一种用于实现可以由对象或类执行的计算或操作的成员。静态方法(static method)只能通过类来访问。实例方法(instance method)则要通过类的实例访问。 方法有一个参数(parameter)列表(可能为空)，表示传递给方法的值或者引用;方法还有返回类型(return type)，用于指定由该方法计算和返回的值的类型。假如方法不返回一个值，则它的返回类型为void。 在声明方法的类中，该方法的签名必需是惟一的。方法的签名由它的名称、参数的数目、每个参

10、数的修饰符和类型组成。返回类型不是方法签名的组成部分。 1.6.5.1 参数 参数用于将值或者引用变量传递给方法。当方法被调用时，方法的参数译注5从指定的自变量(argument)译注6得到它们实际的值。C#有4种参数：值参数、引用参数、输出参数和参数数组。 值参数(value parameter)用于输入参数的传递。值参数相当于一个局部变量，它的初始值是从为该参数所传递的自变量获得的。对值参数的修改不会影响所传递的自变量。 引用参数(reference parameter)用于输入和输出参数的传递。用于引用参数的自变量必需是一个变量，并且在方法执行期间，引用参数和作为自变量的变量所表示的是同

11、一个存储位置。引用参数用ref修饰符声明。下面的示例展现了ref参数的用法： using System; class Test static void Swap(ref int x, ref int y) int temp = x; x = y; y = temp; static void Main() int i = 1, j = 2; Swap(ref i, ref j); Console.WriteLine(0 1, i, j); /输出 2 1 输出参数(output parameter)用于输出参数的传递。输出参数类似于引用参数，不同之处在于调用方供应的自变量初始值无关紧要。输出参数

12、用out修饰符声明。下面的示例展现了out参数的用法： using System; class Test static void Divide(int x, int y, out int result, out int remainder) result = x / y; remainder = x % y; static void Main() int res, rem; Divide(10, 3, out res, out rem); Console.WriteLine(0 1, res, rem); /输出3 1 参数数组(parameter array)允许将可变长度的自变量列表传递给

13、方法。参数数组用params修饰符声明。只有方法的最终一个参数能够被声明为参数数组，而且它必需是一维数组类型。System.Console类的Write和WriteLine方法是参数数组应用的很好的例子。它们的声明形式如下： public class Console public static void Write(string fmt, params object args) . public static void WriteLine(string fmt, params object args) . . 在方法中用法参数数组时，参数数组表现得就像常规的数组类型参数一样。然而，带数组参数的

14、方法调用中，既可以传递参数数组类型的单个自变量，也可以传递参数数组的元素类型的若干自变量。对于后者的情形，数组实例将自动被创建，并且通过给定的自变量初始化。示例： Console.WriteLine(x=0 y=1 z=2, x, y, z); 等价于下面的语句： object args = new object3; args0 = x; args1 = y; args2 = z; Console.WriteLine(x=0 y=1 z=2, args); 1.6.5.2 方法体和局部变量 方法体指定方法调用时所要执行的语句。 方法体能够声明特定于该方法调用的变量。这样的变量被称为局部变量(l

15、ocal variable)。局部变量声明指定类型名、变量名，可能还有初始值。下面的示例声明白一个局部变量i，其初始值为0;另一个局部变量j没有初始值。 using System; class Squares static void Main() int i = 0; int j; while(i 10) j = i * i; Console.WriteLine(0 x 0 = 1, i, j); i = i + 1; C#要求局部变量在其值被获得之前明确赋值(definitely)。例如，假设前面的变量i的声明没有包含初始值，那么，在接下来对i的用法将导致编译器报告错误，缘由就是i在程序中没

16、有明确赋值。 方法能够用法return语句将掌握返回给它的调用方。假如方法是void的，则return语句不能指定表达式;假如方法是非void的，则return语句必需包含表达式，用于计算返回值。 1.6.5.3 静态方法和实例方法 若一个方法声明中含有static修饰符，则称该方法为静态方法(static method)。静态方法不对特定实例进行操作，只能访问静态成员。 若一个方法声明中没有static修饰符，则称该方法为实例方法(instance method)。实例方法对特定实例进行操作，既能够访问静态成员，也能够访问实例成员。在调用实例方法的实例上，可以用 this来访问该实例，而在静

17、态方法中引用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;

18、每一个Entity实例包含一个序列号(并且假定这里省略了一些其他信息)。Entity构造函数(类似于实例方法)用下一个有效的序列号初始化新的实例。由于构造函数是一个实例成员，所以，它既可以访问serialNo实例字段，也可以访问nextSerialNo静态字段。 GetNextSerialNo和SetNextSerialNo静态方法能够访问nextSerialNo静态字段，但是假如访问serialNo实例字段就会产生错误。 下面的示例展现了Entity类的用法： using System; class Test static void Main() Entity.SetNextSerialNo

19、(1000); Entity e1 = new Entity(); Entity e2 = new Entity(); Console.WriteLine(e1.GetSerialNo(); /输出1000 Console.WriteLine(e2.GetSerialNo(); /输出1001 Console.WriteLine(Entity.GetNextSerialNo(); /输出1002 留意，SetNextSerialNo和GetNextSerialNo静态方法通过类调用，而GetSerialNo实例成员则通过类的实例调用。 1.6.5.4 虚拟方法、重写方法和抽象方法 若一个实例方

20、法的声明中含有virtual修饰符，则称该方法为虚拟方法(virtual method)。若其中没有virtual修饰符，则称该方法为非虚拟方法(nonvirtual method)。 在一个虚拟方法调用中，该调用所涉及的实例的运行时类型(runtime type)确定了要被调用的毕竟是该方法的哪一个实现。在非虚拟方法调用中，实例的编译时类型(compile-time type)是决定性因素。 虚拟方法可以由派生类重写(override)译注7实现。当一个实例方法声明中含有override修饰符时，该方法将重写所继承的相同签名的虚拟方法。虚拟方法声明用于引入新方法，而重写方法声明则用于使现有的

21、继承虚拟方法专用化(通过供应该方法的新实现)。 抽象(abstract)方法是没有实现的虚拟方法。抽象方法的声明是通过abstract修饰符实现的，并且只允许在抽象类中用法抽象方法声明。非抽象类的派生类需要重写抽象方法。 下面的示例声明白一个抽象类Expression，它表示一个表达式树的节点;它有三个派生类Constant，VariableReference，Operation，它们实现了常数、变量引用和算术运算的表达式树节点。 using System; using System.Collections; public abstract class Expression public ab

22、stract 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.n

23、ame = name; public override double Evaluate(Hashtable vars) object value = varsname; 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

24、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

25、Exception(Unknown operator); 前面的4个类用于模型化算术表达式。例如，用法这些类的实例，表达式x+3能够被表示为如下的形式： Expression e = new Operation( new VariableReference(x), +, new Constant(3); Expression实例的Evaluate方法将被调用，以计算表达式的值，从而产生一个double值。该方法取得一个包含变量名(输入的键)和值(输入的值)的Hashtable作为其自变量。Evaluate方法是虚拟的抽象方法，意味着派生类必需重写它并供应实际的实现。 Evaluate方法的Co

26、nstant的实现只是返回保存的常数。VariableReference的实现在Hashtable中查找变量名，并且返回相应的值。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), *, ne

27、w Operation( new VariableReference(y), +, new Constant(2) ) ); Hashtable vars = new Hashtable(); Varsx = 3; Varsy = 5; Console.WriteLine(e.Evaluate(vars); /输出21 Varsx = 1.5; Varsy = 9; Console.WriteLine(e.Evaluate(vars); /输出16.5 1.6.5.5 方法重载 方法重载(Method overloading)允许在同一个类中采纳同一个名称声明多个方法，条件是它们的签名是惟一的

28、。当编译一个重载方法的调用时，编译器采纳重载决策(overload resolution)确定应调用的方法。重载决策找到最佳匹配自变量的方法，或者在没有找到最佳匹配的方法时报告错误信息。下面的示例展现了重载决策工作机制。在Main方法中每一个调用的说明说明白实际被调用的方法。 class Test static void F() Console.WriteLine(F(); static void F(object x) Console.WriteLine(F(object); static void F(int x) Console.WriteLine(F(int); static void

29、 F(double x) Console.WriteLine(F(double); static void F(double x, dpuble y) Console.WriteLine(F(double, double); static void Main() F(); /调用F() F(1); /调用F(int) F(1.0); /调用F(double) F(abc); /调用F(object) F(double)1); /调用F(double) F(object)1); /调用F(object) F(1, 1); /调用F(double, double) 如上例所示，总是通过自变量到参数

30、类型的显式的类型转换，来选择特定方法。 1.6.6 其他函数成员 类的函数成员(function member)是包含可执行语句的成员。前面部分所描述的方法是主要的函数成员。这一节商量其他几种C#支持的函数成员：构造函数、属性、索引器、大事、运算符、析构函数。 表1.8展现一个名为List的类，它实现一个可扩展的对象列表。这个类包含了最通用的几种函数成员的例子。 表1.8 类的函数成员示例 public class List const int defaultCapacity = 4; 常数 object items; int count; 字段 (续表) public List(): thi

31、s(defaultCapacity) public List(int capacity) items = new objectcapacity; 构造函数 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 objectvalue; Array.Copy(items, 0, newItems, 0, count);

32、 items = newItems; 属性 public object thisint index get return itemsindex; set itemsindex = value; OnListChange(); 索引器 public void Add(object item) if (count = Capacity) Capacity = count * 2; itemscount = item; count+; OnChanged(); protected virtual void OnChanged() if (Changed != null) Changed(this,

33、EventArgs.Empty); public override bool Equals(object other) return Equals (this,other as List ); static bool Equals ( List a,List b) if (a = null) return b = null; if (b = null | a.count != b.count) return false; for (int i = 0; i a.count; i+) if (!object.Equals(a.itemi, b.itemi) return false; 方法 pu

34、blic event EventHandler Changed; 大事 public static bool operator =(List a, List b) return Equals(a, b); public static bool operator !=(List a, List b) return !Equals(a, b); 运算符 1.6.6.1 构造函数 C#既支持实例构造函数，也支持静态构造函数。实例构造函数(instance constructor)是实现初始化类实例所需操作的成员。静态构造函数(static constructor)是一种在类首次加载时用于实现初始化类

35、本身所需操作的成员。 构造函数的声明犹如方法一样，不过，它没有返回类型，它的名字与包含它的类名一样。若构造函数的声明中包含static修饰符，则它声明白一个静态构造函数，否则声明实例构造函数。 实例构造函数能够被重载。例如，List声明白两个实例构造函数，一个不带参数，一个带有一个int参数。用法new运算符可以调用实例参数。下面的语句用法各个List类的构造函数创建了两个List实例。 List list1 = new List(); List list2 = new List(10); 实例构造函数不同于其他方法，它是不能被继承的。并且，一个类除了自己声明的实例构造函数外，不行能有其他的实

36、例构造函数。假如一个类没有声明任何实例构造函数，则会自动地为它供应一个默认的空的实例构造函数。 1.6.6.2 属性 属性(property)是字段的自然扩展，两者都是具有关联类型的命名成员，而且访问字段和属性的语法是相同的。然而，属性与字段不同，不表示存储位置。相反，属性有访问器(accessor)，这些访问器指定在它们的值被读取或写入时需执行的语句。 属性的声明类似于字段，不同之处在于属性的声明以定界符之间的get访问器和/或set访问器结束，而不是分号。同时包含get访问器和set访问器的属性称为读写属性(read-write property)。只具有get访问器的属性称为只读属性(r

37、ead-only property)。只具有set访问器的属性称为只写属性(write-only property)。 get访问器相当于一个具有属性类型返回值的无参数方法。除了作为赋值的目标外，当在表达式中引用属性时，会调用该属性的get访问器以计算该属性的值。 set访问器相当于一个具有单个名为value的参数和无返回类型的方法。当一个属性作为赋值的目标，或者作为+或-运算符的操作数被引用时，就会调用set访问器，所传递的自变量将供应新值。 List类声明白两个属性Count和Capacity，依次是只读和只写的。下面是用法这些属性的示例： List names = new List();

38、 names.Capacity = 100; /调用set访问器 int i = names.Count; /调用get访问器 int j = names.Capacity; /调用get访问器 与字段和方法类似，对于实例属性和静态属性，C#两者都支持。静态属性是声明中具有static修饰符，而实例属性则没有。 属性的访问器可以是虚拟的。当属性声明中包含virtual，abstract，override修饰符时，它们将运用到属性访问器。 1.6.6.3 索引器 索引器是这样一个成员：它使对象能够用与数组相同的方式进行索引。索引器的声明与属性很相像，不同之处在于成员的名字是this，后面的参数列

39、表是在定界符()之间。参数在索引器的访问器中是可用的。与属性类似，索引器可以是读写、只读、只写的，并且索引器的访问器也可以是虚拟的。 List类声明白单个读写索引器，接受一个int型的参数。通过索引器就可能用int值索引List实例。例如： List names = new List(); names.Add(Liz); names.Add(Martha); names.Add(Beth); for (int i = 0; i names.Count; i+) string s = (string) namesi; namesi = s.ToUpper(); 索引器能够被重载，意味着可以声明多

40、个索引器，只要它们的参数个数或类型不同。 1.6.6.4 大事 大事是使对象或类能够供应通知的成员。大事的声明与字段的类似，不同之处在于大事声明包含一个event关键字，并且大事声明的类型必需是托付类型。 在包含大事声明的类中，大事可以像托付类型的字段一样用法(这样的大事不能是 abstract，而且不能声明访问器)。该字段保存了一个托付的引用，表示大事处理程序已经被添加到大事上。假如尚未添加任何大事处理程序，则该字段为null。 List类声明白名为Changed的单个大事成员，Changed大事表明有一个新项添加到大事处理程序列表，它由OnChanged虚拟方法引发，它首先检查大事是否为n

41、ull(意思是没有大事处理程序)。引发大事的通知正好等价于调用大事所表示的托付因此，不需要特别的语言构件引发大事。 客户通过大事处理程序(event handler)响应大事。用法“+=”运算符添加或者用法“-=”移除大事处理程序。下面的示例添加一个大事处理程序到List类的Changed大事： using System; class Test static int changeCount; static void ListChanged(object sender, EventArgs e) changCount+; static void Main() List names = new L

42、ist(); names.Changed += new EventHandler(ListChanged); names.Add(Liz); names.Add(Martha); names.Add(Beth); Console.WriteLine(changeCount); /输出 3 对于要求掌握大事的底层存储的更高级场景译注8，大事的声明可以显式地供应add和remove访问器，它们在某种程度上类似于属性的set访问器。 1.6.6.5 运算符 运算符(operator)是一种函数成员，用来定义可应用于类实例的特定表达式运算符的含义。有三种运算符能够被定义：一元运算符、二元运算符和转换运

43、算符。全部的运算符必需声明为public和static。 List类声明白两个运算符，运算符 “=”和运算符 “!=”，并且向表达式给予新的含义，而这些表达式将这些运算符应用到List实例上。格外指出，这些运算符定义了两个List对象的相等比较，即用法它们的Equals方法进行比较。下面的示例用法“=”运算符比较两个List实例。 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

44、.WriteLine(a = b); /输出True b.Add(3); Console.WriteLine(a = b); /输出False 类(class)是C#类型中最基础的类型。类是一个数据结构，将状态(字段)和行为(方法和其他函数成员)组合在一个单元中。类供应了用于动态创建类实例的定义，也就是对象(object)。类支持继承(inheritance)和多态(polymorphism)，即派生类能够扩展和特别化基类的机制。 用法类声明可以创建新的类。类声明以一个声明头开头，其组成方式如下：先是指定类的特性和修饰符，后跟类的名字，基类(假如有的话)的名字，以及被该类实现的接口名。声明头后

45、面就是类体了，它由一组包含在大括号()中的成员声明组成。 下面是一个名为Point的简洁类的声明： 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); 当不再用法对象时，该对象所占的内存将

46、被自动回收。在C#中，没有必要也不行能显式地释放对象。 1.6.1 成员 类的成员或者是静态成员(static member)，或者是实例成员(instance member)。静态成员属于类，实例成员属于对象(类的实例)。 表1.6供应了类所能包含的各种成员的描述。 表1.6 类 的 成 员 成 员 描 述 常数 与类关联的常量值 字段 类的变量 方法 能够被类执行的计算和行为 属性 使对象能够读取和写入类的命名属性 索引器 使对象能够用与数组相同的方式进行索引 大事 能够被类产生的通知 运算符 类支持的转换和表达式运算符 构造函数 初始化类的实例或者类本身 析构函数 在永久销毁类的实例之前

47、执行的行为 类型 被类声明的嵌套类型 1.6.2 可访问性 类的每个成员都有关联的可访问性，它掌握能够访问该成员的程序文本区域。有5种可能的可访问性形式。表1.7概述了类的可访问性的意义。 表1.7 类的可访问性 可访问性 意 义 public 访问不受限制 protected 访问仅限于包含类或从包含类派生的类型 internal 访问仅限于当前程序集 protected internal 访问仅限于从包含类派生的当前程序集或类型 private 访问仅限于包含类 1.6.3 基类 类的声明可能通过在类名后加上冒号和基类的名字来指定一个基类译注4。省略基类等同于挺直从object类派生。在下

48、面的示例中，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类继承了其基类的成员。继承意味着类将隐式地包含其基类的全部成员(除了基类的构造函数)。派生类能够在继承基类的基础上增加新的成

49、员，但是它不能移除继承成员的定义。在前面的示例中，Point3D类从Point类中继承了x字段和y字段，并且每一个Point3D实例都包含三个字段x，y和z。 从类类型到它的任何基类类型都存在隐式的转换。并且，类类型的变量能够引用该类的实例，或者任何派生类的实例。例如，对于前面给定的类声明，Point类型的变量能够引用Point实例或者Point3D实例： Point a = new Point(10, 20); Point b = new Point3D(10, 20, 30); 1.6.4 字段 字段是与对象或类相关联的变量。 当一个字段声明中含有static修饰符时，由该声明引入的字段为

50、静态字段(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(b