C#类访问修饰符

1. public 修饰符

public 类能被任何代码访问，不受访问限制。

// 定义一个 public 类
public class PublicClass
{
    public void ShowMessage()
    {
        Console.WriteLine("这是一个 public 类的方法。");
    }
}

class Program
{
    static void Main()
    {
        PublicClass publicObj = new PublicClass();
        publicObj.ShowMessage();
    }
}

在这个例子里，PublicClass 被 public 修饰，Main 方法能够创建它的实例并调用其方法。

 

2. private 修饰符

private 类仅在包含它的类型内可访问，一般用于嵌套类。

class OuterClass
{
    // 定义一个 private 嵌套类
    private class PrivateNestedClass
    {
        public void Display()
        {
            Console.WriteLine("这是一个 private 嵌套类的方法。");
        }
    }

    public void UsePrivateClass()
    {
        PrivateNestedClass privateObj = new PrivateNestedClass();
        privateObj.Display();
    }
}

class Program
{
    static void Main()
    {
        OuterClass outer = new OuterClass();
        outer.UsePrivateClass();
    }
}

这里的 PrivateNestedClass 是 OuterClass 的私有嵌套类，只有 OuterClass 内部的代码可以访问它。

 

3. internal 修饰符

internal 类只能在同一程序集内被访问。

// 定义一个 internal 类
internal class InternalClass
{
    public void PrintInfo()
    {
        Console.WriteLine("这是一个 internal 类的方法。");
    }
}

class Program
{
    static void Main()
    {
        InternalClass internalObj = new InternalClass();
        internalObj.PrintInfo();
    }
}

InternalClass 被 internal 修饰，在同一程序集内的 Main 方法能够创建其实例并调用方法。

 

4. protected 修饰符

protected 修饰符一般用于类的成员，而不是直接修饰类，但可以用于嵌套类，使嵌套类能在其外部类和派生类中被访问。

class BaseClass
{
    // 定义一个 protected 嵌套类
    protected class ProtectedNestedClass
    {
        public void Print()
        {
            Console.WriteLine("这是一个 protected 嵌套类的方法。");
        }
    }

    public void UseProtectedClass()
    {
        ProtectedNestedClass protectedObj = new ProtectedNestedClass();
        protectedObj.Print();
    }
}

class DerivedClass : BaseClass
{
    public void AccessProtectedClass()
    {
        ProtectedNestedClass protectedObj = new ProtectedNestedClass();
        protectedObj.Print();
    }
}

class Program
{
    static void Main()
    {
        DerivedClass derived = new DerivedClass();
        derived.AccessProtectedClass();
    }
}

在这个例子中，ProtectedNestedClass 是 BaseClass 的受保护嵌套类，BaseClass 及其派生类 DerivedClass 都可以访问它。

 

5. abstract 修饰符

abstract 类不能被实例化，只能作为基类，且可以包含抽象成员。

// 定义一个抽象类
abstract class Shape
{
    // 定义抽象方法
    public abstract double Area();

    public void PrintArea()
    {
        Console.WriteLine("面积是: " + Area());
    }
}

// 继承抽象类并实现抽象方法
class Circle : Shape
{
    private double radius;

    public Circle(double r)
    {
        radius = r;
    }

    public override double Area()
    {
        return Math.PI * radius * radius;
    }
}

class Program
{
    static void Main()
    {
        Circle circle = new Circle(5);
        circle.PrintArea();
    }
}

Shape 是抽象类，Area 是抽象方法，Circle 类继承自 Shape 并实现了 Area 方法。

 

6. sealed 修饰符

sealed 类不能被继承。

// 定义一个 sealed 类
sealed class SealedClass
{
    public void Show()
    {
        Console.WriteLine("这是一个 sealed 类的方法。");
    }
}

// 以下代码会报错，因为不能继承 sealed 类
// class DerivedFromSealed : SealedClass { }

class Program
{
    static void Main()
    {
        SealedClass sealedObj = new SealedClass();
        sealedObj.Show();
    }
}

SealedClass 被 sealed 修饰，不能有派生类。

 

7. partial 修饰符

partial 类允许将类的定义分散在多个文件中。
文件 1：PartialClassPart1.cs

// 定义 partial 类的一部分
partial class PartialClass
{
    public void Method1()
    {
        Console.WriteLine("这是 partial 类的方法 1。");
    }
}

 

文件 2：PartialClassPart2.cs

// 定义 partial 类的另一部分
partial class PartialClass
{
    public void Method2()
    {
        Console.WriteLine("这是 partial 类的方法 2。");
    }
}

class Program
{
    static void Main()
    {
        PartialClass partialObj = new PartialClass();
        partialObj.Method1();
        partialObj.Method2();
    }
}

PartialClass 的定义分布在两个文件中，编译时会合并成一个完整的类。