学习c#的第七天

[C# 封装](# 封装)

概念

[Public 访问修饰符](#Public 访问修饰符)

[Private 访问修饰符](#Private 访问修饰符)

[Protected 访问修饰符](#Protected 访问修饰符)

[Internal 访问修饰符](#Internal 访问修饰符)

[Protected Internal 访问修饰符](#Protected Internal 访问修饰符)

总结

C# 封装

概念

在面向对象程序设计中，封装是一种将数据和方法包含在一个单元中，并控制对这些数据和方法访问的机制。通过使用访问修饰符，可以根据需要设置成员的访问权限，以实现封装的特性。

C#中的访问修饰符确实具有如下所示的各种级别和可见性：

public：该成员对所有对象都是可见的，可以被任何类访问。
private：该成员只能在定义它的类的内部访问，其他类无法直接访问。
protected：该成员对该类对象及其子类对象可见，但对于其他类是不可见的。
internal：该成员对同一个程序集的对象可见，但对于其他程序集的对象是不可见的。
protected internal：该成员对当前程序集或派生自包含类的类型可见。

通过合理地使用这些访问修饰符，可以控制对类的成员的访问权限，从而实现所需的封装级别。这种限制访问权限的方式有助于保护类的内部细节，并使得类的使用更加安全和可靠。

总的来说，封装和访问修饰符是面向对象编程中非常重要的概念，它们提供了一种有效管理代码访问权限的机制，有助于实现代码的安全性、可维护性和可扩展性。

Public 访问修饰符

在C#中，public访问修饰符是用于声明类成员的一种修饰符，它表示该成员对所有对象都是可见的，可以被任何类访问。具体来说，使用public访问修饰符可以使得该成员对外部代码公开，从而可以在任何地方访问和使用它。

当一个类的成员被声明为public时，这意味着其他类可以通过该成员进行直接的访问和操作，而不需要通过特定的访问方法。这种公开的访问权限可以方便其他类与该类进行交互，同时也需要我们在设计和使用时考虑到公开成员可能带来的影响。

以下是使用public访问修饰符的示例：

cs 复制代码

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        public double length;
        public double width;

        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }

    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

cs 复制代码

长度： 4.5
宽度： 3.5
面积： 15.75

它定义了一个名为Rectangle的类和一个名为ExecuteRectangle的类，并在ExecuteRectangle类中包含了Main方法作为程序的入口点。这个Main方法创建了一个Rectangle对象实例，并设置了其长度和宽度，然后调用Display方法展示了该矩形的属性和面积。

Private 访问修饰符

在C#中，private访问修饰符确实用于将类的成员（字段、属性、方法等）隐藏起来，使它们只能被同一个类中的其他成员访问，而无法被类的实例或其他类访问。

这种封装性质的特性允许类在内部维护其状态并确保其行为的一致性，同时对外部代码隐藏其实现细节。这有助于避免外部代码直接修改类的内部状态，从而提高了代码的安全性和可维护性。

下面是一个使用private访问修饰符的简单示例：

cs 复制代码

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        private double length;  // 私有成员变量
        private double width;   // 私有成员变量

        public void SetDimensions(double len, double wid)  // 公有方法可以访问私有成员
        {
            if (len > 0 && wid > 0)
            {
                length = len;  // 在类的内部可以访问私有成员
                width = wid;   // 在类的内部可以访问私有成员
            }
            else
            {
                Console.WriteLine("无效的长度和宽度");
            }
        }

        public double GetArea()  // 公有方法可以访问私有成员
        {
            return length * width;  // 在类的内部可以访问私有成员
        }
    }

    class Program
    {
        static void Main()
        {
            Rectangle rect = new Rectangle();
            rect.SetDimensions(5, 3);
            Console.WriteLine("矩形的面积: " + rect.GetArea());
        }
    }
}

在这个示例中，length和width被声明为private，因此它们只能在Rectangle类的内部访问。通过SetDimensions方法，我们可以在类的内部设置这些私有成员的值，并通过GetArea方法获取它们的乘积。外部代码无法直接访问或修改length和width，从而保证了这些私有成员的安全性和封装性。

Protected 访问修饰符

在 C# 中，protected 访问修饰符用于限制成员的访问性，使它们只能在定义了该成员的类或派生类中进行访问。

具体来说，使用 protected 修饰的成员可以在定义它的类内部以及派生类内部进行访问，但不能在类的外部直接访问。这种访问修饰符通常用于实现封装和继承，允许派生类访问基类的成员而不暴露其细节给外部。这有助于构建更为灵活和可维护的代码结构。

例如，在 Rectangle 类中，如果希望某些成员只能被派生类访问，可以将它们声明为 protected，如下所示：

cs 复制代码

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        protected double length;  // 受保护的成员变量
        protected double width;   // 受保护的成员变量  

        public void SetDimensions(double len, double wid)  // 公有方法可以访问私有成员
        {
            if (len > 0 && wid > 0)
            {
                length = len;  // 在类的内部可以访问私有成员
                width = wid;   // 在类的内部可以访问私有成员
            }
            else
            {
                Console.WriteLine("无效的长度和宽度");
            }
        }

        public double GetArea()  // 公有方法可以访问私有成员
        {
            return length * width;  // 在类的内部可以访问私有成员
        }
    }

    class Program
    {
        static void Main()
        {
            Rectangle rect = new Rectangle();
            rect.SetDimensions(5, 3);
            Console.WriteLine("矩形的面积: " + rect.GetArea());
        }
    }
}

在上面的代码中，length 和 width 成员被声明为 protected，这意味着它们可以在 Rectangle 类内部以及任何从 Rectangle 派生出来的类内部进行访问，但在类的外部是不可见的。

Internal 访问修饰符

在 C# 中，internal 访问修饰符用于限制类型和成员只能在同一程序集内部进行访问。换句话说，具有 internal 访问修饰符的类型或成员可以被同一程序集中的其他类访问，但无法被其他程序集中的类访问。

请注意成员函数声明的时候不带有任何访问修饰符。如果没有指定访问修饰符，则使用类成员的默认访问修饰符，即为 private。

以下是一个简单的示例代码，演示了如何在C#中使用 internal 访问修饰符：

cs 复制代码

using System;

namespace MyNamespace
{
    // 定义一个类
    class MyClass
    {
        // internal 访问修饰符将这些成员变量暴露给相同程序集内的其他类
        internal int internalVar;
        internal void InternalMethod()
        {
            Console.WriteLine("这是一种内部方法。");
        }
    }

    // 在同一程序集中的另一个类中访问 internal 成员
    class AnotherClass
    {
        static void Main(string[] args)
        {
            MyClass myObject = new MyClass();
            myObject.internalVar = 10;  // 可以访问 internal 成员变量
            myObject.InternalMethod();  // 可以调用 internal 方法
        }
    }
}

在这个示例中，我们定义了一个名为 MyClass 的类，其中包含一个 internal 成员变量 internalVar 和一个 internal 方法 InternalMethod。然后，在同一程序集中的另一个类 AnotherClass 中，我们创建了 MyClass 的实例并访问了它的 internal 成员。

Protected Internal 访问修饰符

在 C# 中，protected internal 访问修饰符表示成员对定义它们的类、派生类和同一程序集中的其他类都可见。换句话说，这种修饰符结合了 protected 和 internal 的特性，允许派生类以及同一程序集内的其他类都能访问该成员。

下面是一个简单的示例代码，演示了如何在 C# 中使用 protected internal 访问修饰符：

cs 复制代码

using System;

namespace MyNamespace
{
    // 定义一个基类
    class MyBaseClass
    {
        // protected internal 访问修饰符将这些成员变量暴露给派生类和相同程序集内的其他类
        protected internal int protectedInternalVar;

        protected internal void ProtectedInternalMethod()
        {
            Console.WriteLine("这是一个受保护的内部方法。");
        }
    }

    // 定义一个派生类
    class MyDerivedClass : MyBaseClass
    {
        static void Main(string[] args)
        {
            MyDerivedClass myObject = new MyDerivedClass();
            myObject.protectedInternalVar = 10;  // 可以访问 protected internal 成员变量
            myObject.ProtectedInternalMethod();  // 可以调用 protected internal 方法
        }
    }

}

总结

举个例子，一个人A为父类，他的儿子B，妻子C，私生子D（注：D不在他家里）

public 事件：所有人都知道，就像公开的信息一样，任何人都可以访问。
protected 事件：A，B和D知道，但妻子C不知道。这里假设B是A的儿子，D是A的私生子，因此他们可以知道这些信息。而妻子C不知道，因为她并不是A的子类。
private 事件：只有A知道，这意味着这些事件只能被A访问，对于其他家庭成员来说是私密的。
internal 事件：A，B，C都知道，因为这些事件对A家里的所有人都可见，但是私生子D不知道，因为他不在A的家庭内。
protected internal 事件：A，B，C，D都知道，因为这些事件对A家庭内的所有人都可见，包括A的私生子D。

关于范围比较：

private 的范围最小，只能在类的内部访问。
internal 和 protected 的范围相当，但是 protected 对派生类也可见，而 internal 只对同一程序集内的类可见。
protected internal 的范围介于 protected 和 internal 之间，同时对派生类和同一程序集内的其他类可见。
public 的范围最大，所有地方都可以访问。