您的位置：首页 > 编程语言 > C#

C#面向对象基础概念25个

2015-08-24 15:12 537 查看

1.静态成员和非静态成员的区别？
2.const和staticreadonly区别？
3.extern是什么意思？
4.abstract是什么意思？
5.internal修饰符起什么作用？
6.sealed修饰符是干什么的？
7.override和overload的区别？
8.什么是索引指示器？
9.new修饰符是起什么作用？
10.this关键字的含义？
11.可以使用抽象函数重写基类中的虚函数吗？
12.密封类可以有虚函数吗？
13.什么是属性访问器？
14.abstract可以和virtual一起使用吗？可以和override一起使用吗？
15.接口可以包含哪些成员？
16.类和结构的区别？
17.接口的多继承会带来哪些问题？
18.抽象类和接口的区别？
19.别名指示符是什么？
20.如何手工释放资源？
21.P/Invoke是什么？
22.StringBuilder和String的区别？
23.explicit和implicit的含义？
24.params有什么用？
25.什么是反射？

以下是我做的一份参考答案（C#语言范畴之内），如果有不准确、不全面的，欢迎各位朋友指正！

1.静态成员和非静态成员的区别？

答：

静态变量使用static修饰符进行声明，在类被实例化时创建，通过类进行访问

不带有static修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问

一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值

静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample01

classProgram

classClass1

publicstaticStringstaticStr="Class";

publicStringnotstaticStr="Obj";

}

staticvoidMain(string[]args)

{

//静态变量通过类进行访问，该类所有实例的同一静态变量都是同一个值

Console.WriteLine("Class1'sstaticStr:{0}",Class1.staticStr);

Class1tmpObj1=newClass1();

tmpObj1.notstaticStr="tmpObj1";

Class1tmpObj2=newClass1();

tmpObj2.notstaticStr="tmpObj2";

//非静态变量通过对象进行访问，不同对象的同一非静态变量可以有不同的值

Console.WriteLine("tmpObj1'snotstaticStr:{0}",tmpObj1.notstaticStr);

Console.WriteLine("tmpObj2'snotstaticStr:{0}",tmpObj2.notstaticStr);

Console.ReadLine();

}

}
[/code]
结果：
Class1'sstaticStr:Class
tmpObj1'snotstaticStr:tmpObj1
tmpObj2'snotstaticStr:tmpObj2

2.const和staticreadonly区别？

答：

const

用const修饰符声明的成员叫常量，是在编译期初始化并嵌入到客户端程序

staticreadonly

用staticreadonly修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法：通过类进行访问、初始化后不可以修改。但与常量不同的是这种变量是在运行期初始化

示例：

测试类：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample02Lib

publicclassClass1

publicconstStringstrConst="Const";

publicstaticreadonlyStringstrStaticReadonly="StaticReadonly";

//publicconstStringstrConst="ConstChanged";

//publicstaticreadonlyStringstrStaticReadonly="StaticReadonlyChanged";

}

客户端代码：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

usingExample02Lib;

namespaceExample02

{

classProgram

{

staticvoidMain(string[]args)

{

//修改Example02中Class1的strConst初始值后，只编译Example02Lib项目

//然后到资源管理器里把新编译的Example02Lib.dll拷贝Example02.exe所在的目录，执行Example02.exe

//切不可在IDE里直接调试运行因为这会重新编译整个解决方案！！

//可以看到strConst的输出没有改变，而strStaticReadonly的输出已经改变

//表明Const变量是在编译期初始化并嵌入到客户端程序，而StaticReadonly是在运行时初始化的

Console.WriteLine("strConst:{0}",Class1.strConst);

Console.WriteLine("strStaticReadonly:{0}",Class1.strStaticReadonly);

Console.ReadLine();

}

[/code]

结果：
strConst:Const
strStaticReadonly:StaticReadonly

修改后的示例：

测试类：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample02Lib

publicclassClass1

//publicconstStringstrConst="Const";

//publicstaticreadonlyStringstrStaticReadonly="StaticReadonly";

publicconstStringstrConst="ConstChanged";

publicstaticreadonlyStringstrStaticReadonly="StaticReadonlyChanged";

}

[/code]
结果

strConst:Const
strStaticReadonly:StaticReadonlyChanged

3.extern是什么意思？

答：

extern修饰符用于声明由程序集外部实现的成员函数

经常用于系统API函数的调用（通过DllImport）。注意，和DllImport一起使用时要加上static修饰符

也可以用于对于同一程序集不同版本组件的调用（用extern声明别名）

不能与abstract修饰符同时使用

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

usingSystem.Runtime.InteropServices;

namespaceExample03

{

classProgram

{

//注意DllImport是一个AttributeProperty，在System.Runtime.InteropServices命名空间中定义

//extern与DllImport一起使用时必须再加上一个static修饰符

[DllImport("User32.dll")]

publicstaticexternintMessageBox(intHandle,stringMessage,stringCaption,intType);

staticintMain()

stringmyString;

Console.Write("Enteryourmessage:");

myString=Console.ReadLine();

returnMessageBox(0,myString,"MyMessageBox",0);

}

}
[/code]
结果：

4.abstract是什么意思？

答：

abstract修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员

abstract不可以和static、virtual一起使用

声明为abstract成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample04

#region基类，抽象类

publicabstractclassBaseClass

{

//抽象属性，同时具有get和set访问器表示继承类必须将该属性实现为可读写

publicabstractStringAttribute

get;

set;

}

//抽象方法，传入一个字符串参数无返回值

publicabstractvoidFunction(Stringvalue);

//抽象事件，类型为系统预定义的代理(delegate)：EventHandler

publicabstracteventEventHandlerEvent;

//抽象索引指示器，只具有get访问器表示继承类必须将该索引指示器实现为只读

publicabstractCharthis[intIndex]

{

get;

}

#endregion

#region继承类

publicclassDeriveClass:BaseClass

{

privateStringattribute;

publicoverrideStringAttribute

{

get

{

returnattribute;

}

set

{

attribute=value;

}

publicoverridevoidFunction(Stringvalue)

attribute=value;

if(Event!=null)

{

Event(this,newEventArgs());

}

publicoverrideeventEventHandlerEvent;

publicoverrideCharthis[intIndex]

{

get

{

returnattribute[Index];

}

#endregion

classProgram

{

staticvoidOnFunction(objectsender,EventArgse)

{

for(inti=0;i<((DeriveClass)sender).Attribute.Length;i++)

{

Console.WriteLine(((DeriveClass)sender)[i]);

}

staticvoidMain(string[]args)

DeriveClasstmpObj=newDeriveClass();

tmpObj.Attribute="1234567";

Console.WriteLine(tmpObj.Attribute);

//将静态函数OnFunction与tmpObj对象的Event事件进行关联

tmpObj.Event+=newEventHandler(OnFunction);

tmpObj.Function("7654321");

Console.ReadLine();

}

[/code]
结果：
1234567
7
6
5
4
3
2
1

5.internal修饰符起什么作用？

答：

internal修饰符可以用于类型或成员，使用该修饰符声明的类型或成员只能在同一程集内访问

接口的成员不能使用internal修饰符

值得注意的是，如果为internal成员加上了protected修饰符，这时的访问级别为internal或protected。只是看字面意思容易弄错，许多人认为internalprotected应该是“只有同一个程序集中的子类可以访问”，但其实它表示“同一个程序集中的所有类，以及所有程序集中的子类都可以访问”

示例

Example05Lib项目的Class1

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample05Lib

publicclassClass1

internalStringstrInternal=null;

publicStringstrPublic;

internalprotectedStringstrInternalProtected=null;

}
[/code]
结果
Example05Lib项目的Class2类可以访问到Class1的strInternal成员，当然也可以访问到strInternalProtected成员，因为他们在同一个程序集里

Example05项目里的Class3类无法访问到Class1的strInternal成员，因为它们不在同一个程序集里。但却可以访问到strInternalProtected成员，因为Class3是Class1的继承类

Example05项目的Program类既无法访问到Class1的strInternal成员，也无法访问到strInternalProtected成员，因为它们既不在同一个程序集里也不存在继承关系

6.sealed修饰符是干什么的？

答：

sealed修饰符表示密封

用于类时，表示该类不能再被继承，不能和abstract同时使用，因为这两个修饰符在含义上互相排斥

用于方法和属性时，表示该方法或属性不能再被重写，必须和override关键字一起使用，因为使用sealed修饰符的方法或属性肯定是基类中相应的虚成员

通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱

恰当的利用sealed修饰符也可以提高一定的运行效率，因为不用考虑继承类会重写该成员

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample06

classProgram

classA

publicvirtualvoidF()

Console.WriteLine("A.F");

publicvirtualvoidG()

Console.WriteLine("A.G");

}

classB:A

{

publicsealedoverridevoidF()

{

Console.WriteLine("B.F");

}

publicoverridevoidG()

{

Console.WriteLine("B.G");

}

classC:B

publicoverridevoidG()

Console.WriteLine("C.G");

}

staticvoidMain(string[]args)

{

newA().F();

newA().G();

newB().F();

newB().G();

newC().F();

newC().G();

Console.ReadLine();

}

[/code]
结果：
类B在继承类A时可以重写两个虚函数，如图所示：

由于类B中对F方法进行了密封，类C在继承类B时只能重写一个函数，如图所示：

控制台输出结果，类C的方法F只能是输出类B中对该方法的实现：

A.F
A.G
B.F
B.G
B.F
C.G

7.override和overload的区别？

答：

override表示重写，用于继承类对基类中虚成员的实现

overload表示重载，用于同一个类中同名方法不同参数（包括类型不同或个数不同）的实现

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample07

classProgram

classBaseClass

publicvirtualvoidF()

Console.WriteLine("BaseClass.F");

}

classDeriveClass:BaseClass

{

publicoverridevoidF()

{

base.F();

Console.WriteLine("DeriveClass.F");

publicvoidAdd(intLeft,intRight)

Console.WriteLine("AddforInt:{0}",Left+Right);

publicvoidAdd(doubleLeft,doubleRight)

Console.WriteLine("Addforint:{0}",Left+Right);

}

staticvoidMain(string[]args)

{

DeriveClasstmpObj=newDeriveClass();

tmpObj.F();

tmpObj.Add(1,2);

tmpObj.Add(1.1,2.2);

Console.ReadLine();

}

[/code]
结果：
BaseClass.F
DeriveClass.F
AddforInt:3
Addforint:3.3

8.什么是索引指示器？

答：

实现索引指示器（indexer）的类可以象数组那样使用其实例后的对象，但与数组不同的是索引指示器的参数类型不仅限于int

简单来说，其本质就是一个含参数属性

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample08

publicclassPoint

privatedoublex,y;

publicPoint(doubleX,doubleY)

{

x=X;

y=Y;

//重写ToString方法方便输出

publicoverridestringToString()

{

returnString.Format("X:{0},Y:{1}",x,y);

}

publicclassPoints

Point[]points;

publicPoints(Point[]Points)

{

points=Points;

}

publicintPointNumber

{

get

{

returnpoints.Length;

}

//实现索引访问器

publicPointthis[intIndex]

{

get

{

returnpoints[Index];

}

//感谢watsonhua(http://huazhihao.cnblogs.com/)的指点

//索引指示器的实质是含参属性，参数并不只限于int

classWeatherOfWeek

publicstringthis[intIndex]

get

//注意case段使用return直接返回所以不需要break

switch(Index)

{

case0:

{

return"Todayiscloudy!";

}

case5:

{

return"Todayisthundershower!";

}

default:

{

return"Todayisfine!";

}

publicstringthis[stringDay]

get

stringTodayWeather=null;

//switch的标准写法

switch(Day)

case"Sunday":

TodayWeather="Todayiscloudy!";

break;

}

case"Friday":

{

TodayWeather="Todayisthundershower!";

break;

default:

TodayWeather="Todayisfine!";

break;

}

returnTodayWeather;

}

classProgram

staticvoidMain(string[]args)

Point[]tmpPoints=newPoint[10];

for(inti=0;i<tmpPoints.Length;i++)

{

tmpPoints[i]=newPoint(i,Math.Sin(i));

}

PointstmpObj=newPoints(tmpPoints);

for(inti=0;i<tmpObj.PointNumber;i++)

{

Console.WriteLine(tmpObj[i]);

}

string[]Week=newstring[]{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Staurday"};

WeatherOfWeektmpWeatherOfWeek=newWeatherOfWeek();

for(inti=0;i<6;i++)

{

Console.WriteLine(tmpWeatherOfWeek[i]);

}

foreach(stringtmpDayinWeek)

{

Console.WriteLine(tmpWeatherOfWeek[tmpDay]);

}

Console.ReadLine();

}

[/code]
结果：
X:0,Y:0
X:1,Y:0.841470984807897
X:2,Y:0.909297426825682
X:3,Y:0.141120008059867
X:4,Y:-0.756802495307928
X:5,Y:-0.958924274663138
X:6,Y:-0.279415498198926
X:7,Y:0.656986598718789
X:8,Y:0.989358246623382
X:9,Y:0.412118485241757
Todayiscloudy!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisthundershower!
Todayiscloudy!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisfine!
Todayisthundershower!
Todayisfine!

9.new修饰符是起什么作用？

答：

new修饰符与new操作符是两个概念

new修饰符用于声明类或类的成员，表示隐藏了基类中同名的成员。而new操作符用于实例化一个类型

new修饰符只能用于继承类，一般用于弥补基类设计的不足

new修饰符和override修饰符不可同时用在一个成员上，因为这两个修饰符在含义上互相排斥

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample09

classBaseClass

//基类设计者声明了一个PI的公共变量，方便进行运算

publicstaticdoublePI=3.1415;

}

classDervieClass:BaseClass

{

//继承类发现该变量的值不能满足运算精度，于是可以通过new修饰符显式隐藏基类中的声明

publicnewstaticdoublePI=3.1415926;

classProgram

staticvoidMain(string[]args)

Console.WriteLine(BaseClass.PI);

Console.WriteLine(DervieClass.PI);

Console.ReadLine();

}

}
[/code]
结果：
3.1415
3.1415926

10.this关键字的含义？

答：

this是一个保留字，仅限于构造函数和方法成员中使用

在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用

this保留字不能用于静态成员的实现里，因为这时对象或结构并未实例化

在C#系统中，this实际上是一个常量，所以不能使用this++这样的运算

this保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample10

classClass1

privatedoublec;

privatestringvalue;

publicdoubleC

{

get

{

returnc;

}

publicClass1(doublec)

//限定同名的隐藏成员

this.c=c;

}

publicClass1(Class1value)

{

//用对象本身实例化自己没有意义

if(this!=value)

c=value.C;

}

publicoverridestringToString()

{

//将对象本身做为参数

returnstring.Format("{0}Celsius={1}Fahrenheit",c,UnitTransClass.C2F(this));

//由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。

publicstringTest1()

longvTickCount=Environment.TickCount;

for(inti=0;i<10000000;i++)

this.value=i.ToString();

returnstring.Format("Havethis.:{0}MSEL",Environment.TickCount-vTickCount);

}

publicstringTest2()

{

longvTickCount=Environment.TickCount;

for(inti=0;i<10000000;i++)

value=i.ToString();

returnstring.Format("Don'thavethis.:{0}MSEL",Environment.TickCount-vTickCount);

}

classUnitTransClass

{

publicstaticdoubleC2F(Class1value)

{

//摄氏到华氏的转换公式

return1.8*value.C+32;

}

classProgram

{

staticvoidMain(string[]args)

{

Class1tmpObj=newClass1(37.5);

Console.WriteLine(tmpObj);

Console.WriteLine(tmpObj.Test1());

Console.WriteLine(tmpObj.Test2());

Console.ReadLine();

}

[/code]
结果：
37.5Celsius=99.5Fahrenheit
Havethis.:4375MSEL
Don'thavethis.:4406MSEL

11.可以使用抽象函数重写基类中的虚函数吗？

答：

可以

需使用new修饰符显式声明，表示隐藏了基类中该函数的实现

或增加override修饰符，表示抽象重写了基类中该函数的实现

示例:

[code=alt]classBaseClass

publicvirtualvoidF()

Console.WriteLine("BaseClass.F");

}

abstractclassDeriveClass1:BaseClass

{

publicabstractnewvoidF();

}

//感谢watsonhua(http://huazhihao.cnblogs.com/)的指点

//是他提醒了我还可以用这种方法抽象重写基类的虚方法

abstractclassDeriveClass2:BaseClass

publicabstractoverridevoidF();

[/code]

12.密封类可以有虚函数吗？

答：

可以，基类中的虚函数将隐式的转化为非虚函数，但密封类本身不能再增加新的虚函数

示例：

[code=alt]classBaseClass

publicvirtualvoidF()

Console.WriteLine("BaseClass.F");

}

sealedclassDeriveClass:BaseClass

{

//基类中的虚函数F被隐式的转化为非虚函数

//密封类中不能再声明新的虚函数G

//publicvirtualvoidG()

//{

//Console.WriteLine("DeriveClass.G");

//}

}
[/code]

13.什么是属性访问器？

答：

属性访问器（PropertyAccessor），包括get访问器和set访问器分别用于字段的读写操作

其设计目的主要是为了实现面向对象（OO）中的封装思想。根据该思想，字段最好设为private，一个精巧的类最好不要直接把字段设为公有提供给客户调用端直接访问

另外要注意属性本身并不一定和字段相联系

14.abstract可以和virtual一起使用吗？可以和override一起使用吗？

答：

abstract修饰符不可以和static、virtual修饰符一起使用

abstract修饰符可以和override一起使用，参见第11点

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample14

classBaseClass

publicvirtualvoidF()

Console.WriteLine("BaseClass.F");

}

abstractclassDeriveClass1:BaseClass

{

//在这里，abstract是可以和override一起使用的

publicabstractoverridevoidF();

classProgram

staticvoidMain(string[]args)

}

}
[/code]

15.接口可以包含哪些成员？

答：

接口可以包含属性、方法、索引指示器和事件，但不能包含常量、域、操作符、构造函数和析构函数，而且也不能包含任何静态成员

16.类和结构的区别？

答：
类：

类是引用类型在堆上分配，类的实例进行赋值只是复制了引用，都指向同一段实际对象分配的内存

类有构造和析构函数

类可以继承和被继承

结构：

结构是值类型在栈上分配（虽然栈的访问速度比较堆要快，但栈的资源有限放），结构的赋值将分配产生一个新的对象。

结构没有构造函数，但可以添加。结构没有析构函数

结构不可以继承自另一个结构或被继承，但和类一样可以继承自接口

示例：

根据以上比较，我们可以得出一些轻量级的对象最好使用结构，但数据量大或有复杂处理逻辑对象最好使用类。

如：Geoemtry（GIS里的一个概论，在OGC标准里有定义）最好使用类，而Geometry中点的成员最好使用结构

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample16

interfaceIPoint

doubleX

get;

set;

}

doubleY

{

get;

set;

doubleZ

get;

set;

}

//结构也可以从接口继承

structPoint:IPoint

{

privatedoublex,y,z;

//结构也可以增加构造函数

publicPoint(doubleX,doubleY,doubleZ)

{

this.x=X;

this.y=Y;

this.z=Z;

}

publicdoubleX

{

get{returnx;}

set{x=value;}

publicdoubleY

get{returnx;}

set{x=value;}

}

publicdoubleZ

{

get{returnx;}

set{x=value;}

}

//在此简化了点状Geometry的设计，实际产品中还包含Project（坐标变换）等复杂操作

classPointGeometry

privatePointvalue;

publicPointGeometry(doubleX,doubleY,doubleZ)

value=newPoint(X,Y,Z);

publicPointGeometry(Pointvalue)

//结构的赋值将分配新的内存

this.value=value;

}

publicdoubleX

{

get{returnvalue.X;}

set{this.value.X=value;}

publicdoubleY

get{returnvalue.Y;}

set{this.value.Y=value;}

}

publicdoubleZ

{

get{returnvalue.Z;}

set{this.value.Z=value;}

publicstaticPointGeometryoperator+(PointGeometryLeft,PointGeometryRigth)

returnnewPointGeometry(Left.X+Rigth.X,Left.Y+Rigth.Y,Left.Z+Rigth.Z);

publicoverridestringToString()

returnstring.Format("X:{0},Y:{1},Z:{2}",value.X,value.Y,value.Z);

}

classProgram

{

staticvoidMain(string[]args)

{

PointtmpPoint=newPoint(1,2,3);

PointGeometrytmpPG1=newPointGeometry(tmpPoint);

PointGeometrytmpPG2=newPointGeometry(tmpPoint);

tmpPG2.X=4;

tmpPG2.Y=5;

tmpPG2.Z=6;

//由于结构是值类型，tmpPG1和tmpPG2的坐标并不一样

Console.WriteLine(tmpPG1);

Console.WriteLine(tmpPG2);

//由于类是引用类型，对tmpPG1坐标修改后影响到了tmpPG3

PointGeometrytmpPG3=tmpPG1;

tmpPG1.X=7;

tmpPG1.Y=8;

tmpPG1.Z=9;

Console.WriteLine(tmpPG1);

Console.WriteLine(tmpPG3);

Console.ReadLine();

}

}
[/code]
结果：
X:1,Y:2,Z:3
X:4,Y:5,Z:6
X:7,Y:8,Z:9
X:7,Y:8,Z:9

17.接口的多继承会带来哪些问题？

答：

C#中的接口与类不同，可以使用多继承，即一个子接口可以有多个父接口。但如果两个父成员具有同名的成员，就产生了二义性（这也正是C#中类取消了多继承的原因之一），这时在实现时最好使用显式的声明

示例：

[code=alt]usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespaceExample17

classProgram

//一个完整的接口声明示例

interfaceIExample

{

//属性

stringP

get;

set;

}

//方法

stringF(intValue);

//事件

eventEventHandlerE;

//索引指示器

stringthis[intIndex]

get;

set;

}

interfaceIA

intCount{get;set;}

interfaceIB

intCount();

//IC接口从IA和IB多重继承

interfaceIC:IA,IB

{

classC:IC

privateintcount=100;

//显式声明实现IA接口中的Count属性

intIA.Count

get{return100;}

set{count=value;}

}

//显式声明实现IB接口中的Count方法

intIB.Count()

returncount*count;

}

staticvoidMain(string[]args)

{

CtmpObj=newC();

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

C#面向对象 基础概念25个

C#面向对象基础概念25个