類（class）是c#類型中最基礎(chǔ)的類型。類是一個數(shù)據(jù)結(jié)構(gòu)，將狀態(tài)（字段）和行為（方法和其他函數(shù)成員）組合在一個單元中。類提供了用于動態(tài)創(chuàng)建類實例的定義，也就是對象（object）。類支持繼承（inheritance）和多態(tài)（polymorphism），即派生類能夠擴展和特殊化基類的機制。
使用類聲明可以創(chuàng)建新的類。類聲明以一個聲明頭開始，其組成方式如下：先是指定類的特性和修飾符，后跟類的名字，基類（如果有的話）的名字，以及被該類實現(xiàn)的接口名。聲明頭后面就是類體了，它由一組包含在大括號（{}）中的成員聲明組成。
下面是一個名為point的簡單類的聲明：
public class point
{
public int x, y;
public point(int x, int y){
this.x = x;
this.y = y;
}
}
使用new運算符創(chuàng)建類的實例，它將為新實例分配內(nèi)存，調(diào)用構(gòu)造函數(shù)初始化實例，并且返回對該實例的引用。下面的語句創(chuàng)建兩個point對象，并且將那些對象的引用保存到兩個變量中：
point p1 = new point(0, 0);
point p2 = new point(10, 20);
當不再使用對象時，該對象所占的內(nèi)存將被自動回收。在c#中，沒有必要也不可能顯式地釋放對象。
1.6.1 成員
類的成員或者是靜態(tài)成員（static member），或者是實例成員（instance member）。靜態(tài)成員屬于類，實例成員屬于對象（類的實例）。
表1.6提供了類所能包含的各種成員的描述。
表1.6 類 的 成 員
成 員
描 述
常數(shù)
與類關(guān)聯(lián)的常量值
字段
類的變量
方法
能夠被類執(zhí)行的計算和行為
屬性
使對象能夠讀取和寫入類的命名屬性
索引器
使對象能夠用與數(shù)組相同的方式進行索引
事件
能夠被類產(chǎn)生的通知
運算符
類支持的轉(zhuǎn)換和表達式運算符
構(gòu)造函數(shù)
初始化類的實例或者類本身
析構(gòu)函數(shù)
在永久銷毀類的實例之前執(zhí)行的行為
類型
被類聲明的嵌套類型
1.6.2 可訪問性
類的每個成員都有關(guān)聯(lián)的可訪問性，它控制能夠訪問該成員的程序文本區(qū)域。有5種可能的可訪問性形式。表1.7概述了類的可訪問性的意義。
表1.7 類的可訪問性
可訪問性
意 義
public
訪問不受限制
protected
訪問僅限于包含類或從包含類派生的類型
internal
訪問僅限于當前程序集
protected internal
訪問僅限于從包含類派生的當前程序集或類型
private
訪問僅限于包含類
1.6.3 基類
類的聲明可能通過在類名后加上冒號和基類的名字來指定一個基類譯注4。省略基類等同于直接從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類繼承了其基類的成員。繼承意味著類將隱式地包含其基類的所有成員（除了基類的構(gòu)造函數(shù)）。派生類能夠在繼承基類的基礎(chǔ)上增加新的成員，但是它不能移除繼承成員的定義。在前面的示例中，point3d類從point類中繼承了x字段和y字段，并且每一個point3d實例都包含三個字段x，y和z。
從類類型到它的任何基類類型都存在隱式的轉(zhuǎn)換。并且，類類型的變量能夠引用該類的實例，或者任何派生類的實例。例如，對于前面給定的類聲明，point類型的變量能夠引用point實例或者point3d實例：
point a = new point(10, 20);
point b = new point3d(10, 20, 30);
1.6.4 字段
字段是與對象或類相關(guān)聯(lián)的變量。
當一個字段聲明中含有static修飾符時，由該聲明引入的字段為靜態(tài)字段（static field）。它只標識了一個存儲位置。不管創(chuàng)建了多少個類實例，靜態(tài)字段都只會有一個副本。
當一個字段聲明中不含有static修飾符時，由該聲明引入的字段為實例字段（instance field）。類的每個實例都包含了該類的所有實例字段的一個單獨副本。
在下面的示例中，color類的每個實例都有r，g，b實例字段的不同副本，但是black，white，red，green和blue等靜態(tài)字段只有一個副本：
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修飾符聲明只讀字段。給readonly字段的賦值只能作為聲明的組成部分出現(xiàn)，或者在同一類中的實例構(gòu)造函數(shù)或靜態(tài)構(gòu)造函數(shù)中出現(xiàn)。
1.6.5 方法
方法（method）是一種用于實現(xiàn)可以由對象或類執(zhí)行的計算或操作的成員。靜態(tài)方法（static method）只能通過類來訪問。實例方法（instance method）則要通過類的實例訪問。
方法有一個參數(shù)（parameter）列表（可能為空），表示傳遞給方法的值或者引用；方法還有返回類型（return type），用于指定由該方法計算和返回的值的類型。如果方法不返回一個值，則它的返回類型為void。
在聲明方法的類中，該方法的簽名必須是惟一的。方法的簽名由它的名稱、參數(shù)的數(shù)目、每個參數(shù)的修飾符和類型組成。返回類型不是方法簽名的組成部分。
1.6.5.1 參數(shù)
參數(shù)用于將值或者引用變量傳遞給方法。當方法被調(diào)用時，方法的參數(shù)譯注5從指定的自變量（argument）譯注6得到它們實際的值。c#有4種參數(shù)：值參數(shù)、引用參數(shù)、輸出參數(shù)和參數(shù)數(shù)組。
值參數(shù)（value parameter）用于輸入?yún)?shù)的傳遞。值參數(shù)相當于一個局部變量，它的初始值是從為該參數(shù)所傳遞的自變量獲得的。對值參數(shù)的修改不會影響所傳遞的自變量。
引用參數(shù)（reference parameter）用于輸入和輸出參數(shù)的傳遞。用于引用參數(shù)的自變量必須是一個變量，并且在方法執(zhí)行期間，引用參數(shù)和作為自變量的變量所表示的是同一個存儲位置。引用參數(shù)用ref修飾符聲明。下面的示例展示了ref參數(shù)的使用：
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"
}
}
輸出參數(shù)（output parameter）用于輸出參數(shù)的傳遞。輸出參數(shù)類似于引用參數(shù)，不同之處在于調(diào)用方提供的自變量初始值無關(guān)緊要。輸出參數(shù)用out修飾符聲明。下面的示例展示了out參數(shù)的使用：
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"
}
}
參數(shù)數(shù)組（parameter array）允許將可變長度的自變量列表傳遞給方法。參數(shù)數(shù)組用params修飾符聲明。只有方法的最后一個參數(shù)能夠被聲明為參數(shù)數(shù)組，而且它必須是一維數(shù)組類型。system.console類的write和writeline方法是參數(shù)數(shù)組應用的很好的例子。它們的聲明形式如下：
public class console
{
public static void write(string fmt, params object[] args) {...}
public static void writeline(string fmt, params object[] args) {...}
...
}
在方法中使用參數(shù)數(shù)組時，參數(shù)數(shù)組表現(xiàn)得就像常規(guī)的數(shù)組類型參數(shù)一樣。然而，帶數(shù)組參數(shù)的方法調(diào)用中，既可以傳遞參數(shù)數(shù)組類型的單個自變量，也可以傳遞參數(shù)數(shù)組的元素類型的若干自變量。對于后者的情形，數(shù)組實例將自動被創(chuàng)建，并且通過給定的自變量初始化。示例：
console.writeline("x={0} y={1} z={2}", x, y, z);
等價于下面的語句：
object[] args = new object[3];
args[0] = x;
args[1] = y;
args[2] = z;
console.writeline("x={0} y={1} z={2}", args);
1.6.5.2 方法體和局部變量
方法體指定方法調(diào)用時所要執(zhí)行的語句。
方法體能夠聲明特定于該方法調(diào)用的變量。這樣的變量被稱為局部變量（local 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）。例如，假設(shè)前面的變量i的聲明沒有包含初始值，那么，在接下來對i的使用將導致編譯器報告錯誤，原因就是i在程序中沒有明確賦值。
方法能夠使用return語句將控制返回給它的調(diào)用方。如果方法是void的，則return語句不能指定表達式；如果方法是非void的，則return語句必須包含表達式，用于計算返回值。
1.6.5.3 靜態(tài)方法和實例方法
若一個方法聲明中含有static修飾符，則稱該方法為靜態(tài)方法（static method）。靜態(tài)方法不對特定實例進行操作，只能訪問靜態(tài)成員。
若一個方法聲明中沒有static修飾符，則稱該方法為實例方法（instance method）。實例方法對特定實例進行操作，既能夠訪問靜態(tài)成員，也能夠訪問實例成員。在調(diào)用實例方法的實例上，可以用 this來訪問該實例，而在靜態(tài)方法中引用this是錯誤的。
下面的entity類具有靜態(tài)和實例兩種成員：
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構(gòu)造函數(shù)（類似于實例方法）用下一個有效的序列號初始化新的實例。因為構(gòu)造函數(shù)是一個實例成員，所以，它既可以訪問serialno實例字段，也可以訪問nextserialno靜態(tài)字段。
getnextserialno和setnextserialno靜態(tài)方法能夠訪問nextserialno靜態(tài)字段，但是如果訪問serialno實例字段就會產(chǎn)生錯誤。
下面的示例展示了entity類的使用：
using system;
class test
{
static void main() {
entity.setnextserialno(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靜態(tài)方法通過類調(diào)用，而getserialno實例成員則通過類的實例調(diào)用。
1.6.5.4 虛擬方法、重寫方法和抽象方法
若一個實例方法的聲明中含有virtual修飾符，則稱該方法為虛擬方法（virtual method）。若其中沒有virtual修飾符，則稱該方法為非虛擬方法（nonvirtual method）。
在一個虛擬方法調(diào)用中，該調(diào)用所涉及的實例的運行時類型（runtime type）確定了要被調(diào)用的究竟是該方法的哪一個實現(xiàn)。在非虛擬方法調(diào)用中，實例的編譯時類型（compile-time type）是決定性因素。
虛擬方法可以由派生類重寫（override）譯注7實現(xiàn)。當一個實例方法聲明中含有override修飾符時，該方法將重寫所繼承的相同簽名的虛擬方法。虛擬方法聲明用于引入新方法，而重寫方法聲明則用于使現(xiàn)有的繼承虛擬方法專用化（通過提供該方法的新實現(xiàn)）。
抽象（abstract）方法是沒有實現(xiàn)的虛擬方法。抽象方法的聲明是通過abstract修飾符實現(xiàn)的，并且只允許在抽象類中使用抽象方法聲明。非抽象類的派生類需要重寫抽象方法。
下面的示例聲明了一個抽象類expression，它表示一個表達式樹的節(jié)點；它有三個派生類constant，variablereference，operation，它們實現(xiàn)了常數(shù)、變量引用和算術(shù)運算的表達式樹節(jié)點。
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");
}
}
前面的4個類用于模型化算術(shù)表達式。例如，使用這些類的實例，表達式x+3能夠被表示為如下的形式：
expression e = new operation(
new variablereference("x"),
'+',
new constant(3));
expression實例的evaluate方法將被調(diào)用，以計算表達式的值，從而產(chǎn)生一個double值。該方法取得一個包含變量名（輸入的鍵）和值（輸入的值）的hashtable作為其自變量。evaluate方法是虛擬的抽象方法，意味著派生類必須重寫它并提供實際的實現(xiàn)。
evaluate方法的constant的實現(xiàn)只是返回保存的常數(shù)。variablereference的實現(xiàn)在hashtable中查找變量名，并且返回相應的值。operation的實現(xiàn)則首先計算左操作數(shù)和右操作數(shù)的值（通過遞歸調(diào)用evaluate方法），然后執(zhí)行給定的算術(shù)運算。
下面的程序使用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)); //輸出 "21"
vars["x"] = 1.5;
vars["y"] = 9;
console.writeline(e.evaluate(vars)); //輸出 "16.5"
}
}
1.6.5.5 方法重載
方法重載（method overloading）允許在同一個類中采用同一個名稱聲明多個方法，條件是它們的簽名是惟一的。當編譯一個重載方法的調(diào)用時，編譯器采用重載決策（overload resolution）確定應調(diào)用的方法。重載決策找到最佳匹配自變量的方法，或者在沒有找到最佳匹配的方法時報告錯誤信息。下面的示例展示了重載決策工作機制。在main方法中每一個調(diào)用的注釋說明了實際被調(diào)用的方法。
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 f(double x) {
console.writeline("f(double)");
}
static void f(double x, dpuble y) {
console.writeline("f(double, double)");
}
static void main(){
f(); //調(diào)用f()
f(1); //調(diào)用f(int)
f(1.0); //調(diào)用f(double)
f("abc"); //調(diào)用f(object)
f((double)1); //調(diào)用f(double)
f((object)1); //調(diào)用f(object)
f(1, 1); //調(diào)用f(double, double)
}
}
如上例所示，總是通過自變量到參數(shù)類型的顯式的類型轉(zhuǎn)換，來選擇特定方法。
1.6.6 其他函數(shù)成員
類的函數(shù)成員（function member）是包含可執(zhí)行語句的成員。前面部分所描述的方法是主要的函數(shù)成員。這一節(jié)討論其他幾種c#支持的函數(shù)成員：構(gòu)造函數(shù)、屬性、索引器、事件、運算符、析構(gòu)函數(shù)。
表1.8展示一個名為list的類，它實現(xiàn)一個可擴展的對象列表。這個類包含了最通用的幾種函數(shù)成員的例子。
表1.8 類的函數(shù)成員示例
public class list
{
const int defaultcapacity = 4;
常數(shù)
object[] items;
int count;
字段
（續(xù)表）
public list(): this(defaultcapacity) {}
public list(int capacity) {
items = new object[capacity];
}
構(gòu)造函數(shù)
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;
}
}
}
屬性
public object this[int index] {
get {
return items[index];
}
set {
items[index] = value;
onlistchange();
}
}
索引器
public void add(object item) {
if (count == capacity) capacity = count * 2;
items[count] = item;
count++;
onchanged();
}
protected virtual void onchanged() {
if (changed != null) changed(this, 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.item[i], b.item[i])) {
return false;
}
}
}
方法
public 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 構(gòu)造函數(shù)
c#既支持實例構(gòu)造函數(shù)，也支持靜態(tài)構(gòu)造函數(shù)。實例構(gòu)造函數(shù)（instance constructor）是實現(xiàn)初始化類實例所需操作的成員。靜態(tài)構(gòu)造函數(shù)（static constructor）是一種在類首次加載時用于實現(xiàn)初始化類本身所需操作的成員。
構(gòu)造函數(shù)的聲明如同方法一樣，不過，它沒有返回類型，它的名字與包含它的類名一樣。若構(gòu)造函數(shù)的聲明中包含static修飾符，則它聲明了一個靜態(tài)構(gòu)造函數(shù)，否則聲明實例構(gòu)造函數(shù)。
實例構(gòu)造函數(shù)能夠被重載。例如，list聲明了兩個實例構(gòu)造函數(shù)，一個不帶參數(shù)，一個帶有一個int參數(shù)。使用new運算符可以調(diào)用實例參數(shù)。下面的語句使用各個list類的構(gòu)造函數(shù)創(chuàng)建了兩個list實例。
list list1 = new list();
list list2 = new list(10);
實例構(gòu)造函數(shù)不同于其他方法，它是不能被繼承的。并且，一個類除了自己聲明的實例構(gòu)造函數(shù)外，不可能有其他的實例構(gòu)造函數(shù)。如果一個類沒有聲明任何實例構(gòu)造函數(shù)，則會自動地為它提供一個默認的空的實例構(gòu)造函數(shù)。
1.6.6.2 屬性
屬性（property）是字段的自然擴展，兩者都是具有關(guān)聯(lián)類型的命名成員，而且訪問字段和屬性的語法是相同的。然而，屬性與字段不同，不表示存儲位置。相反，屬性有訪問器（accessor），這些訪問器指定在它們的值被讀取或?qū)懭霑r需執(zhí)行的語句。
屬性的聲明類似于字段，不同之處在于屬性的聲明以定界符{}之間的get訪問器和／或set訪問器結(jié)束，而不是分號。同時包含get訪問器和set訪問器的屬性稱為讀寫屬性（read-write property）。只具有g(shù)et訪問器的屬性稱為只讀屬性（read-only property）。只具有set訪問器的屬性稱為只寫屬性（write-only property）。
get訪問器相當于一個具有屬性類型返回值的無參數(shù)方法。除了作為賦值的目標外，當在表達式中引用屬性時，會調(diào)用該屬性的get訪問器以計算該屬性的值。
set訪問器相當于一個具有單個名為value的參數(shù)和無返回類型的方法。當一個屬性作為賦值的目標，或者作為++或--運算符的操作數(shù)被引用時，就會調(diào)用set訪問器，所傳遞的自變量將提供新值。
list類聲明了兩個屬性count和capacity，依次是只讀和只寫的。下面是使用這些屬性的示例：
list names = new list();
names.capacity = 100; //調(diào)用set訪問器
int i = names.count; //調(diào)用get訪問器
int j = names.capacity; //調(diào)用get訪問器
與字段和方法類似，對于實例屬性和靜態(tài)屬性，c#兩者都支持。靜態(tài)屬性是聲明中具有static修飾符，而實例屬性則沒有。
屬性的訪問器可以是虛擬的。當屬性聲明中包含virtual，abstract，override修飾符時，它們將運用到屬性訪問器。
1.6.6.3 索引器
索引器是這樣一個成員：它使對象能夠用與數(shù)組相同的方式進行索引。索引器的聲明與屬性很相似，不同之處在于成員的名字是this，后面的參數(shù)列表是在定界符（[]）之間。參數(shù)在索引器的訪問器中是可用的。與屬性類似，索引器可以是讀寫、只讀、只寫的，并且索引器的訪問器也可以是虛擬的。
list類聲明了單個讀寫索引器，接受一個int型的參數(shù)。通過索引器就可能用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) names[i];
names[i] = s.toupper();
}
索引器能夠被重載，意味著可以聲明多個索引器，只要它們的參數(shù)個數(shù)或類型不同。
1.6.6.4 事件
事件是使對象或類能夠提供通知的成員。事件的聲明與字段的類似，不同之處在于事件聲明包含一個event關(guān)鍵字，并且事件聲明的類型必須是委托類型。
在包含事件聲明的類中，事件可以像委托類型的字段一樣使用（這樣的事件不能是 abstract，而且不能聲明訪問器）。該字段保存了一個委托的引用，表示事件處理程序已經(jīng)被添加到事件上。如果尚未添加任何事件處理程序，則該字段為null。
list類聲明了名為changed的單個事件成員，changed事件表明有一個新項添加到事件處理程序列表，它由onchanged虛擬方法引發(fā)，它首先檢查事件是否為null（意思是沒有事件處理程序）。引發(fā)事件的通知正好等價于調(diào)用事件所表示的委托——因此，不需要特殊的語言構(gòu)件引發(fā)事件。
客戶通過事件處理程序（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 list();
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）是一種函數(shù)成員，用來定義可應用于類實例的特定表達式運算符的含義。有三種運算符能夠被定義：一元運算符、二元運算符和轉(zhuǎn)換運算符。所有的運算符必須聲明為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.writeline(a == b); //輸出 "true"
b.add(3);
console.writeline(a == b); //輸出 "false"
}
}
第一個console.writeline輸出true，原因是兩個list集合對象包含個數(shù)和值都相同的對象。假如list沒有定義運算符 “==”，那么第一個console.writeline將輸出false，因為a和b引用不同的list實例。
1.6.6.6 析構(gòu)函數(shù)
析構(gòu)函數(shù)（destructor）是用于實現(xiàn)析構(gòu)類實例所需操作的成員。析構(gòu)函數(shù)不能帶參數(shù)，不能具有可訪問性修飾符，也不能被顯式地調(diào)用。垃圾回收期間會自動調(diào)用所涉及實例的析構(gòu)函數(shù)。
垃圾回收器在決定何時回收對象和運行析構(gòu)函數(shù)方面采取寬松的策略。特別指出，析構(gòu)函數(shù)的調(diào)用時機是不確定的，并且析構(gòu)函數(shù)可能運行在任何線程上。由于這些或者其他原因，只有沒有其他可行的解決方案，類才實現(xiàn)析構(gòu)函數(shù)。
