修饰符.txt

C#实验报告 C#实验报告 C#实验报告 C#实验报告 C#实验报告 C#实验报告 C#实验报告

new 修饰符

使用 new 修饰符显式隐藏从基类继承的成员。若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它。
请看下面的类：
public class MyBaseC 
{
   public int x;
   public void Invoke() {}
}
在派生类中用 Invoke 名称声明成员会隐藏基类中的 Invoke 方法，即：
public class MyDerivedC : MyBaseC
{
   new public void Invoke() {}
}
但是，因为字段 x 不是通过类似名隐藏的，所以不会影响该字段。
通过继承隐藏名称采用下列形式之一： 
引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。 
引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。有关更多信息，请参见 3.6 签名和重载。 
引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。 
在同一成员上同时使用 new 和 override 是错误的。
在不隐藏继承成员的声明中使用 new 修饰符将生成警告。
有关隐藏名称的更多信息，请参见 3.7.1 名称隐藏。
有关完全限定名的更多信息，请参见 3.8.1 完全限定名。
示例
在该例中，基类 MyBaseC 和派生类 MyDerivedC 使用相同的字段名 x，从而隐藏了继承字段的值。该例说明了 new 修饰符的使用。同时也说明了如何使用完全限定名访问基类的隐藏成员。
// cs_modifier_new.cs
// The new modifier
using System;
public class MyBaseC 
{
   public static int x = 55;
   public static int y = 22;
}

public class MyDerivedC : MyBaseC 
{
   new public static int x = 100;   // Name hiding
   public static void Main() 
   {
      // Display the overlapping value of x:
      Console.WriteLine(x);

      // Access the hidden value of x:
      Console.WriteLine(MyBaseC.x);

      // Display the unhidden member y:
      Console.WriteLine(y);
   }
}
输出
100
55
22
如果移除 new 修饰符，程序将继续编译和运行，但您会收到以下警告：
The keyword new is required on 'MyDerivedC.x' because it hides inherited member 'MyBaseC.x'.
如果嵌套类型正在隐藏另一种类型，如下例所示，也可以使用 new 修饰符修改此嵌套类型。
示例
在该例中，嵌套类 MyClass 隐藏了基类中具有相同名称的类。该例不仅说明了如何使用完全限定名访问隐藏类成员，同时也说明了如何使用 new 修饰符消除警告消息。
// cs_modifer_new_nested.cs
// Using the new modifier with nested types
using System;
public class MyBaseC 
{
   public class MyClass 
   {
      public int x = 200;
      public int y;
   }
}

public class MyDerivedC : MyBaseC 
{
   new public class MyClass   // nested type hiding the base type members
   {
      public int x = 100;
      public int y; 
      public int z;
   }

   public static void Main() 
   {
      // Creating object from the overlapping class:
      MyClass S1  = new MyClass();

      // Creating object from the hidden class:
      MyBaseC.MyClass S2 = new MyBaseC.MyClass();

      Console.WriteLine(S1.x);
      Console.WriteLine(S2.x);   
   }
}
输出
100
200
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
public 修饰符

声明类、接口或成员具有公共可见性。

public statement
参数
statement 
必选。类、接口或成员定义。 
备注
public 修饰符使类的成员对于可访问该类的所有代码都可见。

所有类和接口在默认情况下都为 public。类或接口的成员可以使用 public 修饰符来标记。

不能将 public 修饰符与其他任何可见性修饰符（private、protected 或 internal）组合。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
protected 修饰符

声明类成员或接口成员具有受保护的可见性。

protected statement
参数
statement 
必选。类成员或接口成员定义。 
备注
protected 标识符使类或接口的成员仅在该类或接口以及当前类的所有派生类中可见。当前类之外的代码无法访问 protected 成员。

全局范围内的类和接口不能使用 protected 修饰符来标记。类或接口（包括嵌套类和嵌套接口）的任何成员都可以使用 protected 修饰符来标记。

不能将 protected 修饰符与其他任何可见性修饰符（public、private 或 internal）组合。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
private 修饰符

声明类成员具有私有可见性。

private statement
参数
statement 
必选。类成员定义。 
备注
private 修饰符使一个类的成员仅在该类中可见。当前类（包括派生类）之外的代码不能访问 private 成员。

全局范围内的类和接口不能使用 private 修饰符来标记。类或接口（包括嵌套类和嵌套接口）的任何成员都可以使用 private 修饰符来标记。

不能将 private 修饰符与其他任何可见性修饰符（public、protected 或 internal）组合。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
internal 修饰符

声明类、类成员、接口或接口成员具有内部可见性。

internal statement
参数
statement 
必选。类、接口或成员定义。 
备注
internal 修饰符使类、接口或成员仅在当前包中可见。当前包之外的代码不能访问 internal 成员。

类和接口可以使用 internal 修饰符来标记。在全局范围内，internal 修饰符与 public 修饰符相同。类或接口的任何成员都可以使用 internal 修饰符来标记。

不能将 internal 修饰符与其他任何可见性修饰符（public、private 或 protected）组合。可见性修饰符相对于它们的定义范围。例如，不能公开访问 internal 类的 public 方法，但任何具有该类访问权的代码都可以访问该方法。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。

在类声明中使用 abstract 修饰符以指示类只能是其他类的基类。

抽象类具有以下特性： 

抽象类不能实例化。 
抽象类可以包含抽象方法和抽象访问器。 
不能用 sealed 修饰符修改抽象类，这意味着该类不能被继承。 
从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。 
在方法或属性声明中使用 abstract 修饰符以指示此方法或属性不包含实现。

抽象方法具有以下特性： 

抽象方法是隐式的 virtual 方法。 
只允许在抽象类中使用抽象方法声明。 
因为抽象方法声明不提供实实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。例如： 
public abstract void MyMethod();
实现由 overriding 方法提供，它是非抽象类的成员。 
在抽象方法声明中使用 static 或 virtual 修饰符是错误的。 
除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。 

在静态属性上使用 abstract 修饰符是错误的。 
在派生类中，通过包括使用 override 修饰符的属性声明可以重写抽象的继承属性。 
抽象类必须为所有接口成员提供实现。

实现接口的抽象类可以将接口方法映射到抽象方法上。例如：

interface I 
{
   void M();
}
abstract class C: I 
{
   public abstract void M();
}
有关更多信息，请参见 10.1.1.1 抽象类和 10.5.6 抽象方法。

示例
在本例中，MyDerivedC 类是从抽象类 MyBaseC 派生的。抽象类包含一个抽象方法 MyMethod() 和两个抽象属性：GetX() 和 GetY()。

// abstract_keyword.cs
// Abstract Classes
using System;
abstract class MyBaseC   // Abstract class
{
   protected int x = 100; 
   protected int y = 150;
   public abstract void MyMethod();   // Abstract method

   public abstract int GetX   // Abstract property
   {
      get;
   }

   public abstract int GetY   // Abstract property
   {
      get;
   }
}

class MyDerivedC: MyBaseC
{
   public override void MyMethod() 
   {
      x++;
      y++;   
   }   

   public override int GetX   // overriding property
   {
      get 
      {
         return x+10;
      }
   }

   public override int GetY   // overriding property
   {
      get
      {
         return y+10;
      }
   }

   public static void Main() 
   {
      MyDerivedC mC = new MyDerivedC();
      mC.MyMethod();
      Console.WriteLine("x = {0}, y = {1}", mC.GetX, mC.GetY);    
   }
}
输出
x = 111, y = 161
在上面的示例中，如果试图通过使用下面的语句将抽象类实例化：

MyBaseC mC1 = new MyBaseC();   // Error
将收到以下错误信息：

Cannot create an instance of the abstract class 'MyBaseC'.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
sealed 修饰符

密封类不能被继承。将密封类用作基类是错误的。在类声明中使用 sealed 修饰符可防止继承此类。

不允许将 abstract 修饰符用于密封类。

结构是隐式密封的；因此它们不能被继承。

示例
// cs_sealed_keyword.cs
// Sealed classes
using System;
sealed class MyClass 
{
   public int x; 
   public int y;
}

class MainClass 
{
   public static void Main() 
   {
      MyClass mC = new MyClass(); 
      mC.x = 110;
      mC.y = 150;
      Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y); 
   }
}
输出
x = 110, y = 150
在前面的示例中，如果试图通过使用下面的语句从密封类继承：

class MyDerivedC: MyClass {}   // Error
将收到错误信息：

'MyDerivedC' cannot inherit from sealed class 'MyBaseC'.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
override 修饰符 

 重写方法使用 override 修饰符来修改方法、属性、索引器或事件。重写方法提供从基类继承的成员的新实现。由重写声明重写的方法称为重写基方法。
重写基方法必须与重写方法具有相同的签名。
不能重写非虚方法或静态方法。重写基方法必须是虚拟的、抽象的或重写的。