C#中的修饰符

C#中的修饰符有很多，可以分类：

类修饰符，存取修饰符，成员修饰符。

 

(一)   类及其类的存取修饰符有：

public，inner，friend，abastruct，sealed

1.         public：

public class ClassPublic{}

如果一个类声明为public，则该类的应用不受限制。具体含义可与inner参考对比。

2.         inner：

inner class ClassInner{}

如果一个类声明为inner，则该类只在程序集中可见。可以理解成在同一个dll或exe中可以应用该类，但是出了该程序集，则该类就不可见了。

例如:程序集Assm1中有一个public的类ClassPublic一个inner的类ClassInner。

在程序集Assm2中有一个类ClassTest：

class ClassTest

{

ClassPublic demo1;    // 正确，因为ClassPublic类是public类型

ClassInner demo2;   // 错误，因为ClassInner为inner类型，仅在:程序集Assm1中可用，出了:程序集Assm1，就看不见了。

}

 

3.         abastruct：

abstract class ClassAbstract

{

public  ClassAbstract()

{

}

}

表示ClassAbstract demo3 = new ClassAbstract();这句话通不过编译【是错误的】，因为该类是一个抽象类。

如果某个类中包含了一个抽象函数，则这个类必须是一个抽象类。

抽象函数：只有函数的声明而没有实现代码的函数。试想：如果ClassAbstract类中有个抽象函数FunctionAbstract。

demo3.FunctionAbstract()将会怎么执行？不知道怎么执行，因为FunctionAbstract函数没有实现代码。这不乱套了吗？

所以不允许new一个抽象类。

4.         sealed：

sealed class ClassSealed{}

类ClassSealed的意思是不允许被继承。即：

class ClassSealedChild : ClassSealed{}是错误的。

用sealed修饰的类叫密封类。

class Class1{}

sealed class Class : Class1{}

这句话是正确的。

 

成员修饰符：

public, private, protected, virtual, override, abstract, sealed, static, const,readonly,

(二)   用于继承的有：

1.         Public：

一个函数，变量，属性可以是public类型的，即是公共类型。类之外的函数可以调用这个成员。

例如：

Class Class1{

Public string str1;

Private string str2;

Protected string str3;

}

Class Class2

{

Private void Test()

{

Class1 demo1 = new Class1();

String strTest = demo1. str1;    // 正确，因为Class1的str1为public类型

String strTest2 = demo1. str2;   // 错误，因为Class1的str2为private类型

String strTest3 = demo1. str3;   // 错误，因为Class1的str3为protected类型

}

}

Class Class3 : Class1

{

String strTest3 = demo1. str3;   // 争取的，因为Class1的str3为protected类型，而Class3是Class1的派生类（子类）

}

 

2.         Protected：

Protected string str3;

一个函数，变量，属性可以是Protected类型的，即是保护类型。本类及其本类的派生类可以访问。

3.         private：

private string str2;

一个函数，变量，属性可以是private类型的，即是私有类型。类之外的函数不可以调用这个成员。

 

4.         inner

inner string str3;

一个函数，变量，属性可以是inner类型的，即只有在同一个程序集中才可以访问。

 

5.         inner protected/protected inner

inner protected string str4;

protected inner string str5;

这两个变量表示在同一个程序集或者是当前类的派生类才可以访问。

注意：这里不是指：当前类的派生类而且是在同一个程序集中。

6.         virtual

virtual void Test()

{

}

虚函数，参考override修饰符。

7.         abstract

abstract void Test();

abstract string TestStr{

get;set;

}

没有实现代码的函数或属性。包含抽象函数或属性的类必须是抽象类。

8.         override

class Class1{

virtual void Test()

{

….

}

Void Test2()

{

Test();

}

}

 

class Class2 : Class1{

override void Test()   // 正确，覆盖了基类虚函数

{

….

}

}

class Class3 : Class2{

override void Test()   // 正确，覆盖了基类虚函数

{

….

}

}

class Class4 : Class2{

}

 

 

Class1 demo1 = new Class1();

demo1. Test2();                     // Test2中调用的是Class1中的Test函数。

Class2 demo2 = new Class2();

Demo2. Test2();                     // Test2中调用的是Class2中的Test函数。因为Class2重写了Class1中的Test函数

Class3 demo3 = new Class3();

Demo3. Test2();                     // Test2中调用的是Class3中的Test函数。因为Class2重写了Test函数

 

Class4 demo4 = new Class4();

Demo4. Test2();                     // Test2中调用的是Class2中的Test函数。因为Class4没有重写Test，所以它执行其父类代码。

 

 

 

9.         sealed：

sealed可以用来秘方虚函数或抽象函数。例如：

class Class1{

virtual void Test()

{

….

}

}

 

class Class2 : Class1{

sealed override void Test()   // 正确，覆盖了基类虚函数

{

….

}

}

 

class Class3 : Class2{

sealed override void Test()   // 错误，因为虚函数已被Class2密封

{

….

}

}

 

 

(三)   用于声明静态变量或方法：

1.         static

class Class1{

public static string StaticString;

}

C#中，静态变量/函数/属性表示可以通过类名访问的变量/函数/属性。表示该变量/函数/属性是属于类的，而不是属于对象的

Class Class2{

Class1 demo1 = new Class1();

String TestStr = Class1. StaticString;    // 正确。

String TestStr2 = demo1. StaticString;   // 错误，demo1中并没有StaticString这个成员

}

2.         readonly

readonly可以修饰静态变量，表示该变量不可以修改。即静态只读变量。

Static Readonly与const类似。

我们可以用只实现get方法的属性类实现与Static Readonly相似的功能，但是比Static Readonly方便的地方就是属性中可以有变量。

例如：

Static string TXT = “txt”;

Static string TXT2 = TXT + “1234”;   //错误

Static string TXT3

{

Get

{

Return TXT + “1234”;   // 正确

}

}

(四)   用于声明常量

1.          const

class Class1{

public const string ClassName = “Class1”;

}

常量很类似于静态只读变量。

(五)   用于委托的：

1.         delegate：

public delegate  string OnMoveHandler(string name, int id);

声明一个委托，名称叫OnMoveHandler，该委托的返回类型为string，该委托的参数为string name, int id。

(六)   用于事件的：

1.         event

public event OnMoveHandler OnMove;

声明一个事件，该事件的名称为OnMove，类型为OnMoveHandler。

该事件的返回类型string，参数为string name, int id

 

给事件赋值：

Private string MyMove(string name, int id)

{

….

}

 

OnMove += new OnMoveHandler(MyMove);