本文转自：https://www.cnblogs.com/yubinfeng/p/4553505.html
我们的课题是面向对象编程，前面主要介绍了面向对象的基础知识，而从这里开始才是面向对象的核心部分，即
面向对象的三大特性：封装、继承、多态。
1.封装概念
封装：每个对象都包含有它能进行操作的所有信息，这个特性称为封装。这样的方法包含在类中，通过类的实例来实现。
2.封装的优点
A.良好的封装能够减少耦合（比如实现界面和逻辑分离）
B.可以让类对外接口不变，内部可以实现自由的修改
C.类具有清晰的对外接口，使用者只需调用，无需关心内部
D.因为封装的类功能相对独立，因此能更好的实现代码复用
E.可保护代码不被无意中破坏，通过私有字段等实现内部。注意：这里的代码保护不是指代码本身的加密，而是对不想外部更改的代码通过私有实现。
为了更好的理解封装的我们举几个实际例子
实例一：有一个漂亮的房子(House类)，房子里有：床(Bed属性)、沙发（Sofa属性）、书桌(Desk属性)、钱柜(Box属性)，还有门(Door属性)、窗子(Window属性)，我们可以用一个类及他的属性成员来表示这个房子这个对象，在定义之前，我们可以考虑，像钱柜、床这类个人隐私的东西，不能随便让路过的人看到，那就就是私有的。也不能把窗子也封闭起来不接受阳光，那么窗子就是一个公有属性。而门在离开家的时候需要锁上，回到家需要打开，这就是一个对外的方法，当然开锁是需要有定的条件，比如有钥匙等。通过以上的描述，我们来用代码实现这个封装
1 /// <summary>
2 /// 房子类
3 /// </summary>
4 class House
5 {
6 object _bed;
7 object _sofa;
8 object _desk;
9 object _box;
10 object _door;
11 object _window;
12
13 /// <summary>
14 /// 床 默认私有成员
15 /// </summary>
16 object Bed
17 {
18 get { return _bed; }
19 set { _bed = value; }
20 }
21 /// <summary>
22 /// 沙发(私有)
23 /// </summary>
24 object Sofa
25 {
26 get { return _sofa; }
27 set { _sofa = value; }
28 }
29 /// <summary>
30 /// 书桌(私有)
31 /// </summary>
32 object Desk
33 {
34 get { return _desk; }
35 set { _desk = value; }
36 }
37 /// <summary>
38 /// 钱柜(私有)
39 /// </summary>
40 object Box
41 {
42 get { return _box; }
43 set { _box = value; }
44 }
45
46 /// <summary>
47 /// 门(公有)
48 /// </summary>
49 public object Door
50 {
51 get { return _door; }
52 set { _door = value; }
53 }
54
55 /// <summary>
56 /// 窗子(公有)
57 /// </summary>
58 public object Window
59 {
60 get { return _window; }
61 set { _window = value; }
62 }
63 }
实例二：我们单位养了一只价值800块钱，黄色的的牧羊犬，有陌生人来的时候，就会叫几声，当然越是陌生程度越高，叫的次数越多。对这样一个事务的处理上，可以利用面向对象的封装特性,代码实现如下：
1 /// <summary>
2 /// 狗狗类
3 /// </summary>
4 class Dog
5 {
6 string _dogName;
7 readonly Color _dogColor=Color.Yellow;
8 readonly double _dogPrice = 800.00;
9 int _shoutNumber;
10
11 /// <summary>
12 /// 构造函数
13 /// </summary>
14 /// <param name="dogName"></param>
15 public Dog(string dogName)
16 {
17 DogName = dogName;
18 }
19
20 /// <summary>
21 /// 狗狗名字 公有属性
22 /// </summary>
23 public string DogName
24 {
25 get { return _dogName; }
26 set { _dogName = value; }
27 }
28 /// <summary>
29 /// 狗狗颜色 只读属性 (颜色一出生就是这个颜色，这里只提供只读，当然这里不考虑染色)
30 /// </summary>
31 public Color DogColor
32 {
33 get { return _dogColor;}
34 }
35 /// <summary>
36 /// 狗狗价格 只读属性 （这是买来的价格，历史是不可以修改的）
37 /// </summary>
38 public double DogPrice
39 {
40 get { return _dogPrice; }
41 }
42
43 /// <summary>
44 /// 狗叫的次数 （不同的陌生人来，叫的次数不同）
45 /// </summary>
46 public int ShoutNumber{
47 set{_shoutNumber=value;}
48 get { return _shoutNumber; }
49 }
50
51 /// <summary>
52 /// 狗叫的方法
53 /// </summary>
54 public void Shout()
55 {
56 int i=0;
57 string ShoutNum="";
58 do
59 {
60 ShoutNum += "旺！";
61 i++;
62 } while (i <= ShoutNumber);
63 MessageBox.Show(ShoutNum);
64 }
65 }
上面的Dog类就是对狗狗的全部信息，包括它的价格，颜色，叫声，名字等封装成一个类，以方便外部调用。对狗狗的价格和颜色使用了只读属性，因为它买来的历史价格和颜色是不可以更改的（染毛暂不考虑）。通过封装的思想我们可以增加狗狗体重等其它公有属性，而不会影响到外部接口的调用，对私有的只读属性做到了保护。
相信通过这两个实例，我们已经完全对封装熟悉了。假如我们的狗狗又生了一个宝宝，他的很多特征都基本相同，我们是不是又要复制一次这个类呢？这就要用到面向对象的另一个重要特性——继承，下面我们会慢慢介绍。
国际惯例，我们归纳一下封装的要点
要点：
1.封装，就是把一个对象所能操作的所有信息放在一起
2.封装能减少耦合，保持统一的对外接口，内部修改不影响外部调用