c# 关键字的含义

关键字在C#中有特殊的用途，不能用作标识符或变量名，因为它们已经被预留给特定的编程功能或语法结构。

常见的关键字与含义

在C#中，常用的关键字以及它们的含义如下：

1. **public**: 表示一个类成员或方法是公开的，可以从任何地方访问。

2. **private**: 表示一个类成员或方法是私有的，只能在当前类内部访问。

3. **protected**: 表示一个类成员或方法是受保护的，只能在当前类及其派生类中访问。

4. **internal**: 表示一个类成员或方法对当前程序集可见，但对其他程序集不可见。

5. **static**: 用于定义静态成员，静态成员属于类而不是类的实例，可以通过类名直接访问。

6. **const**: 用于声明常量，常量的值在编译时确定且不能修改。

7. **readonly**: 用于声明只读字段，只读字段的值在运行时确定且不能再次修改。

8. **new**: 用于隐藏基类中的成员，指示派生类中的成员将隐藏具有相同名称的基类成员。

9. **abstract**: 用于定义抽象类和抽象成员，抽象类不能被实例化，而抽象成员只有声明没有实现，必须在派生类中实现。

10. **override**: 用于重写基类中的虚方法，指示派生类中的方法将覆盖基类中的方法。

11. **virtual**: 用于定义虚方法，虚方法可以在派生类中重写。

12. **this**: 表示当前对象的实例，可用于访问当前对象的成员或调用其方法。

13. **base**: 表示基类的实例，可用于访问基类的成员或调用其方法。

14. **params**: 允许方法接受可变数量的参数，参数类型在声明时使用数组表示。

15. **foreach**: 用于遍历集合类型的数据，例如数组或集合。

16. **if**, **else**: 用于条件控制，根据条件执行不同的代码块。

17. **switch**, **case**: 用于多分支选择，根据不同的值执行不同的代码块。

18. **try**, **catch**, **finally**: 用于异常处理，try块中包含可能引发异常的代码，catch块用于捕获并处理异常，finally块中的代码无论是否发生异常都会被执行。

19. **while**, **do-while**: 用于循环执行一段代码，while在执行前判断条件，do-while在执行后判断条件。

20. **for**: 用于循环执行一段代码，通常用于遍历数组或执行指定次数的循环。

这些是C#中一些常用的关键字及其含义。使用这些关键字可以帮助你在编写C#程序时控制程序的逻辑和行为。

以下是一些关键字的用法 ：

public

public class MyClass
{
    public int MyPublicVariable; // 公开的成员变量
    public void MyPublicMethod() // 公开的方法
    {
        // 方法实现
    }
}

private

public class MyClass
{
    private int MyPrivateVariable; // 私有的成员变量
    private void MyPrivateMethod() // 私有的方法
    {
        // 方法实现
    }
}

protected

public class MyBaseClass
{
    protected int MyProtectedVariable; // 受保护的成员变量
    protected void MyProtectedMethod() // 受保护的方法
    {
        // 方法实现
    }
}

public class MyDerivedClass : MyBaseClass
{
    public void AccessProtectedMembers()
    {
        MyProtectedVariable = 10; // 可以在派生类中访问基类的受保护成员
        MyProtectedMethod(); // 可以在派生类中调用基类的受保护方法
    }
}

1. static:

public class MyClass
{
    public static int MyStaticVariable; // 静态成员变量
    public static void MyStaticMethod() // 静态方法
    {
        // 方法实现
    }
}

// 访问静态成员和方法时不需要实例化对象
MyClass.MyStaticVariable = 5;
MyClass.MyStaticMethod();

const:

public class MyClass
{
    public const int MyConstantValue = 100; // 常量
}

// 访问常量值
int value = MyClass.MyConstantValue;

readonly:

public class MyClass
{
    public readonly int MyReadOnlyVariable; // 只读字段

    public MyClass(int value)
    {
        MyReadOnlyVariable = value; // 只能在构造函数中初始化只读字段
    }
}

new:

public class MyBaseClass
{
    public void MyMethod()
    {
        Console.WriteLine("Base class method");
    }
}

public class MyDerivedClass : MyBaseClass
{
    public new void MyMethod()
    {
        Console.WriteLine("Derived class method");
    }
}

MyDerivedClass obj = new MyDerivedClass();
obj.MyMethod(); // 输出 "Derived class method"
((MyBaseClass)obj).MyMethod(); // 输出 "Base class method"，使用强制类型转换可以调用基类方法

abstract:

public abstract class Shape
{
    public abstract void Draw(); // 抽象方法，没有具体实现
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

Shape shape = new Circle();
shape.Draw(); // 输出 "Drawing a circle"

override and virtual:

public class MyBaseClass
{
    public virtual void MyMethod()
    {
        Console.WriteLine("Base class method");
    }
}

public class MyDerivedClass : MyBaseClass
{
    public override void MyMethod()
    {
        Console.WriteLine("Derived class method");
    }
}

MyDerivedClass obj = new MyDerivedClass();
obj.MyMethod(); // 输出 "Derived class method"，重写了基类方法

MyBaseClass obj2 = new MyDerivedClass();
obj2.MyMethod(); // 输出 "Derived class method"，通过基类引用调用派生类方法