的面向对象程序设计

会计学1的面向对象程序设计内容提要：类、对象的概念及使用方法、属性、索引的概念、声明及调用构造函数和析构函数的定义继承和接口的用法委托和事件的声明及调用目的要求：理解类、对象、构造函数和析构函数的意义

掌握方法、属性、索引的用法掌握继承和接口、委托和事件的声明及调用重点难点：类、对象、方法、属性、继承、接口、委托和事件第1页/共78页

面向对象的程序设计(OOP)的主要思想是将数据及处理这些数据的操作都封装到一个称为类（Class）的数据结构中。使用这个类时，只需要定义一个类的变量即可，这个变量叫做对象（Object）。通过调用对象的数据成员完成对类的使用。

1.类在面向对象理论中，类（class)就是对具有相同特征的一类事物所做的抽象（或者说，归纳）。

6.1面向对象程序设计的基本概念第2页/共78页2.对象类是一种抽象，而对象(object)则是实例(instance)，是具体的。

如果使用如下格式来代表一个类生成一个对象：

类名对象名；则：电子计算机ComputerA;

电子计算机ComputerB;

就代表ComputerA和ComputerB是“电子计算机”类的两个不同对象。第3页/共78页3.类的属性属性说明了这个类的特点。例如“PC计算机”类则可能具备如下属性：计算机的名称

CPU类型内存容量硬盘容量主板型号显示适配器型号声卡型号操作系统类型通过这些属性，就可以将不同的PC计算机区分开。第4页/共78页3.类的属性属性说明了这个类的特点。例如“PC计算机”类则可能具备如下属性：计算机的名称

CPU类型内存容量硬盘容量主板型号显示适配器型号声卡型号操作系统类型通过这些属性，就可以将不同的PC计算机区分开。第5页/共78页

4.类的方法类的方法（method)代表了一类事物所具备的动作，是对属性的操作。

比如：“石英钟”类的方法有：秒针前进一格、分针前进一格、时针前进一格等;而“录像机”类所具备的方法可以有：播放、定格、录像、倒带、快进等。

第6页/共78页5.派生和继承

在类的继承中，被继承的类称为基类（又称为父类），由基类继承的类称为派生类（又称为子类）。派生类自动获得基类的所有属性和方法，而且可以在派生类中添加新的属性和方法。

第7页/共78页6.多态性多态性是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同数据类型或表现出不同的行为。就是程序在运行时，会自动判断对象的派生类型，并调用相应的方法。

7.封装封装就是把对象的属性和服务结合成一个独立的系统单位，并尽可能隐蔽对象的内部细节。第8页/共78页

6.2类和对象

6.2.1类的声明类是C#的一种自定义数据类型，其声明格式为：

[类修饰符]class类名[：基类类名]{

类的成员；

}[；]

说明：C#支持的类修饰符有：new、public、protected、

internal、private、abstract、sealed。

第9页/共78页例：定义一个车辆类（有三个变量）

classVehicle{publicintpassengers;//乘客数

publicintfuelcap;//所耗燃料

publicintmpg;//每公里耗油量

}第10页/共78页6.2.2类的成员

类可以分为两大类：类本身所声明的，以及从基类中继承而来的。在C＃中，按照类的成员是否为函数将其分为两种：一种不以函数形式体现，称为成员变量；另一种是以函数形式体现，称为成员函数。

第11页/共78页1.类成员的访问修饰符

（1）public：允许类的内部或外界直接访问；（2）private:不允许外界访问，也不允许派生类访问，即只能在类的内部访问。如果没有设定访问修饰符，默认为

private；（3）protected:不允许外界访问，但允许派生类访问；（4）internal:只有本类的成员才能访问。（5）readonly：该成员的值只能读，不能写。也就是说，除了赋予初始值外，在程序的任何一个部分将无法更改这个成员的值。

第12页/共78页classClassA{publicinta;privateintb;protectedintc;publicvoidSetA(){a=1;//正确，允许访问类自身公有成员

b=2;//正确，允许访问类自身私有成员

c=3;//正确，允许访问类自身保护成员

}}classClassB:ClassA{publicvoidSetB(){ClassABaseA=newClassA();BaseA.a=5;//正确，允许访问基类公有成员

BaseA.b=23;//错误，不允许访问基类私有成员

BaseA.c=68;//正确，允许访问基类保护成员

}}classClassC{publicvoidSetB(){ClassABaseA=newClassA();BaseA.a=5;//正确，允许访问类的其他公有成员

BaseA.b=23;//错误，不允许访问类的其他私有成员

BaseA.c=68;//错误，不允许访问类的其他保护成员

}}第13页/共78页2.静态成员与非静态成员静态成员是在声明成员时在前面加上static保留字；非静态成员是在声明成员时前面没有static保留字；静态成员属于类所有，非静态成员属于类的对象所有。

静态成员的访问格式：

类名.静态成员名第14页/共78页

若将类中的某个成员声明为static，则该成员称为静态成员。类中的成员要么是静态的，要么是非静态的。

类的非静态成员属于类的实例所有，每创建一个类的实例都在内存中为非静态成员开辟了一块区域。而类的静态成员属于类所有，为这个类的所有实例所共享。无论这个类创建了多少个对象（实例），一个静态成员在内存中只占有一块区域。第15页/共78页例：静态成员的访问usingSystem;classMyclass{publicintnIndex=10;staticpublicdoublefphi=45.6;}classclassTest{staticvoidMain(){inta=Myclass.nIndex;//错误，因为nIndex是非静态成员

doubleb=Myclass.fphi;//正确，因为fphi是静态成员

Console.Write(b);}}第16页/共78页6.2.3对象的声明创建类的对象。分两步：（1）先声明对象名

格式：类名对象名；例：Vehicleminivan;//定义类Vehicle的一个对象（2）创建类的实例。

格式：对象名=new类名();

例：minivan=newVehicle();//创建一个实例以上两步也可以合并成一步。格式：类名对象名=new类名()；例：Vehicleminivan=newVehicle()；第17页/共78页6.3构造函数和析构函数

C#中有两个特殊的函数：构造函数和析构函数。

构造函数：当类实例化时首先执行的函数；

析构函数：当实例（即对象）从内存中销毁前最后执行的函数。第18页/共78页6.3.1构造函数

在C#中，当创建一个对象时，系统首先为这个对象赋予一个标识符，然后给对象分配合适的内存空间，随后系统就自动调用对象的构造函数。构造函数的类型修饰符总是public，因为构造函数主要是在类外创建对象时自动调用。格式：class类名

{public类名(){//构造函数体

}}第19页/共78页

例：usingSystem;classMyClass{publicintx;publicMyclass()//类MyClass的构造函数

{x=10;}}classConsDemo{publicstaticvoidMain(){MyClasst1=newMyClass();MyClasst2=newMyClass();Console.WriteLine(“{0}\t{1}”,t1.x,t2.x);}}运行结果如下：第20页/共78页

构造函数也可以带参数。

例：usingSystem;classFruit{publicstringcolor;publicstringshape;publicFruit(stringc,strings)//类Fruit的构造函数

{color=c;shape=s;}}classTest{publicstaticvoidMain(){FruitOrange=newFruit(“orange”,”round”);//创建Orange实例

Console.WriteLine(“{0},{1}”,Orange.color,Orange.shape);}}

运行结果如下：第21页/共78页

构造函数也可以重载。例：usingSystem;classA{ publicintcount; publicA() { count=-1; } publicA(intn) { count=n; }}classTest{ staticvoidMain() { Aa=newA();Console.WriteLine("count={0}",a.count); Ab=newA(5); Console.WriteLine("count={0}",b.count);}}运行结果如下：第22页/共78页使用this关键字

C#中的this关键字是用来代表对象自身。this一般用在构造函数中，以便区别同名的构造函数参数和类成员变量。例：

usingSystem;

classPoint{intx,y;publicPoint(intx,inty){this.x=x;this.y=y;}}

运行结果如下：

classTest{ staticvoidMain() { Pointp=newPoint(5,6); Console.WriteLine("x={0}",p.x); Console.WriteLine("y={0}",p.y); }}第23页/共78页6.3.2析构函数

析构函数也是类的特殊的成员函数，它主要用于释放类实例。析构函数的特殊性表现在以下几个方面：（1）析构函数的名字与类名相同，但它前面需要加一个“~”符号；（2）析构函数不能带参数，也没有返回值；（3）当撤消对象时，自动调用析构函数；（4）析构函数不能被继承，也不能被重载。第24页/共78页格式：

class类名

{

……~类名(){//析构函数体

}}

析构函数以与构造函数相反的顺序被调用。第25页/共78页例：usingSystem;classDecon1{publicDecon1(){Console.WriteLine(“调用构造函数Decon1”);}~Decon1(){Console.WriteLine(“调用析构函数Decon1”);}}classDecon2{publicDecon2(){Console.WriteLine(“调用构造函数Decon2”);}~Decon2(){Console.WriteLine(“调用析构函数Decon2”);}}classTest{publicstaticvoidMain(){Decon1dec1=newDecon1();Decon2dec2=newDecon2();}}

运行结果如下：第26页/共78页

可以按照程序代码执行的功能或其他依据把相关的语句组织在一起，并给它们注明相应的名称，利用这种方式把程序分块，就形成了类的方法。方法的功能是通过方法调用实现的。方法调用指定了被调用方法的名字和调用方法所需的信息（参数），调用方法要求被调用方法按照方法参数完成某个任务，并在完成这项任务后由方法返回。如果调用过程出错，则无法完成正常的任务。6.4方法第27页/共78页6.4.1方法的定义及调用

方法是类中用于计算或进行其他操作的成员。类的方法主要用来操作类的数据，提供一种访问数据的途径。

1.方法的定义

格式：修饰符返回值类型方法名（形式参数列表）

{

方法体各语句；

}第28页/共78页说明：（1）如果省略“方法修饰符”，该方法为类的

私有成员。（2）“返回类型”指定该方法返回数据的类型，它可以是任何有效的类型。如果方法不需要返回一个值，其返回类型必须是void。（3）“方法参数列表”是用逗号分隔的类型、

标识符对。这里的参数是形式参数，本质

上是一个变量，它用来在调用方法时接收

传给方法的实际参数值，如果方法没有参

数，那么参数列表为空。第29页/共78页2.从方法返回

一般来说有两种情况将导致方法返回。第一种情况：当碰到方法的结束花括号。第二种情况：执行到return语句。有两种形式的return：一种用在void方法中（就是那些没有返回值的方法），另一种用在有返回值的方法中。

第30页/共78页例：通过方法的结束花括号返回。

usingSystem;classTest{publicvoidmyMeth(){intj;for(j=0;j<10;j++){if(j%3==0)continue;Console.WriteLine(“{0}\t”,j);}}staticvoidMain(){Testlei=newTest();lei.myMeth();}}

运行结果如下：第31页/共78页

C#允许在一个方法中，有两个或多个return语句，特别是当方法有多个分支时。例：usingSystem;classTest{publicvoidmyMeth(){intj=8;if(j>=5){j=j*2;Console.WriteLine(j);return;}else{j=j*3;Console.WriteLine(j);return;}}staticvoidMain(){Testlei=newTest();lei.myMeth();}}运行结果如下：第32页/共78页

注意：一个void方法在下述情况之一下将返回程序执行时碰到方法的结束花括号；或者程序执行到一条return语句时。使用下述形式的return语句来从方法返回一个值给调用者。格式：

returnvalue；说明：这里value是要从方法中返回的值。

第33页/共78页例：用return语句返回值。

publicintmyMeth(){intj=8;if(j>=5){returnj*2;}else{returnj*3;}}

第34页/共78页6.4.2方法的参数类型

调用方法时，可以给方法传递一个或多个值。传给方法的值叫做实参（argument)，在方法内部，接收实参值的变量叫做形参（parameter),形参在紧跟着方法名的括号中声明。形参的声明语法与变量的声明语法一样。形参只在方法内部有效，除了将接收实参的值外，它与一般的变量没什么区别。

C#方法的参数类型主要有：值参数、引用参数和输出参数。

第35页/共78页1．值参数未用任何修饰符声明的参数为值参数。值参数在调用该参数所属的方法成员时创建，并用调用中给定的实参值初始化。当从该方法返回时值参数被销毁。对值参数的修改不会影响到原自变量。值参数通过复制原自变量的值来初始化。第36页/共78页例：使用值参数。usingSystem;classTest{publicvoidSwap(intx,inty){intk;k=x;x=y;y=x;}staticvoidMain(){inta=8,b=68;Console.WriteLine("a={0},b={1}",a,b);Testsw=newTest();sw.Swap(a,b);Console.WriteLine("a={0},b={1}",a,b);}}程序的运行结果为：

a=8,b=68a=8,b=68第37页/共78页2.引用型参数用ref修饰符声明的参数为引用参数。引用参数本身并不创建新的存储空间，而是将实参的存储地址传递给形参。可以认为引用参数中就是调用方法时给出的变量，而不是一个新变量。在方法调用中，引用参数必须被赋初值。在调用时，传送给ref参数的必须是变量，类型必须相同，并且必须使用ref修饰。

格式：

方法修饰符返回类型方法名（[…,]ref参数1[,ref参数

2，…]){

方法实现部分；

}

调用方法时，实参前面也必须要加上ref。第38页/共78页例：使用引用参数。usingSystem;classTest{publicvoidSwap(refintx,refinty){intk;k=x;x=y;y=x;}staticvoidMain(){inta=8,b=68;Console.WriteLine("a={0},y={1}",a,b);Testsw=newTest();sw.Swap(refa,refb);Console.WriteLine("a={0},y={1}",a,b);}}程序的运行结果为：

a=8,b=68a=68,b=8第39页/共78页3.输出参数用out修饰符定义的参数称为输出参数。如果希望方法返回多个值，可使用输出参数。

格式：

方法修饰符返回类型方法名（[…,]out参数1[,out参数

2，…]){

方法实现部分；

}

调用方法时，实参前面也要加上out。第40页/共78页例：使用输出参数usingSystem;classMyClass

{

publicstringTestOut(outstringi) {

i="使用out关键字";

return"out参数"; }

}classtest

{

staticvoidMain() {

stringx; MyClassapp=newMyClass();

Console.WriteLine(app.TestOut(outx));

Console.WriteLine(x); }

}

运行结果如下：第41页/共78页例：usingSystem;classTestOut{//b就是利用out这个输出参数而返回的值

staticintOutValue(inta,outcharb) { b=(char)a; return9; } staticvoidMain() { intt=65,r; charm; r=OutValue(t,outm); Console.WriteLine("r={0},m={1}",r,m); }}

运行结果如下：第42页/共78页

注意：在把引用型实参的值传递给形参之前，必须先对其赋值。这一点是引用参数与输出参数的不同之处。在带有引用参数的方法中，有可能导致多个变量名指向同一内存地址，从而导致出错。第43页/共78页6.4.2方法的重载

类中两个以上的方法(包括隐藏的继承而来的方法)取的名字相同，只要使用的参数类型或参数个数不同，编译器便知道在何种情况下应该调用哪个方法，这就叫做方法的重载。

方法重载必须遵守一个重要的约束：每一个被重载方法的参数类型或个数必须不同。当调用重载方法时，将执行形参与实参相匹配的那个方法。

第44页/共78页例：方法重载。

usingSystem;classTestoverLoad{publicvoidprint(inti){Console.WriteLine("输出的整数={0}"，i);}publicvoidprint(strings){Console.WriteLine("输出的字符串={0}",s);}publicvoidprint(doubled){Console.WriteLine("输出的双精度数={0}"，d);}}classtest{publicstaticvoidMain(){TestoverLoadapp=newTestoverLoad();app.print(6);app.print("理解方法重载了吗？"）；

app.print(3.14);}}运行结果为：输出的整数=6

输出的字符串=理解方法重载了吗？输出的双精度数=3.14第45页/共78页6.4.4静态方法与非静态方法

类的成员类型有静态和非静态两种，因此方法也有静态方法和非静态方法两种。使用static修饰符的方法称为静态方法，没有使用static修饰符的方法称为非静态方法。静态方法和非静态方法的区别是：静态方法属于类所有，非静态方法属于用该类定义的对象所有。

第46页/共78页例：使用静态方法和非静态方法。

usingSystem;classTestMethod{publicinta;staticpublicintb;voidFun1()//定义一个非静态方法

{a=10;//正确，直接访问非静态成员

b=20;//正确，直接访问静态成员

}staticvoidFun2()//定义一个静态成员方法

{a=10;//错误，不能访问非静态成员

b=20;//正确，可以访问静态成员，相当于myClass.b=20}}classTest{staticvoidMain(){myClassA=newmyClass();A.a=10;//正确，访问类myClass的非静态公有成员变量

A.b=10;//错误，不能直接访问类中静态公有成员

MyClass.a=20;//错误，不能通过类访问类中非静态公有成员

MyClass.b=20;//正确，可以通过类访问类myClass中的

//静态公有成员

}}第47页/共78页6.4.5运算符的重载为类定义自己的运算符的操作，就称为运算符重载。1．运算符重载的声明

C#中运算符重载总是在类中进行声明。实际上一个运算符重载不过是一个方法罢了，比较特别的是它的名称需要遵守一个特殊的格式来定义。所有的重载运算符的名称都是以operator开始，加上欲重载的运算符，而且重载运算符的方法一定是public且为static的。

声明重载运算符的一般格式如下：

publicstatic返回类型operator运算符(参数列表){//可执行语句

}第48页/共78页C#中下列运算符都是可以重载的：一元运算符：+-！~++--truefalse

二元运算符：+-*/%&|^<<>>==!=><>=<=

其中，比较运算符重载必须成对出现，如果重载==,也必须重载!=，反之亦然，对于>和<，以及<=和>=同样如此。同样，true与false也必须成对出现。C#中还有一些运算符是允许重载的，如下所示：

=&&?:newtypeofsizeofis第49页/共78页2．一元运算符重载

一元运算符重载必须使用类T的单个参数，其中+、-、！可以返回任何类型；++或--的返回类型必须是类T，而且重载之后的++或--无法区分前缀与后缀；true和false要求返回类型是布尔类型。3．二元运算符重载二元运算符重载必须有两个参数，而且其中至少一个必须是声明运算符的类类型。一个二元运算符可以返回任何类型。第50页/共78页6.4.6递归

类的方法成员间允许相互调用，也可以自己调用自己。类的方法如果在方法体内直接或间接地自己调用自己就称为递归方法。递归是常用的程序设计技术，其基本思想就是“自己调用自己”。递归方法实际上体现了“依此类推”、“用同样的步骤重复”这样的思想，它可以用简单的程序来解决某些复杂的计算问题。递归调用在完成阶乘运算、级数运算、幂指数运算等方面特别有效。在执行递归操作时，C#语言把递归过程中的信息保存在堆栈中。如果无限循环地递归，或者递归次数太多，则产生“堆栈溢出”错误。第51页/共78页

例：用递归方法求阶乘。利用的数学公式为n!=n*(n-1)!。当n=0时，n!=1。代码如下：

publiclongF(longn){if(n==0||n==1)return1;elsereturnn*F(n-1);}第52页/共78页

6.5属性属性是对现实世界中实体特征的抽象，它提供了一种对类或对象性质的访问。不直接操作类的数据内容，而是通过访问器进行访问（使用get和set对属性的值进行读写）。

由于属性是表达事物的状态的，属性的存取方式可以是读，也可以是写。读写属性分别用get和set进行表示。

第53页/共78页6.5属性6.5.1属性的声明格式：

[属性修饰符]属性的类型属性名称{方法声明}

说明：若属性是静态成员，通过“类名.属性成员名”访问；若属性是非静态成员，通过“对象名.属性成员名”访问。通过访问器，类的属性成员可以返回一个值（get访问器），或者接受外界通过赋值语句提供的值（set访问器）。第54页/共78页get访问器格式：

get{语句}

说明：get访问器中的语句主要是用return语句返回某一个变量成员的值。

例：classCircle{protectedintpage=2;publicintpa{get{returnpage;}}}classTest{staticvoidMain(){CircleMyCircle=newCircle();intn=MyCircle.pa*10;//读pa属性

intm=MyCircle.page*10;//错误！Page是protected}}第55页/共78页

set访问器格式：

set{语句}

说明：set访问器用于外界写入的值。set访问器就像带有一个参数的方法，这个参数的名字是value(注意：参数value是隐含的，不能再定义），它的值就是调用者要写入属性的值。

例：classCircle{protectedintpage;publicintpa{get{returnpage;}set{page=value;}}}classTest{staticvoidMain(){CircleMyCircle=newCircle();MyCircle.pa=10;//对pa属性进行写操作

intn=MyCircle.pa*10;//读pa属性

Console.WriteLine(“n={0}”,n);}}

运行结果如下：第56页/共78页

通过属性来设置变量成员的值，可以在访问器中加入代码，以判断数据的合法性。

例：以下是使用条件运算符进行运算，从而保证类ClassA的nIndex不为负数。

classA{privateintnIndex;publicintIndex{get{returnnIndex;}set{nIndex=value>=0?value:0;}}}

classTest{staticvoidMain(){Ap=newA();p.Index=-9; Console.WriteLine(p.Index);}}

运行结果如下：第57页/共78页

属性定义可以包含get和set两个访问器的定义，也可以只包含其中的一个。根据get和set访问器的存在或不存在，属性按下面特征进行分类：

.既包括get访问器也包括set访问器的属性被称为读写属性。

.只包括get访问器的属性被称为只读属性。一个只读属性被赋值是错误的。

.只包括set访问器的属性被称为只写属性。第58页/共78页

属性与变量都可以用来表示事物的状态，但属性可以实现只写或只读并且可以对用户指定的值（value）进行有效性检查，从而保证只有正确的状态才会得到设置，而变量不能。所以，在C#中一般采取以下原则：（1）若在类的内部记录事物的状态信息，则用变量。（2）变量一般用private修饰，以防止对外使用。（3）对外公布事物的状态信息，则使用属性。（4）属性一般与某个或某几个变量有对应关系。第59页/共78页

索引器是这样一个成员：它能够让对象以类似数组的方式来访问，即可以使对象能用下标来得到一个值，它以访问数组的方法来访问类的数据成员，而实际的读/写操作则是通过get和set来完成的。

6.6.1索引的定义与使用

格式：修饰符类型名this[参数列表]{set{}get{}}

说明：在set方法中，可以使用一个特殊变量value，用以表示用户指定的值，而get方法使用return返回所得到的值。

6.6索引指示器第60页/共78页例：定义索引指示器classMyIndexer{privatestring[]myArray=newstring[4];publicstringthis[intindex]{get{if(index<0||index>=4) returnnull;else returnmyArray[index];}set{if(!(index<0||index>=4)) myArray[index]=value;}}注意：属性可以是静态成员，而索引指示器只能是实例成员。第61页/共78页

6.6.2使用索引指示器访问对象

使用索引指示器，可以像数组一样访问类的对象，只不过通过数组下标访问的是存储在数组中的数组元素，而索引指示器访问的是类的对象。使用“常规的”C#数组，下标数字必须是整型值。索引器的一个优点就是程序员可以定义整型和非整型两种下标。第62页/共78页例：usingSystem;classIndex{ string[]name=newstring[]{"A","B","C","D"}; inti; publicintthis[stringidx] {get {for(i=0;i<name.Length;i++) { if(idx==name[i]) break; } if(i==name.Length) return-1; else returni+1; }}staticvoidMain() {Indexa=newIndex(); if(a["A"]!=-1) Console.WriteLine("字符A是序列中的第{0}个字符",a["A"]); else Console.WriteLine("序列中没有该字符"); }}

运行结果如下：第63页/共78页

委托，顾名思义，就是中间代理人的意思。通俗地说，委托是一个可以引用方法的对象，即是说委托可以调用它所指向的方法。事件是建立在委托基础上的另一个重要特性。从本质上说，事件就是当某个事情发生时，会自动去执行一些语句。事件是特殊化的委托，委托是事件的基础。6.7委托和事件第64页/共78页6.7.1委托

C#中使用委托的具体的步骤是：（1）声明一个委托，其参数形式一定要和想要包含的方法的参数形式一致。

（2）定义所有你要定义的方法，其参数形式和第一步中声明的委托对象的参数形式必须相同。

（3）创建委托对象并将所希望的方法包含在该委托对象中。（4）通过委托对象调用包含在其中的各个方法。

第65页/共78页步骤1：声明一个委托

格式：

[修饰符]delegate返回类型委托名(参数列表);

例：

委托的声明

publicdelegatevoidMyDelegate1(stringinput);

publicdelegatedoubleMyDelegate2();

声明一个委托的对象，与声明一个普通类对象的方式一样：委托名委托对象名；委托对象的声明。

MyDelegate1a;MyDelegate2b;第66页/共78页步骤2：定义方法，其参数形式和步骤1中声明的委托对象的必须相同。

例：定义方法classMyClass1{

publicvoiddMethod1(stringinput){

Console.WriteLine(“Method1传递的参数是{0}",input);

}

publicvoiddMethod2(stringinput){

Console.WriteLine(Method1传递的参数是{0}",input);}

}

第67页/共78页

步骤3：创建一个委托对象并将上面的方法包含其中

例：在委托对象中包含方法。

MyClass1c2=newMyClass1();MyDelegate1d1;d1=newMyDelegate1(c2.dMethod1);MyDelegate1d2=newMyDelegate1(c2.dMethod2);步骤4：通过委托对象调用包含在其中的方法。

例：调用委托对象包含的方法。

d1("abc");d2("123");

第68页/共78页下面这个例子就是将上面的4个步骤合在一起：usingSystem;publicdelegatevoidMyDelegate1(stringinput);classMyClass1{

publicvoiddMethod1(stringinput)

{

Console.WriteLine("dMethod1传递的参数是{0}",input);

}publicvoiddMethod2(stringinput)

{

Console.WriteLine("dMethod2传递的参数是{0}",input);

} }classDriver{

staticvoidMain(){

MyClass1c2=newMyClass1();?

MyDelegate1d1=newMyDelegate1(c2.dMethod1);?

MyDelegate1d2=newMyDelegate1(c2.dMethod2);?

d1("abc");

d2("123");

}

}