c#关键字详解
Posted LongtengGensSupreme
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c#关键字详解相关的知识，希望对你有一定的参考价值。
c#关键字
|
关键字是对编译器有特殊意义的预定义的保留标识符。它们不能在程序中用作普通标识符，除非在它们前面加上@前缀。
第一部分
一.访问关键字：base，this~~~~base:访问基类的成员。 用于从派生类中访问基类的成员， 1.调用基类上已经被重写的方法。 2.指定创建派生类实例时应调用的基类构造函数。 **对基类的访问只能在 派生类的构造函数 实例的方法 实例的属性访问器 中。 属性访问器：get,set函数。
注意：！！！！！！！！！ 不能在静态方法中使用base关键字。 例： 在子类的方法中写 base.GetInfo();调用基类的方法。 基类中的构造函数重载了，Mybase()和Mybase(int i); 在子类的构造函数中public MyDerived():base(int i) public MyDerived(int i):base()
~~~~this:引用当前对象。 用于引用为其调用方法的当前实例。 静态成员函数没有this指针。 可以用于从 构造函数，实例方法，实例访问器 中访问成员。
this的一般用途： 1.限定被相似的名子隐藏的成员 public void A(int a, int b ) { this.a=a; this.b=b; }
2.将对象作为参数传递到函数中 public void ShowInstance() { print(this); console.writeline("lalalalllalalala"); }
3.声明索引器 public int this[int param] { get{ return array[param]; } set{ array[param]=value; } } 注意！！！！！！静态方法，静态属性访问器或字段声明中不能用this。
二.转换关键字：explicit, implicit, operator1~~~~explicit: 用于声明用户定义的 显式类型转换运算符。 例： class MyType { public static explicit operator MyType(int i) { //从int显式转换成MyType类型的代码！！！ } }
显式类型转换符必须通过类型转换调用。需要在转换失败时抛出异常。 if(转换失败的条件) throw new ArgumentException();
int i; MyType x = (MyType)i; 注意！！！！！！！如果转换可能导致信息丢失，则使用explicit关键字。
2~~~~implicit: 用于声明用户定义的 隐式类型转换运算符。 例： class MyType { public static implicit operator int(MyType i) { //从MyType隐式转换成Mint类型的代码！！！ } } MyType i; int x = i; 注意！！！！！！！！！！！由于隐式转换在程序员未指定的情况下发生，所以必须防止出现不良的后果。只有在一定不会出现异常和信息丢失时才可以使用implicit，否则使用expicit。
3~~~~operator: 用于声明用户在类或结构中自定义的运算符。有四种形式：
public static 结果类型 operator unary-operator (参数类型 参数名) public static implict operator 目标类型 (输入类型 参数名) public static explict operator 目标类型 (输入类型 参数名)
//implict中，目标类型一般是封闭类型，例如：int, double, byte等。 //explict中，目标类型一般是自定义类型，例如：MyType等。
三.文字关键字：null,false,true 1~~~~null: 表示不引用任何对象的空引用的值。null是引用类型的默认值。
2~~~~true： true运算符：用户自定义的类型可以重载true运算符，用来表示是否满足条件，若满足则返回bool值的true，否则返回false。 注意！！！！！！！若在自定义类型中定义了true运算符，则必须定义false运算符。 true文字值：表示bool的真。
3~~~~false： false运算符：用户自定义的类型可以重载false运算符，用来表示是否满足条件，若不满足则返回bool值的true，否则返回false。 注意！！！！！！！若在自定义类型中定义了false运算符，则必须定义true运算符。 false文字值：表示bool的假。
true和false运算符可以用在任何条件判断中。
四.方法参数关键字：params，ref，out1~~~~params：用于指定在参数数目可变处，采用参数的方法参数。只能有一个params，并且在他后面不能再有参数。 ~方法参数：如果在为方法声明参数时未使用 ref 或 out，则该参数可以具有关联的值。可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值 using System; public class MyClass {
public static void UseParams(params int[] list) { for (int i = 0 ; i < list.Length; i++) { Console.WriteLine(list[i]); } Console.WriteLine(); }
public static void UseParams2(params object[] list) { for (int i = 0 ; i < list.Length; i++) { Console.WriteLine(list[i]); } Console.WriteLine(); }
static void Main() { UseParams(1, 2, 3); UseParams2(1, ‘a‘, "test");
// An array of objects can also be passed, as long as // the array type matches the method being called. int[] myarray = new int[3] {10,11,12}; UseParams(myarray); } }
输出
1 2 3
1 a test
10 11 12 //把1，2，3三个参数当成一个数组处理，在最后输出Console.WriteLine();
2~~~~ref：使方法可以引用传递到该方法的参数。当程序跳转到调用方法处的时候，在方法中对参数所做的任何改动都将传递给参数。类似于传地址。 注意！！！！！必须将参数作为ref参数 显示 的传递到方法。参数必须显示的初始化！属性不是变量不能作为ref参数传递。 例子： using System; using System.Collections.Generic; using System.Text; namespace 真的是关键字 { class Program { public static void TestRef(ref string i) { i = "change once!"; }
public static void TestNoRef(string i) { i = "change twice!"; }
static void Main(string[] args) { string i = "begining!"; Console.WriteLine(i);
TestRef(ref i); Console.WriteLine(i);
TestNoRef(i); Console.WriteLine(i);
Console.ReadLine(); } } }输出：beginning！ Change once! Change once!
3.~~~~out：使方法可以引用传递到该方法的同一个变量。当程序跳转到方法调用处时，在方法中对变量所做的任何改动都将传递给该变量。 注意！！！！！当希望方法返回多个值时，声明out非常有用。 一个方法可以有多个out参数。 必须将参数作为out参数显示的传递到方法。 不必初始化作为out参数的变量。 属性不是变量不能作为out变量。 注意！！！！！ref参数必须显示初始化，而out参数不用。 例子： using System; using System.Collections.Generic; using System.Text;
namespace 真的是关键字 { class Program { public static int TestOut(out string i) { i = "change once!"; return -1; }
static void Main(string[] args) { string i = "begining!"; Console.WriteLine(i);
Console.WriteLine(TestOut(out i)); Console.WriteLine(i);
Console.ReadLine(); } } } 5.修饰关键字
1.访问关键字
不嵌套在其他类型中的顶级类型只能有public和internal可访问性，默认是internal。
嵌套类型的可访问性取决于它的可访问域，而且不能超出包含它类型的可访问域。
2.可访问域1.~~~~可访问域：用于指定程序段中可以引用该成员的位置。如果是嵌套类型，那么它的可访问域由成员的访问级别和直接包含该成员的类型的可访问域共同决定。 using System; using System.Collections.Generic; using System.Text;
namespace 真的是关键字 { public class T1 { public static int publicInt; internal static int internalInt; private static int privateInt = 0; // CS0414
public class M1 { public static int publicInt; internal static int internalInt; private static int privateInt = 0; // CS0414 }
private class M2 { public static int publicInt = 0; internal static int internalInt = 0; private static int privateInt = 0; // CS0414 } }
class MainClass { static void Main() { // Access is unlimited: T1.publicInt = 1; // Accessible only in current assembly: T1.internalInt = 2; // Error: inaccessible outside T1: // T1.myPrivateInt = 3;
// Access is unlimited: T1.M1.publicInt = 1; // Accessible only in current assembly: T1.M1.internalInt = 2; // Error: inaccessible outside M1: // T1.M1.myPrivateInt = 3;
// Error: inaccessible outside T1: // T1.M2.myPublicInt = 1; // Error: inaccessible outside T1: // T1.M2.myInternalInt = 2; // Error: inaccessible outside M2: // T1.M2.myPrivateInt = 3; } } } 3.对使用可访问性级别的限制1~~~~基类的可访问性必须不小于派生类。 2~~~~派生类的可访问性必须不大于基类。 3~~~~成员的可访问性至少是包含它的类。 例子： Class BaseClass{}; Public class MyClass: BaseClass{}; 这是错误的！！！！！！！！！！！！！！！！
对使用声明的而访问型级别限制
4.访问修饰关键字1~~~~internal：是类型和类型成员的访问修饰符，只有在同一个程序集中才可以访问。 通俗的说就是：如果用internal修饰，那么只能在定义它的.cs文件中访问它。在别的文件中访问就会出错。
5．其它修饰关键字1~~~~abstract：可用来修饰 类，方法和属性。 （1） 在类的声明中使用abstract，表示这个类只能作为其他类的基类，即抽象类。 抽象类的特点： a．抽象类不能实例化。 b.抽象类可以包含抽象方法和抽象访问器。 c.不能用sealed修饰抽象类，否则，该类不能被继承。 d.从抽象类派生的非抽象类必须包含继承来的所有抽象方法和抽象访问器的实实现。 (2) 在方法和属性中使用abstract，表示此方法或属性 不包含实现。即抽象方法和抽象属性。 抽象方法的特点： A． 抽象方法是隐式的virtual方法。 B． 只允许在抽象类中定义抽象方法。 C． 抽象方法不提供实现，所以没有方法体。 格式如下：没有{}！！！！ Public abstract void MyMethod(); D． 实现由重写方法提供，他是非抽象的。 E． 抽象方法中使用virtual, static, override关键字是错误的。 F． 静态属性上不能使用abstract关键字。 G． 在派生类中，通过使用override 可以重写抽象的继承属性。 H． 抽象类必须为所有接口成员提供实现，或将其映射到抽象方法上去。
// abstract_keyword.cs // Abstract Classes using System; abstract class BaseClass // Abstract class { protected int _x = 100; protected int _y = 150; public abstract void AbstractMethod(); //Abstract method public abstract int X { get; } //abstract property public abstract int Y { get; } }
class DerivedClass : BaseClass { public override void AbstractMethod() { _x++; _y++; }
} public override int X // overriding property { get { return _x + 10; }
public override int Y // overriding property { get { return _y + 10; } }
static void Main() { DerivedClass o = new DerivedClass(); o.AbstractMethod(); Console.WriteLine("x = {0}, y = {1}", o.X, o.Y); } } 输出
x = 111, y = 161 2.~~~~const:用来指定字段或局部变量的之不能被修改。 Public const int a=1，b=2；
3.~~~~event：用于指定一个事件。 指定当代码中的某些事件发生时调用的委托。此委托可以有一个或多个相关联的方法。 创建事件的步骤： 1. 创建或标示一个委托。先有委托后定义事件。 2. 创建一个类，其中包含： A． 委托创建的事件。 B． 调用此事件的方法。 3. 定义将方法连接到事件的类。 4. 使用事件：创建包含事件声明类的对象。 4~~~~extern：表示方法在外部实现。 注意！！！！！不能将extern和abstract一起使用。 格式举例：public static extern int MyMethod (int x); 没有{} 5~~~~override：用于修改方法和属性，通过 override 声明重写的方法称为重写基方法。重写的基方法必须与 override 方法具有相同的签名。 重写基方法：有重写声明的方法。 注意！！！！！不能重写非虚方法或静态方法。 不能使用以下关键字修饰重写方法：new，static，virtual，abstract 重写的属性与重写的方法的要求是一样的。 重写的方法中可以调用基类的原来的virtual方法。 namespace 真的是关键字 { public class Square { public double x; public Square(double x) { this.x = x; } public virtual double Area() { return (x*x); }
}
class Cube : Square { public Cube(double x):base(x) {
}
public override double Area() { return (6*base.Area());//调用base即基类的方法。 } }
class MainClass { static void Main() { double x = 5.2; Square s = new Square(x); Square c = new Cube(x); Console.WriteLine("Area of Square is{0:F2}",s.Area()); Console.WriteLine("Area of Cube is {0:F2}", c.Area()); Console.ReadLine();
} } }
6.~~~~readonly：只可以使用在字段上，被readonly修饰的字段的赋值只能作为 声明的一部分或者在构造函数中。 1.在声明中初始化：public readonly double a=1.1; 2.在构造函数中。 readonly 关键字与 const 关键字不同：const 字段只能在该字段的声明中初始化。readonly段可以在声明或构造函数中初始化。因此，根据所使用的构造函数，readonly 字段可能具有不同的值。另外，const 字段为编译时常数，而 readonly 字段可用于运行时常数。
|