C#关键字详解.docx

C#关键字详解.docx

《C#关键字详解.docx》由会员分享，可在线阅读，更多相关《C#关键字详解.docx（50页珍藏版）》请在冰豆网上搜索。

C#关键字详解

1第一部分

2访问关键字：

base，this

3base

访问基类的成员。

用于从派生类中访问基类的成员，

1.调用基类上已经被重写的方法。

2.指定创建派生类实例时应调用的基类构造函数。

**对基类的访问只能在派生类的构造函数实例的方法实例的属性访问器中。

属性访问器：

get,set函数。

注意：

！

！

！

！

！

！

！

！

！

不能在静态方法中使用base关键字。

例：

在子类的方法中写base.GetInfo（）;调用基类的方法。

基类中的构造函数重载了，Mybase（）和Mybase（inti）;

在子类的构造函数中publicMyDerived（）:

base（inti）

publicMyDerived（inti）:

base（）

this:

引用当前对象。

用于引用为其调用方法的当前实例。

静态成员函数没有this指针。

可以用于从构造函数，实例方法，实例访问器中访问成员。

this的一般用途：

1.限定被相似的名子隐藏的成员

publicvoidA（inta,intb）

{

this.a=a;

this.b=b;

}

2.将对象作为参数传递到函数中

publicvoidShowInstance（）

{

print（this）;

console.writeline（"lalalalllalalala"）;

}

3.声明索引器

publicintthis[intparam]

{

get{returnarray[param];}

set{array[param]=value;}

}

注意！

！

！

！

！

！

静态方法，静态属性访问器或字段声明中不能用this。

二.转换关键字：

explicit,implicit,operator

1explicit:

用于声明用户定义的显式类型转换运算符。

例：

classMyType

{

publicstaticexplicitoperatorMyType（inti）

{

//从int显式转换成MyType类型的代码！

！

！

}

}

显式类型转换符必须通过类型转换调用。

需要在转换失败时抛出异常。

if（转换失败的条件）

thrownewArgumentException（）;

inti;

MyTypex=（MyType）i;

注意！

！

！

！

！

！

！

如果转换可能导致信息丢失，则使用explicit关键字。

2implicit:

用于声明用户定义的隐式类型转换运算符。

例：

classMyType

{

publicstaticimplicitoperatorint（MyTypei）

{

//从MyType隐式转换成Mint类型的代码！

！

！

}

}

MyTypei;

intx=i;

注意！

！

！

！

！

！

！

！

！

！

！

由于隐式转换在程序员未指定的情况下发生，所以必须防止出现不良的后果。

只有在一定不会出现异常和信息丢失时才可以使用implicit，否则使用expicit。

3operator:

用于声明用户在类或结构中自定义的运算符。

有四种形式：

publicstatic结果类型operatorunary-operator（参数类型参数名）

publicstaticimplictoperator目标类型（输入类型参数名）

publicstaticexplictoperator目标类型（输入类型参数名）

//implict中，目标类型一般是封闭类型，例如：

int,double,byte等。

//explict中，目标类型一般是自定义类型，例如：

MyType等。

三.文字关键字：

null,false,true

1null:

表示不引用任何对象的空引用的值。

null是引用类型的默认值。

2true：

true运算符：

用户自定义的类型可以重载true运算符，用来表示是否满足条件，若满足则返回bool值的true，否则返回false。

注意！

！

！

！

！

！

！

若在自定义类型中定义了true运算符，则必须定义false运算符。

true文字值：

表示bool的真。

3false：

false运算符：

用户自定义的类型可以重载false运算符，用来表示是否满足条件，若不满足则返回bool值的true，否则返回false。

注意！

！

！

！

！

！

！

若在自定义类型中定义了false运算符，则必须定义true运算符。

false文字值：

表示bool的假。

true和false运算符可以用在任何条件判断中。

四.方法参数关键字：

params，ref，out

1params：

用于指定在参数数目可变处，采用参数的方法参数。

只能有一个params，并且在他后面不能再有参数。

~方法参数：

如果在为方法声明参数时未使用ref或out，则该参数可以具有关联的值。

可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值

usingSystem;

publicclassMyClass

{

publicstaticvoidUseParams（paramsint[]list）

{

for（inti=0;i

{

Console.WriteLine（list[i]）;

}

Console.WriteLine（）;

}

publicstaticvoidUseParams2（paramsobject[]list）

{

for（inti=0;i

{

Console.WriteLine（list[i]）;

}

Console.WriteLine（）;

}

staticvoidMain（）

{

UseParams（1,2,3）;

UseParams2（1,'a',"test"）;

//Anarrayofobjectscanalsobepassed,aslongas

//thearraytypematchesthemethodbeingcalled.

int[]myarray=newint[3]{10,11,12};

UseParams（myarray）;

}

}

输出

1

2

3

1

a

test

10

11

12

//把1，2，3三个参数当成一个数组处理，在最后输出Console.WriteLine（）;

2ref：

使方法可以引用传递到该方法的参数。

当程序跳转到调用方法处的时候，在方法中对参数所做的任何改动都将传递给参数。

类似于传地址。

注意！

！

！

！

！

必须将参数作为ref参数显示的传递到方法。

参数必须显示的初始化！

属性不是变量不能作为ref参数传递。

例子：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespace真的是关键字

{

classProgram

{

publicstaticvoidTestRef（refstringi）

{

i="changeonce!

";

}

publicstaticvoidTestNoRef（stringi）

{

i="changetwice!

";

}

staticvoidMain（string[]args）

{

stringi="begining!

";

Console.WriteLine（i）;

TestRef（refi）;

Console.WriteLine（i）;

TestNoRef（i）;

Console.WriteLine（i）;

Console.ReadLine（）;

}

}

}输出：

beginning！

Changeonce!

Changeonce!

3.out：

使方法可以引用传递到该方法的同一个变量。

当程序跳转到方法调用处时，在方法中对变量所做的任何改动都将传递给该变量。

注意！

！

！

！

！

当希望方法返回多个值时，声明out非常有用。

一个方法可以有多个out参数。

必须将参数作为out参数显示的传递到方法。

不必初始化作为out参数的变量。

属性不是变量不能作为out变量。

注意！

！

！

！

！

ref参数必须显示初始化，而out参数不用。

例子：

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespace真的是关键字

{

classProgram

{

publicstaticintTestOut（outstringi）

{

i="changeonce!

";

return-1;

}

staticvoidMain（string[]args）

{

stringi="begining!

";

Console.WriteLine（i）;

Console.WriteLine（TestOut（outi））;

Console.WriteLine（i）;

Console.ReadLine（）;

}

}

}

5.修饰关键字

修饰符作用

访问修饰符

Public

Private

Internal

protected指定声明的类型和成员的可访问性

abstract指示某个类只能是其他类的基类，虚基类。

Const指定无法修改字段或局部变量的值，只能在声明时初始化。

Event声明一个事件

Extern指示外部实现此方法

Override提供从基类继承的虚拟成员的新实现

Readonly声明的字段只能在声明时或构造函数中初始化。

Sealed指定该类不能被继承

Static声明对象属于类本身不属于特定的对象。

Unsafe声明不安全的上下文

Virtual在派生类中实现具体方法，可以重写。

Volatile指示字段可以由操作系统，硬件或并发的线程等在程序中修改。

1.访问关键字

声明的可访问性意义

public访问不受限制

Protected访问仅限于包含类或从包含类派生的类

Internal访问仅限于当前项目

Protectedinternal访问仅限于包含类或从包含类派生的当前项目和类

Private访问仅限于包含类

不嵌套在其他类型中的顶级类型只能有public和internal可访问性，默认是internal。

类型默认的成员可访问性允许的访问性

枚举Public无（internal）

Public

Protected

类PrivateInternal

Private

Protectedinternal

接口Public无（internal）

Public

结构PrivateInternal

Private

嵌套类型的可访问性取决于它的可访问域，而且不能超出包含它类型的可访问域。

2.可访问域

1.可访问域：

用于指定程序段中可以引用该成员的位置。

如果是嵌套类型，那么它的可访问域由成员的访问级别和直接包含该成员的类型的可访问域共同决定。

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Text;

namespace真的是关键字

{

publicclassT1

{

publicstaticintpublicInt;

internalstaticintinternalInt;

privatestaticintprivateInt=0;//CS0414

publicclassM1

{

publicstaticintpublicInt;

internalstaticintinternalInt;

privatestaticintprivateInt=0;//CS0414

}

privateclassM2

{

publicstaticintpublicInt=0;

internalstaticintinternalInt=0;

privatestaticintprivateInt=0;//CS0414

}

}

classMainClass

{

staticvoidMain（）

{

//Accessisunlimited:

T1.publicInt=1;

//Accessibleonlyincurrentassembly:

T1.internalInt=2;

//Error:

inaccessibleoutsideT1:

//T1.myPrivateInt=3;

//Accessisunlimited:

T1.M1.publicInt=1;

//Accessibleonlyincurrentassembly:

T1.M1.internalInt=2;

//Error:

inaccessibleoutsideM1:

//T1.M1.myPrivateInt=3;

//Error:

inaccessibleoutsideT1:

//T1.M2.myPublicInt=1;

//Error:

inaccessibleoutsideT1:

//T1.M2.myInternalInt=2;

//Error:

inaccessibleoutsideM2:

//T1.M2.myPrivateInt=3;

}

}

}

3.对使用可访问性级别的限制

1基类的可访问性必须不小于派生类。

2派生类的可访问性必须不大于基类。

3成员的可访问性至少是包含它的类。

例子：

ClassBaseClass{};

PublicclassMyClass:

BaseClass{};

这是错误的！

！

！

！

！

！

！

！

！

！

！

！

！

！

！

！

对使用声明的而访问型级别限制

上下文备注

类类类型的直接基类必须至少与类类型本身具有同样的可访问性。

接口接口类型的显式基类接口必须至少与接口类型具有同样的可访问性。

委托返回类型和参数类型必须至少与委托本身具有同样的可访问性。

方法返回类型和参数类型必须至少与方法本身具有同样的可访问性。

运算符返回类型和参数类型必须至少与运算符本身具有同样的可访问性。

构造函数它的参数必须至少与构造函数本身具有同样的可访问性。

字段（它是包含在类或结构中的对象或值）字段的可访问性必须至少与字段本身具有同样的可访问性。

4.访问修饰关键字

1internal：

是类型和类型成员的访问修饰符，只有在同一个程序集中才可以访问。

通俗的说就是：

如果用internal修饰，那么只能在定义它的.cs文件中访问它。

在别的文件中访问就会出错。

5．其它修饰关键字

1abstract：

可用来修饰类，方法和属性。

（1）在类的声明中使用abstract，表示这个类只能作为其他类的基类，即抽象类。

抽象类的特点：

a．抽象类不能实例化。

b.抽象类可以包含抽象方法和抽象访问器。

c.不能用sealed修饰抽象类，否则，该类不能被继承。

d.从抽象类派生的非抽象类必须包含继承来的所有抽象方法和抽象访问器的实实现。

（2）在方法和属性中使用abstract，表示此方法或属性不包含实现。

即抽象方法和抽象属性。

抽象方法的特点：

A．抽象方法是隐式的virtual方法。

B．只允许在抽象类中定义抽象方法。

C．抽象方法不提供实现，所以没有方法体。

格式如下：

没有{}！

！

！

！

PublicabstractvoidMyMethod（）;

D．实现由重写方法提供，他是非抽象的。

E．抽象方法中使用virtual,static,override关键字是错误的。

F．静态属性上不能使用abstract关键字。

G．在派生类中，通过使用override可以重写抽象的继承属性。

H．抽象类必须为所有接口成员提供实现，或将其映射到抽象方法上去。

//abstract_keyword.cs

//AbstractClasses

usingSystem;

abstractclassBaseClass//Abstractclass

{

protectedint_x=100;

protectedint_y=150;

publicabstractvoidAbstractMethod（）;//Abstractmethod

publicabstractintX{get;}

//abstractproperty

publicabstractintY{get;}

}

classDerivedClass:

BaseClass

{

publicoverridevoidAbstractMethod（）

{

_x++;

_y++;

}

}

publicoverrideintX//overridingproperty

{

get

{

return_x+10;

}

publicoverrideintY//overridingproperty

{

get

{

return_y+10;

}

}

staticvoidMain（）

{

DerivedClasso=newDerivedClass（）;

o.AbstractMethod（）;

Console.WriteLine（"x={0},y={1}",o.X,o.Y）;

}

}

输出

x=111,y=161

2.const:

用来指定字段或局部变量的之不能被修改。

Publicconstinta=1，b=2；

3.event：

用于指定一个事件。

指定当代码中的某些事件发生时调用的委托。

此委托可以有一个或多个相关联的方法。

创建事件的步骤：

1.创建或标示一个委托。

先有委托后定义事件。

2.创建一个类，其中包含：

A．委托创建的事件。

B．调用此事件的方法。

3.定义将方法连接到事件的类。

4.使用事件：

创建包含事件声明类的对象。

4extern：

表示方法在外部实现。

注意！

！

！

！

！

不能将extern和abstract一起使用。

格式举例：

publicstaticexternintMyMethod（intx）;没有{}

5override：

用于修改方法和属性，通过override声明重写的方法称为重写基方法。

重写的基方法必须与override方法具有相同的签名。

重写基方法：

有重写声明的方法。

注意！

！

！

！

！

不能重写非虚方法或静态方法。

不能使用以下关键字修饰重写方法：

new，static，virtual，abstract

重写的属性与重写的方法的要求是一样的。

重写的方法中可以调用基类的原来的virtual方法。

namespace真的是关键字

{

publicclassSquare

{

publicdoublex;

publicSquare（doublex）

{

this.x=x;

}

publicvirtualdoubleArea（）

{

return（x*x）;

}

}

classCube:

Square

{

publicCube（doublex）:

base（x）

{

}

publicoverridedoubleArea（）

{

return（6*base.Area（））;//调用base即基类的方法。

}

}

classMainClass

{

staticvoidMain（）

{

doublex=5.2;

Squares=newSquare（x）;

Squarec=newCube（x）;

Console.WriteLine（"AreaofSquareis{0:

F2}",s.Area（））;

Console.WriteLine（"AreaofCubeis{0:

F2}",c.Area（））;

Console.ReadLine（）;

}

}

}

6.readonly：

只可以使用在字段上，被readonly修饰的字段的赋值只能作为声明的一部分或者在构造函数中。

1.在声明中初始化：

publicreadonlydoublea=1.1;

2.在构造函数中。

readonly关键字与const关键字不同：

const字段只能在该字段的声明中初始化。

readonly段可以在声明或构造函数中初始化。

因此，根据所使用的构造函数，readonly字段可能具有不同的值。

另外，const字段为编译时常数，而readonly字段可用于运行时常数。

usingSystem;

publicclassReadOnlyTest

{

classSampleClass

{

publicintx;

//Initializeareadonlyfield

publicreadonlyinty=25;

publicreadonlyintz;

publicSampleClass（）

{

//Initializeareadonlyinstancefield

z=24;

}

publicSampleClass（intp1,intp2,intp3）

{

x=p1;

y=p2;

z=p3;

}

}

staticvoidMain（）

{

SampleClassp1=newSampleClass（11,21,32）;//OK

Console.WriteLine（"p1:

x={0},y={1},z={2}",p1.x,p1.y,p1.z）;

SampleClassp2=newSampleClass（）;

p2.x=55;//OK

Console.WriteLine（"p2:

x={0},y={1},z={2}",p2.x,p2.y,p2.z）;

}

}

输出

p1:

x=11,