C#面向对象编程-类和对象（类的封装）

类的封装

封装是实现面向对象程序设计的第一步，封装就是将数据或方法等集合在一个个的单元中。被封装的对象通常被称为抽象数据类型。抽象和封装都是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。C#封装根据具体的需要，设置使用者的访问权限，并通过访问修饰符来实现。一个访问修饰符定义了一个类成员的范围和可见性。

public公开的

public允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员都可以被外部的类访问。
编写程序，访问类中的公有成员。

using System;
namespace Project6
{
    class myClass
    {
        // 公有成员
        public int length;
        public int width;
        public int getArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", getArea());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass r = new myClass();
            r.length = 6;
            r.width = 3;
            r.Display();
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示公有成员的访问。在代码中，成员变量length和width被声明为public，所以它们可以被Main方法使用myClass类的实例r访问。方法Display和GetArea可以直接访问这些变量。而方法Display也被声明为public，所以它也能被Main方法使用myClass类的实例r访问。

长度： 6
宽度： 3
面积： 18

private私有的

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

using System;
namespace Project7
{
    class myClass
    {
        private int length;
        private int width;
        public void Import()
        {
            Console.WriteLine("请输入长度：");
            length = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("请输入宽度：");
            width = Convert.ToInt32(Console.ReadLine());
        }
        public int getArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", getArea());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass r = new myClass();
            r.Import();         
            r.Display();
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示私有成员的访问。在代码中，成员变量length和width被声明为private，所以它们不能被Main方法访问。成员函数Import和Display可以访问这些变量。由于成员函数Import和Display被声明为public，所以它们可以被Main()使用myClass类的实例r访问。

请输入长度：
5
请输入宽度：
8
长度： 5
宽度： 8
面积： 40

protected受保护的

protected访问修饰符允许派生类访问它的基类的成员变量和成员函数。这样有助于实现继承。
编写程序，通过派生类访问基类的受保护成员。

using System;
namespace Project8
{
    class Point
    {
        protected int x;
        protected int y;
    }
    class Program:Point
    {
        static void Main(string[] args)
        {
            Program dpoint = new Program();          
            // 直接访问受保护的成员
            dpoint.x = 10;
            dpoint.y = 15;
            Console.WriteLine("x = {0}, y = {1}", dpoint.x, dpoint.y);
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示受保护成员的访问。在代码中，Program类是从Point派生的。因此，可以从派生类直接访问基类的受保护成员。如果想要通过Point类的实例化来访问成员变量x与y，编译器也是不允许的。

x = 10, y = 15

internal内部访问

internal的英文含义是“内部的”，而这个“内部的”的确切含义，是指“同一程序集”的内部，而非“同一命名空间”的内部。也就是说，internal修饰的方法或者属性，只要是在同一个程序集中的类都可以访问，如果二者不在同一命名空间，只要使用using引用上相应的命名空间即可。
编写程序，将类中的成员用internal关键字修饰。

using System;
namespace Project9
{
    class myClass
    {
        internal int length;
        internal int width;
        int getArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {0}", getArea());
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass r = new myClass();
            r.length = 15;
            r.width = 8;
            r.Display();
            Console.ReadKey();
        }
    }
}

【程序分析】本例演示了内部成员的访问。在代码中，需要注意成员函数getArea声明的时候不带有任何访问修饰符。如果没有指定访问修饰符，则使用类成员的默认访问修饰符，即为private。

长度： 15
宽度： 8
面积： 120

封装的意义在于保护或者防止代码（数据）被用户无意中破坏，防止对实现细节的访问。用户只提供调用类的方法，而调用者不必了解类内部怎样处理相关数据。