天天看点
返回

3.5 C#的封装和访问修饰符

C#的封装和访问修饰符

封装是面向对象编程的一个重要特性，它可以隐藏类的内部实现细节，只暴露必要的接口给外部使用者。封装可以保护类的数据不被随意修改，提高类的可维护性和安全性。

在C#中，封装是通过使用访问修饰符来实现的。访问修饰符可以指定类、属性、方法、字段等成员的可见性和访问权限。C#支持以下五种访问修饰符：

  • public：表示成员可以被任何对象访问，没有任何限制。
  • private：表示成员只能被同一个类中的其他成员访问，对外部不可见。
  • protected：表示成员只能被同一个类或者其派生类中的其他成员访问，对外部不可见。
  • internal：表示成员只能被同一个程序集中的其他对象访问，对其他程序集不可见。
  • protected internal：表示成员可以被同一个程序集中的任何对象访问，或者被其他程序集中派生自该类的对象访问。

如果没有指定访问修饰符，则默认使用类成员的默认访问修饰符，即为private。

下面我们用一些代码示例来说明不同访问修饰符的用法和效果。

public 访问修饰符

public 访问修饰符表示成员可以被任何对象访问，没有任何限制。例如，我们定义一个公共的Person类，它有一个公共的属性Name和一个公共的方法SayHello：

// 定义一个公共的Person类
public class Person
{
    // 定义一个公共的属性Name
    public string Name { get; set; }

    // 定义一个公共的方法SayHello
    public void SayHello()
    {
        Console.WriteLine("Hello, I am " + Name);
    }
}

然后我们在另一个类中创建Person类的对象，并访问其属性和方法：

// 在另一个类中创建Person类的对象
Person p = new Person();
// 访问其属性Name，并赋值
p.Name = "Alice";
// 访问其方法SayHello，并调用
p.SayHello();

输出结果为：

Hello, I am Alice

可以看到，我们可以在任何地方访问Person类及其成员，因为它们都是公共的。

private 访问修饰符

private 访问修饰符表示成员只能被同一个类中的其他成员访问，对外部不可见。例如，我们定义一个私有的字段_age来存储Person类对象的年龄，并提供一个公共的属性Age来获取或设置该字段：

// 定义一个私有的字段_age
private int _age;

// 定义一个公共的属性Age
public int Age 
{
    // get访问器用于获取_age字段的值
    get 
    {
        return _age;
    }
    // set访问器用于设置_age字段的值，并进行验证
    set 
    {
        // 如果value参数小于0或大于120，则抛出异常
        if (value < 0 || value > 120)
        {
            throw new ArgumentException("Invalid age");
        }
        // 否则将value参数赋值给_age字段
        _age = value;
    }
}

上面的示例中，我们可以通过Age属性来访问或修改_age字段，但是我们不能直接访问或修改_age字段，因为它是私有的。这样可以保证_age字段的值始终在合理的范围内，不会被随意修改。

protected 访问修饰符

protected 访问修饰符表示成员只能被同一个类或者其派生类中的其他成员访问，对外部不可见。这样有助于实现继承，我们将在后面的章节详细讨论这个。

例如，我们定义一个基类Animal，它有一个受保护的属性Name和一个受保护的方法Eat：

// 定义一个基类Animal
public class Animal
{
    // 定义一个受保护的属性Name
    protected string Name { get; set; }

    // 定义一个受保护的方法Eat
    protected void Eat()
    {
        Console.WriteLine(Name + " is eating");
    }
}

然后我们定义一个派生类Dog，它继承自Animal类，并重写了Name属性和Eat方法：

// 定义一个派生类Dog，继承自Animal类
public class Dog : Animal
{
    // 重写Name属性，添加了set访问器
    public override string Name 
    {
        get => base.Name;
        set => base.Name = value;
    }

    // 重写Eat方法，添加了自己的逻辑
    public override void Eat()
    {
        // 调用基类的Eat方法
        base.Eat();
        // 添加自己的逻辑
        Console.WriteLine(Name + " likes bones");
    }
}

然后我们在另一个类中创建Dog类的对象，并访问其Name属性和Eat方法：

// 在另一个类中创建Dog类的对象
Dog d = new Dog();
// 访问其Name属性，并赋值
d.Name = "Bob";
// 访问其Eat方法，并调用
d.Eat();

输出结果为：

Bob is eating
Bob likes bones

可以看到，我们可以在派生类中访问基类的受保护成员，并对其进行重写或扩展。但是我们不能在其他类中直接访问基类的受保护成员，因为它们对外部不可见。

internal 访问修饰符

internal 访问修饰符表示成员只能被同一个程序集中的其他对象访问，对其他程序集不可见。程序集是一个可执行的单元，通常是一个.dll或.exe文件。

例如，我们定义一个类Library，它有一个内部的属性Name和一个内部的方法Borrow：

// 定义一个类Library
public class Library
{
    // 定义一个内部的属性Name
    internal string Name { get; set; }

    // 定义一个内部的方法Borrow
    internal void Borrow()
    {
        Console.WriteLine("You have borrowed a book from " + Name);
    }
}

然后我们在同一个程序集中的另一个类中创建Library类的对象，并访问其属性和方法：

// 在同一个程序集中的另一个类中创建Library类的对象
Library l = new Library();
// 访问其属性Name，并赋值
l.Name = "CSDN Library";
// 访问其方法Borrow，并调用
l.Borrow();

输出结果为：

You have borrowed a book from CSDN Library

可以看到，我们可以在同一个程序集中访问Library类及其成员，因为它们都是内部的。

但是如果我们在另一个程序集中尝试访问Library类及其成员，就会出现编译错误，因为它们对其他程序集不可见。

protected internal 访问修饰符

protected internal 访问修饰符表示成员可以被同一个程序集中的任何对象访问，或者被其他程序集中派生自该类的对象访问。这是一个比较灵活的访问修饰符，它结合了protected和internal的特点。

例如，我们定义一个类Book，它有一个受保护内部的属性Title和一个受保护内部的方法Read：

// 定义一个类Book
public class Book
{
    // 定义一个受保护内部的属性Title
    protected internal string Title { get; set; }

    // 定义一个受保护内部的方法Read
    protected internal void Read()
    {
        Console.WriteLine("You are reading " + Title);
    }
}

然后我们在同一个程序集中的另一个类中创建Book类的对象，并访问其属性和方法：

// 在同一个程序集中的另一个类中创建Book类的对象
Book b = new Book();
// 访问其属性Title，并赋值
b.Title = "C# Tutorial";
// 访问其方法Read，并调用
b.Read();

输出结果为：

You are reading C# Tutorial

可以看到，我们可以在同一个程序集中访问Book类及其成员，因为它们都是受保护内部的。

然后我们在另一个程序集中定义一个派生类Novel，它继承自Book类，并重写了Title属性和Read方法：

// 在另一个程序集中定义一个派生类Novel，继承自Book类
public class Novel : Book
{
    // 重写Title属性，添加了set访问器
    public override string Title 
    {
        get => base.Title;
        set => base.Title = value;
    }

    // 重写Read方法，添加了自己的逻辑
    public override void Read()
    {
        // 调用基类的Read方法
        base.Read();
        // 添加自己的逻辑
        Console.WriteLine("You are enjoying the story of " + Title);
    }
}

然后我们在同一个程序集中的另一个类中创建Novel类的对象，并访问其属性和方法：

// 在同一个程序集中的另一个类中创建Novel类的对象
Novel n = new Novel();
// 访问其属性Title，并赋值
n.Title = "The Three-Body Problem";
// 访问其方法Read，并调用
n.Read();

输出结果为：

You are reading The Three-Body Problem
You are enjoying the story of The Three-Body Problem

可以看到，我们可以在其他程序集中访问Book类及其成员，因为我们是通过派生自该类的对象来访问的。

但是如果我们在其他程序集中直接创建Book类的对象，并尝试访问其属性和方法，就会出现编译错误，因为它们对其他程序集中非派生类的对象不可见。

总结

本文介绍了C#的封装和访问修饰符的概念和用法，通过一些代码示例展示了不同访问修饰符的效果和区别。我们学习了以下五种访问修饰符：

  • public：表示成员可以被任何对象访问，没有任何限制。
  • private：表示成员只能被同一个类中的其他成员访问，对外部不可见。
  • protected：表示成员只能被同一个类或者其派生类中的其他成员访问，对外部不可见。
  • internal：表示成员只能被同一个程序集中的其他对象访问，对其他程序集不可见。
  • protected internal：表示成员可以被同一个程序集中的任何对象访问，或者被其他程序集中派生自该类的对象访问。

封装和访问修饰符是面向对象编程的基础知识，掌握它们可以帮助我们设计出更合理、更安全、更易维护的类和对象。希望本文对你有所帮助，谢谢阅读！

访问修饰符
上一篇: 3.6 C#的多重继承和接口实现
下一篇: java 应用题_java编程应用题！！！

继续阅读