面向对象开发有三大特性（特点 / 特征） ： 封装， 继承， 多态。我们今天主要讨论封装和继承，多态会在下篇中讨论。

一、封装：

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

1.1、封装五种访问修饰符

A.public [公开访问]

公开的访问权限。

当前类， 子类， 实例对象， 都可以访问到。

B.private [私有访问]

私有的访问权限。

只能在当前类内部进行访问使用； 子类， 实例对象， 都访问不到。

C.protected [保护访问]

受保护的访问权限。

只能在当前类的内部，以及该类的子类中访问；实例对象访问不到。

也就是说受保护的，不让外部的实例去访问和改变。

D.internal [内部访问]

只能在当前程序集(项目)中访问；

(程序集可以理解为一个项目，一个项目也就是一个程序集。从设计的角度来说，也可以看成是一个完整的模块（Module），或者称为是包（Package）。因此，一个程序集也可以体现为一个dll文件，或者exe文件。一个解决方案下可以用很多项目，项目名和命名空间名可以分别设置，但默认情况下是一致的，而对应到项目的具体文件夹就是“项目的命名空间.文件夹名

在同一个项目中 internal 和 public 的访问权限是一样的。

一个解决方案里面，可以有多个项目！

E.protected internal [内部保护访问]

protected + internal 的访问权限。

用的不多，我是没用过的。

1.2、使用场合

A.修饰类

能够修饰类的访问修饰符只有两个， public 和 internal；

类的默认访问修饰符是 internal。默认类就是那种前面没有修饰符的class

B.修饰类成员

五种访问修饰符都可以修饰类中的成员；

类中的成员默认访问修饰符是 private。

C.类视图

当前项目上右键-->视图-->查看类图

可以看到类的继承关系图， 以及类中的成员概况。

各位留意一下字段，属性，方法各自特有的图标。

字段是小砖块，还上锁了。属性是小扳手。方法是空的小盒子。

下面是类视图。 

二、继承：

　　将一堆类中的一些共有的“成员”单独抽取出来，作为一个父类，然后这一堆类继承这个父类，共享父类的资源， 这就叫做继承。

　　以为人为例，我们每个人都会有一些共同的特征，都要做一些相同的事情。比如：人都有一个脑袋，二只胳膊，二条脚，这是共同的特征。都要吃饭，喝水，这是都要做的相同的事情。那么如果我们现在要声明很多个人，每个人都会有这些特征，那我不是要写很多重复的代码？所以我们可以先建一个人的父类，这个父类不代表一个具体的人，只是一个拥有人所有共同特性的虚拟的人。下次我 们要实例化一个具体的人的时候，只需要将这个人继承上面这个“虚拟的人”，那么他就拥有了人的所有共同特性。这样，这些重复的代码我们就可以不写了。

　　当然，继承的目标不仅仅是为了节省代码，还有实现后面的多态的功能。初学者只需要了解继承可以少写很多代码就好了，余下的需要在项目中慢慢理解。

书面的解释如下：对象的继承代表一种"is-a"的关系，假如两个对象A和B，如果可以描述为"B就是A"，那么则表示B可以继承自A。

注意： 如果A继承了B，那么A不仅拥有了B除私有的特性外的所有特性，A还可以拥有自己独特的特性。比如上面人的这个例子，一个继承了 “虚拟的人”，那么他除了有一个脑袋，二只胳膊，二条脚，要吃饭喝水外，他可能还会编程。编程就是他独特的特性了，因为不是每个人都会编程的。

2.1、继承的好处

①优化代码结构， 让类与类之间产生关系(人不是孤立存在的， 类也一样)；

②提高代码的复用性， 便于阅读(写更少的代码， 干更多的活)；

③为“ 多态” 提供前提(多态是面向对象最复杂的一个特性， 后面重点讲解)。

2.2、生活中的例子

以电视剧举例， 见图。

2.3、方法

(1)、延续：父类存在，子类没有重写但可以使用；

(2)、新增：父类没有，子类新增加的

(3)、重写：父类子类都存在，但是父类不满足要求，子类对其进行从新定义；

2.4、实例化：

(1)、先父类后子类，先静态后成员；

实例化的时候先调用父类的静态构造快，在调用父类的构造方法，然后子类的构造块，在调用子类的构造方法；

（有继承关系的几个类中，构造函数是由上至下调用的，即首先调用基类的构造函数。父亲会的，儿子也会，不先把父亲弄出来，儿子何来会？

(2)、默认调用父类空构造；

(3)、那么子类如何继承父类的构造方法呢，要按如下写法

编写父类的构造方法

演示： 在 Hero 类中创建构造方法， 用于初始化父类中的成员。

public Hero(string m_heroName, string m_heroInfo, int m_attack, int m_defense, int m_speed, string m_nickName)
        {
            this.heroName = m_heroName;

            this.heroInfo = m_heroInfo;

            this.attack = m_attack;

            this.defense = m_defense;

            this.speed = m_speed;

            this.nickName = m_nickName;
        }

编写子类的构造方法

演示： 在各个子类中编写各自的构造方法， 使用 base 关键字传值给父类。

关键字 base，代表父类；

关键字 this，代表当前类。

public LuKaShi() { }

        public LuKaShi(string m_heroName, string m_heroInfo, int m_attack, int m_defense, int m_speed, string m_nickName)

            : base(m_heroName, m_heroInfo, m_attack, m_defense, m_speed, m_nickName)

        {

        }

这里他不做任何处理，直接扔给父类。

(4)、继承之成员继承：构造方法

构造方法可以使用 private 和 public 进行修饰。但 99%的时候使用 public 修饰， 只有在使用单例模式的时候才使用 private 修饰。

private 修饰的构造方法， 我们在子类中访问不到；

public 修饰的构造方法， 我们在子类中可以访问到， 使用 base()。

2.5、继承的堆栈关系

父类在内存是实际存在的。

2.6、重写override

2.6.1 重写与重载：

重写override：继承的子类中，方法签名相同( 方法名+形参个数 类型 顺序  )

重载overload：同一个类方法名相同，形参个数 类型 顺序 不同（只要有一项不同，即可构成重载）

2.6.2 重写规则：在子类中签名与父类中相同，在合理范围内提高子类可见性；

这里没总结好，先学再总结下

A、父类必须有公共(public)或受保护(protected)的虚方法(virtual)；

返回类型：基本类型和void必须相同；引用类型要<=父类的返回类

在派生类里使用override关键字来重写父类的虚方法。

B、抽象方法，接口，标记为virtual的方法可以被重写（override），实方法不可以。

C、可见性：要大于或等于父类中被重写的方法(重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）)

D、重写和覆盖的区别