C#关键字详解（二）

3.  用于数据流程控制的关键字

  此部分关键字根据不同的使用情况又分为：构成选择语句，构成循环语句,构成跳转语句。

1）构成选择语句的关键字

if , else,switch,case,break,default

四种选择结构：

①if ②if-else ③if-else-if  ④switch-case-break-default

2) 构成循环语句的关键字

while，do,for,foreach,in

四种循环结构：

①while ②do-while ③for ④foreach-in

3）构成跳转语句的关键字

continue   用于循环结构中直接跳转到下次循环，其后内容将不再执行。

例如：

              for (int i = 0; i < 5; i++)

               {

               Console.WriteLine("continue之前");

               continue;

               Console.WriteLine("continue之后");

           }  

输出：

break     除了之前提到的用于在switch语句中终止选择，还能应用与循环中终止循环。

例如：     for (int i = 0; i < 5; i++)

               {

               Console.WriteLine("continue之前");

               break;

               Console.WriteLine("continue之后");

           }

输出：

     

 可以看出，在程序第一次执行时，break就跳出了循环。

return    用于终止方法的执行，并立即返回调用方法中。它还可以返回一个可选值。如果方法为 void 类型，则可以省略 return 语句。

    goto     用于跳转到标记语句，可以用它跳出深层嵌套循环。

++如上14个关键字，多应用于控制程序流程，输出特定数据，default还可作为泛型代码中的关键字（++）。

4.用于处理异常的关键字

 此部分关键字有：try,catch,throw,finally

异常处理语句有：

①try-catch   由一个try语句块和一个或多个catch语句块组成，try语句块中用于包含可能发生异常的代码，catch语句块中用于指定不同的异常处理程序。++catch子句可以加上Exception的对象作为参数，并通过相关属性处理异常。

例如：

②throw    用于抛出一个异常，可以单独使用，也可以用于抛出一个Exception类派生类的对象。++

③try-cath-finally      finally语句块用于保存即使发生错误也要执行的语句块。

++  用于处理异常的关键字，一般都结合使用，并且离不开exception类的支持，关于更多异常寻找解决问题，在以后的学习中慢慢总结。

5.   用于修饰数据类型的关键字

  此部分关键字跨度较广，从修饰访问级别到修饰类、接口、变量等，此处将它们分为：访问修饰符，修饰具体数据成员（类型）的修饰符，独特的修饰符

1）访问修饰符      用于修饰指定数据的被访问级别。

以下排列访问公开程度依次降低。

l       public  可以在任意地方被访问

l       internal  只能在本项目中被访问

l       protected 只能在本类和子类中被访问

l       private  只能在本类中被访问

2）修饰具体数据成员（类型）的修饰符

此类修饰符作用于具体的数据成员（类型），每个都有其特性，在此简单概括和引用，待以后学习之后再做详解探讨。

abstract    指定抽象类型。指定某个类只能是其他类的基类，即抽象类。修饰的方法或属性不包含实现（方法体）。

const   修饰声明字段为常量（既无法修改或重新赋值）。

delegate  声明委托。 

event    声明事件。

extern   声明在外部实现的方法。

override 提供从基类继承的虚拟成员的新实现。(重写基方法)

readonly 声明一个字段，该字段只能赋值为该声明的一部分或者在同一个类的构造函数中。

sealed 指定类不能被继承。

unsafe 声明不安全的上下文。

virtual 在派生类中声明其实现可由重写成员更改的方法或访问器。

void     指定方法不返回值。 

volatile 指示字段可由操作系统、硬件或并发执行线程等在程序中进行修改。

3）独特的修饰符

  该类包括关键词：static 

static   用于声明类型为静态成员。即该数据不属于对象而属于类型本身，不能通过对象引用，可以用类型名称引用。

例如：

1））关于静态类：

1）静态类不能实例化；

2）静态类中的成员必须是静态的，除了常量和结构，其他声明在静态类中的类型必须用static修饰。

3）静态类不能包含sealed和abstract修饰符；

4）静态类无法派生（被继承）；

5）++

2））关于静态与非静态字段使用比较：

静态：classTest

       {

       staticint x = y;

       staticint y = 5;

 

       staticvoid Main()

       {           

           Console.WriteLine(y);

           Console.WriteLine(x);        //静态字段初始值即使未声明也可以调用，输出为默认值   

           x = 99;

           Console.WriteLine(x);

           Console.ReadLine();

       }

   }

输出为：5,0,99

非静态：classTest

             {

        int x = y;

      staticint y = 5;

       staticvoid Main()

           {

           Test r =newTest();                      

           Console.WriteLine(r.x);          //非静态字段在被调用时，引用了静态字段的值。如果上面

           Console.WriteLine(y);          //的y声明为非静态类型，则会发生错误

           r.x = 10;

           Console.WriteLine(r.x);

           Console.WriteLine(y);

           Console.ReadLine();

           }

             }

输出为：5,5,10,5

 3））关于静态方法与实例方法

1.静态方法可以直接通过类名.成员名访问级别允许的静态成员（同一类中可省略类名），访问非静态成员时，无论是在同一类中还是在不同类中，都需要先进性实例化，通过对象对级别允许的非静态成员进行调用。

2.实例方法可以直接通过类名.成员名访问级别允许的静态成员（同一类中可省略类名），也可以直接调用同一类中级别允许的非静态成员（也可以用this指定对本类非静态成员的引用），调用其他类中的非静态成员需要进行实例化，通过对象调用。

二者的区别就是在同一类中，静态方法不能直接调用非静态成员，而实例方法可以。另外，对于关键字this，在静态方法中不能使用。

静态成员的创建通常应用于保存无需创建对象就能访问的数据和函数，这些数据和函数应该独立于对象，不与其关联。不能用new来创建静态类的实例。

   静态属性与实例属性，静态事件与实例事件的区别，与静态方法类似，（静态构造函数的使用暂时无力言表++）。

 ++在此篇总结中对17个修饰符只是简单介绍，因为了解不足，不敢妄加言论，待学习加深后再对修饰符一类做总结。

6.文字运算符及其关联的关键字

as    用于在兼容的类型之间执行转换，但是只执行引用转换和装箱、取消装箱转换（object转换为string类型，如果可以则输出引用值，不能则输出null而不发生报错）。

               object s = 10;

               string a = sas string;

           Console.WriteLine(a);

          输出为空。

               object s ="10";

               string a = sas string;

           Console.WriteLine(a);

 输出为10。

        is    用于检查对象是否与给定类型兼容，同as一样只执行引用和装箱、取消装箱转换。

       object a="5";       

          if (ais string)

           {

               Console.WriteLine("彬彬你好！");

           }

           else

           {

               Console.WriteLine("世界真小！");

       }

 输出“彬彬你好！”

           object a=5;

           if (ais string)

           {

               Console.WriteLine("彬彬你好！");

           }

           else

           {

               Console.WriteLine("世界真小！");

       }

输出“世界真小！”

   classA

   {

   }

   classB

   {

       staticvoid Main(string[] args)

       {

           A r =newA();

           if (ris A)

           {

               Console.WriteLine("1");

           }

           else

           {

               Console.WriteLine("2");

           }

           Console.ReadKey();

       }

   }

输出“1”。

 sizeof   用于获取值类型的字节大小。

          int size=sizeof(decimal);

           Console.WriteLine(size);

输出“16”。

 typeof  用于获取类型的system.Type对象。

       Type type=typeof(object);

           Console.WriteLine(type);  

  输出“System.Object”。                                     ++暂时不明白具体用途

 operator 重载内置运算符，或提供类或接口的用户定义转换。                                   ++

 explicit  声明必须使用强制转换来调用的用户定义的类型转换运算符。                           ++

  implicit 声明隐式的用户定义类型转换运算符。如果可以确保转换过程不会造成数据丢失，则可以使用该关键字在用户定义类型和其他类型之间进行隐式转换。           ++     

7.与参数关联的关键字

    out        用于有多个返回值的方法中，通过该关键字引用传递参数来返回值。

     staticvoid Main(string[] args)

       {

           int a=8;           

           int number=Test("5",out a);

           Console.WriteLine(number);

           Console.WriteLine(a);

           Console.ReadKey();

       }

       staticint Test(string str,outint a)

       {

           int number;

           number =Convert.ToInt32(str);

           a = number+1;

           return number;

       }

 输出“5”，“6”。

       ref            与out一样用于有多个返回值的方法中，以传参的形式返回值。

    out与ref的区别：

    1） Out传参，要求在传递之后的被调用方法中变量必须被重新赋值而调用方法中可以不赋值，而ref传参则要求变量必须在传递之前的调用方法中被赋值而被调用方法中可以不赋值。

    2） Out是从被调用方法中传出值，而ref既可以传入，又可以传出值。ref定义的变量值是互通的，可以在调用方法和被调用方法之间传入和传出值，并且这两个不在同一方法中的变量值任意改变一个都会使得另一变量值改变。而out只是被调用方法中的值单向传出（传回）调用方法中。

       staticvoid Main(string[] args)        //调用方法

       {

           int a=8;

           int number=Test("5",out a);

           Console.WriteLine(number);

           Console.WriteLine(a);

           Console.ReadKey();

       }

       staticint Test(string str,outint a)         //被调用方法

       {

           int number;

           number =Convert.ToInt32(str);

           a = a * number;

           return number;           

       }

如上，即便是在调用方法中，a被初始化赋值，在被调用方法中，依然报错使用了未赋值的变量a.而如果把out改为ref,则不会报错，输出：“5”，“40”。

 staticvoid Main(string[] args)

       {

           int[] number =newint[5];

           for (int i = 0; i < 5; i++)

           {

               Console.WriteLine("请您输入第{0}个数字", i + 1);

               number[i] = ReadInt(ref i);         

           }

           for (int i = 0; i < 5; i++)

           {

               Console.Write("{0}\t", number[i]);

           }

           Console.ReadKey();

       }

       staticint ReadInt(ref int i)  //通过ref，为方法中输入了i

       {

           while (true)

           {

               try

               {

                   int numbers =Convert.ToInt32(Console.ReadLine());

                   return numbers;

               }

               catch

               {

                   Console.WriteLine("您的输入有误,请重新输入第{0}个数字", i + 1);

               }

           }

       }

 

如上代码通过ref向被调用方法ReadInt方法中传入i,换成out则无法使用，因为在被调用方法中i并未被重新赋值。

params   当参数数目过多或不确定时，用该关键字修饰字段。

  staticvoid Main(string[] args)

       {

           int[] array = { 15,18,12,45,-3,0,23,-19,3};

           int[] arrays = Test(array);

           Console.WriteLine("从大到小依次为：");

           for (int i = 0; i < arrays.Length; i++)

           {

               Console.Write("{0}\t",arrays[i]);

           }

           Console.ReadKey();

       }

       staticint[] Test(params  int[] array)

       {

           for (int k = 0; k < array.Length ; k++)

           {

               int temp;

               for (int i = 0; i <array.Length-k-1; i++)

               {

                   if (array[i] < array[i + 1])

                   {

                       temp = array[i];

                       array[i] = array[i + 1];

                       array[i + 1] = temp;

                   }

               }

           }

           return array;

       }

8.其他

 checked     用于对整式运算和显示转换中启用溢出检查，默认情况下编译器会做溢出检查。

 unchecked   用于取消对整式运算和显示转换中的溢出检查。

          unchecked

           {

              int test=2147483647*2;

               Console.WriteLine("无溢出{0}", test);

           }

编译并未报错，但是输出却为-2。

+++为什么下边的整形运算溢出却报错了么？

           unchecked

           {

               byte a = 255 * 2;

           }               

个人猜测：对于byte类型的变量a赋值前，等号右边的值被当做常量，因而此处属于赋值检查，程序并未由unchecked检查。

       fixed  进制垃圾回收器重新定位可以动的变量。  ++

     lock   将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句然后释放该锁。应用于多线程。           +

     new    作为修饰符可用于向基类成员隐藏继承成员。作为运算符可用于创建对象和调用值类型的默认构造函数。作为约束可用于在泛型声明中约束可能用作类型参数的参数的类型。

    this           用于引用本类中的实例，不能在静态方法，静态属性中使用，可在静态类的非静态方法中使用。

    base   用于从派生类中访问基类成员。不能在静态方法中使用。

    using   作为指令用于引用命名空间，作为语句，用于释放对象占用资源。

    stackalloc    用于不安全的上下文中，以便在堆栈上分配内存块。