继承总结：
1， 继承是一种类和类之间的关系，它注重的是共性而不是特性。
2， 子类继承父类，内存中创建的过程是由上而下的。子类继承了父类的所有共有(public，protected)属性和方法。又由于创建过程是自上而下的，因此当子类实例化的时候，会先创建父类。
3， 就近原则：例如下面，Bird bird=new Chicken() ，bird对象中有个字段为type，而类Chicken也有type字段。当访问bird.type的时候就会访问到父类bird的type，而不是类Chicken的type。
4， 对象执行原则：Bird bird=new Chicken()创建的对象为chicken的对象，而类型引用却是bird类型的，但是方法调用的时候就会用对象相应的方法来调用。
5， 子类和父类之间有相同的属性和方法，子类可以覆盖父类的属性和方法：覆盖字段的时候就要用到new关键字，例如public new string type，而覆写方法的时候就要用到override（父类的方法为virtual）。
abstract class Animal
{
public abstract void ShowType();
public void Eat()
{
Console.Write("animal eat");
}
}
class Bird:Animal
{
public string type = "Bird";
public override void ShowType()
{
Console.Write("type is {0}",type);
}
private string color;
public string Color
{
get { return color; }
set { color = value; }
}
}
class Chicken:Bird
{
private new string type = "chicken";
public override void ShowType()
{
Console.WriteLine("type is {0}",type);
}
public void ShowColor()
{
Console.WriteLine("color is {0}", Color);
}
}
class Program
{
static void
{
Bird chicken = new Chicken();
chicken.ShowType(); // 这里使用多态，而ShowType方法覆写了父类方法，因此要根据对象的具体情况来判断使用哪个方法
Bird bird = new Bird();
bird.Color = "black";
Chicken chick = new Chicken();
chick.ShowColor();//这里继承，继承了父类bird的属性color，因此chick的color值和父类bird的一样。
Bird bird1 = new Chicken();//这里的bird1是chicken对象，但是它的类型为Bird，也就是说当要调用方法的时候，
//首先以bird类型来检查bird类中有没有对应的函数，如果没有就会出错，而如果有的话就会调用chicken对象中的方法
bird1.Color = "green";
//bird1.ShowColor();//这里会出错，因为当检查bird类型的时候，bird类没有ShowColor方法。换句话说当子类没有重写父类的方法，这种情况会调用父类的方法而不是子类的showcolor方法。
//注意：当子类继承父类的时候，要注意访问权限，也就是private，public，protected等等，而子类要覆盖父类的属性，那就要用到new，
//例如：private new string type，而对应方法的覆写就要用override。
}
}
封装总结：
1， 这里所谓的接口不是什么接口继承的，它可以是某个方法或属性。
2， 封装简单来说就是使用public，private等来修饰字段和方法，但事实上他体现了重要性。
3， 对外统一的接口，用public来修饰，而内部的操作实现就用private，这样就可以实现UI分离。
4， 在进行封装的过程，其实就是对类设计的过程。类设计的过程中要考虑类的功能或职能，类的属性字段，这里要遵循单一职责原则。
5， 字段一般为private，而属性一般为public，属性换句话说就是字段的对外接口，那当然属性中可以添加相应的判断条件。
6， 方法，对外统一接口的一般为public，而内部实现的一般为private。例如ATM机中，对外统一的接口为那个插卡口。而具体的内部实现（用户的验证，取款的计算等）都是用private。
7， 对外统一的接口一般都是稳定的，而不易去修改的。因此有时候创建一个稳定的接口（这里说的接口是interface，跟上面的对外统一接口不同），通过这样从另一方面来说是封装了变化，当有一个稳定的接口，那可以通过接口继承根据需求来变化。这就是所谓面向接口编程。
封装规则：
1， 尽可能地调用类的访问器，而不是成员，即使是在类内部。
2， 内部私有部分可以任意修改，但一定要在保证外部接口稳定的情况下。
3， 将对字段的读写控制实现为属性，而不是方法，否则舍近求远，非明智之选。
4， 类封装是由访问权限来保证的，对内实现private，对外实现public。
5， 封装的精华是封装变化。
多态总结：
1，多态就是体现为一种动作或操作在不同实例上，表现的结果或实现有所不同。
2，多态分为基类继承式多态和接口实现式多态。基类继承式多态是通过继承来实现的，其实我们平时继承中就有这样一种情况 Files file=new WordFile（）；file.open();而接口实现式多态是通过实现接口的方法约定形成的继承体系，它体现的是一种CAN-DO的关系。
3，以前看过这样的一个例子：一个人，在家被叫为孩子，在车上就是乘客，在学校是学生，而他还是要干活的（对应方法为doWorking（）），而在不同的场合他干活的表现是不同的，在家要做家务，在车上就乘车，而在学校要听老师话。体现了一个动作或操作在不同的场合或实例中，做的工作表现的结果是有所不同的。
4，多态提供了对同一个类对象的差异化的处理方式，实现对变化和共性的有效封装和继承，体现了“一个接口，多个方法”的思想，使方法抽象机制成为可能。
接口总结：
1， 接口是一组行为的规范。也就是说接口里面的方法就是对应的行为，而规范是说，只有自定义类遵循了接口的规范，才拥有这种行为能力。例如
interface IMyInterface
{
void Show();
}
class MyInterface : IMyInterface
{
#region IMyInterface 成员
public void Show()
{
throw new NotImplementedException();
}
#endregion
}
当MyInterface遵循了IMyInterface，它才能具有Show()的行为能力。
2， 接口可以多继承。也就是说同一个对象可以有不同身份，可以实现多个行为，但也就是要遵循多个接口规范。
3， 面向接口编程，如图 整个图是数据访问层，只是具体分开了接口和具体实现
IUser是接口，MySQLUser，AccessUser，XMLUser都遵循了IUser的规范，并实现其功能（增删改查）。而他们具体的数据操作就图片下面的部分MySQLHelper和AccessHelper。这里就分开了两层：基于接口的数据访问层（上面）和具体数据操作层（下面）。因此对数据的操作规则的变更（下面）不会影响实体类对象的行为（上面），体现了职责分离的设计原则。
4， 接口隔离原则
接口应该被实现为具有单一功能的多个小接口，（也就是说实现多接口继承），而不是一个集成多功能的大接口，通过多个接口的不同组合，客户端可以按需求实现不同的接口（是小接口，而不是一个大接口的某些方法），从而避免了出现接口污染的问题。有时候我会想，如果自定义类要继承某个接口，但是接口里面的有些方法，自定义类是不需要的，那怎么办？其实也换句话说，我已经出现了接口污染的问题，因为如果真的是这样的情况，就有必要对接口进行细分变成小接口。这样自定义类就可以有选择性地去实现对应的小接口。还有的是如果多个自定义类继承的一些接口都出现多余的方法，那可以将接口分为一个方法一个接口的形式，这样就可以有选择性地选择小接口，然而又避免了接口污染问题。
5， 接口继承和类继承区别
接口是一组行为的规范，而类是一类对象的共性的集合。接口继承主要面向于行为的操作，例如数据访问的行为（insert，select，update等），而类继承是面向于类的共性，子类继承了父类的一些属性，适应于实体类。
6， 接口不能被实例化，没有构造函数，接口成员被隐式声明为public。
7， 禁止为已经发布的接口，添加新的成员。这样意味着你必须重新修改所有实现了该接口的类型。
8， 接口编程，使得高层模块不依赖于底层模块，而依赖于比较稳定的抽象。这样就实现了良好的设计架构。
