C# 封装

2022-03-20 07:15:34

# 封装

封装被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。

Public 访问修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问

class Obj
        {
            public string name = "obj";
            public void setName(string n)
            {
                this.name = n;
            }
            public string getName()
            {
                return name;
            }
        }

//public method
            Obj obj = new Obj();
            obj.name = "233";//等效于obj.setName("233");
            Console.WriteLine(obj.name);//obj.name 等效于obj.getName()
            obj.setName("name");
            Console.WriteLine(obj.getName());
//↓输出结果

233
name

在上面的实例中，成员变量 name 被声明为 public，所以它们可以被函数使用 Obj 类的实例 obj 访问。

成员函数 getName()和setName() 可以直接访问这些变量。

成员函数 getName()和setName() 也被声明为 public，所以它也能被使用 Obj 类的实例 obj 访问。

Private 访问修饰符

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

class SingleTon
        {
            private static SingleTon instance = null;
            private static String val = null;
            private SingleTon() { }
            public static SingleTon newInstance()
            {
                if (instance == null)
                {
                    instance = new SingleTon();
                }
                return instance;
            }
            public void set(String s)
            {
                setVal(s);
            }
            public String get()
            {
                return getVal();
            }
            private  void setVal(String v)
            {
                if (instance == null)
                {
                    return;
                }
                val = v;
            }
            private  string getVal()
            {
                if (instance == null)
                {
                    return null;
                }
                return val;
            }
        }

//private
            SingleTon instance = SingleTon.newInstance();
            instance.set("233");
            Console.WriteLine(instance.get());

在上面的实例中，成员变量 val 被声明为 private，所以它们不能被函数访问。

成员函数 set() ,get(),setVal(),getVal() 可以访问这些变量。

但,setVal(),getVal() 被声明为private 所以它们无法通过外部引用

由于成员函数 set() 和 get() 被声明为 public，所以它们可以被使用SingleTon类的实例 instance访问。

Protected 访问修饰符

Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。

Internal 访问修饰符

Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。

下面的实例说明了这点：

实例

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        internal double length;
        internal double width;
       
        double GetArea()
        {
            return length * width;
        }
       public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }//end class Rectangle    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.length = 4.5;
            r.width = 3.5;
            r.Display();
            Console.ReadLine();
        }
    }
}

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

Protected Internal 访问修饰符

Protected Internal 访问修饰符允许在本类,派生类或者包含该类的程序集中访问。这也被用于实现继承。