面向对象三大宝，继承，封装和多态。
多态，是面向对象里面比较难理解的基础部分。听完老蒋的课后，我有一些自己对多态的理解，写在这里。
提到多态，就不得不说面向对象。那么什么是面向对象呢？
照我的理解，面向对象就是描述和封装我们所处世界的一种方法，简单的说，就是映射世界，万物皆对象。
而面向对象的伟大这时候就得以显现了一些，一个连世界都能映射出的方法，还有什么是不能做的？
面向对象把我们所能看到的一切东西都看做实例，而我们给这些东西起的名字就是对这些东西的抽象，就是类。笼统点的名字就是抽象类，比如动物；具体一点的就 是继承自抽象类的父类，比如猫；而再具体一点就是继承父类的子类，比如波斯猫；注意了，到现在为止，我们所说的类都是抽象类（或者是没有实例化的类，随 你），这个抽象类包含着异常复杂的属性（每一个属性都是一个枚举变量）和人们所能理解的方法。那么好了，这时候，你就可以有一个活生生的自波斯猫类实例话 的小猫了，我们给它的名字这个属性赋值：“小花”。
而至于你的小花的眼睛是什么颜色，毛发什么颜色这些就取决于上帝给它对应的属性赋什么值了，由于这些属性都是枚举变量，所以没办法，你的小花怎么也个性不 起来，因为这些枚举变量的值都是根据人们的经验所总结出来的。而至于你的小花喜欢尿床，可以认字什么的，就看你让它实现什么接口了。这些都不属于今天想写 的内容，所以就此略过了。
多态的语义看似复杂，其实说起来不外乎两种方式，一个是隐藏方法（new），一个是重写方法（override）。
1.隐藏方法
隐藏方法指的是通过在子类中用new关键字，对父类的同签名方法实现隐藏，实现当子类实例赋值给父类实例后，通过父类实例调用该方法实际调用的是父类实现的方法这一功能。
例子：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test
{
class MyBase
{
public void Func()
{
Console.WriteLine("我是父类方法");
}
}
class MyDerive:MyBase
{
public new void Func()
{
Console.WriteLine("我是子类方法");
}
}
class Test
{
static void Main(string[] args)
{
MyBase mybase = new MyBase();
mybase.Func();
MyDerive myderive = new MyDerive();
myderive.Func();
mybase = myderive;
mybase.Func();
Console.ReadLine();
}
}
}
输出：
我是父类方法
我是子类方法
我是父类方法
2.重写方法
重写方法指的是通过在子类中使用override关键字对，对父类使用virtual关键字修饰的同签名方法进行重写
，实现当子类实例赋值给父类实例后，通过父类实例调用该方法实际是调用子类实现的方法这一功能。
例子：注意这两个例子代码的区别很小，但是结果却很不一样
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test
{
class MyBase
{
public virtual void Func()
{
Console.WriteLine("我是父类方法");
}
}
class MyDerive:MyBase
{
public override void Func()
{
Console.WriteLine("我是子类方法");
}
}
class Test
{
static void Main(string[] args)
{
MyBase mybase = new MyBase();
mybase.Func();
MyDerive myderive = new MyDerive();
myderive.Func();
mybase = myderive;
mybase.Func();
Console.ReadLine();
}
}
}
输出：
我是父类函数
我是子类函数
我是子类函数
你看，多态，就是这么简单。
或许又要纳闷多态在编程上的使用，我就再举个不恰当的例子吧。
现在大学不都开学么，我们把大学里的每个人都看做从“人”这个抽象类继承的子类。这些子类通过实现不同接口又分为 学生类 和 教官类。
好了，军训开始了。
军训训谁，谁训呢？于是我们new了一个 教官对象 “小张” 和 一群 学生对象 “愣头青们”。
然后军训先训站姿，一开始“愣头青们”都由着自己的性子，也就是自己实现stand（）方法，随便站着。这时候“小张”一看不愿意了，于是说：“每个人都 给我站好了”。于是，“愣头青们”开始按照原始的站姿站好了。军训到中午了，“小张”又叫每个人实现Eat()方法，也就是都去吃饭了。
看懂 Eat()和Stand()方法哪个应该用重写，哪个应该用隐藏了么？
还不明白的话，我就写段伪代码，来解释下我上面的这段大白话。
class Person
{
public virtual void Eat();
public void Stand()
{
//标准站法
}
}
class Student:Person,IStudentAble
{
public new void Stand()
{
//每个人站姿不一样
}
public override void Eat()
{
//每个人吃饭口味不一样
}
}
class Master:Person,IMasterAble
{
}
class 大学生活
{
public void 军训()
{
Master 小张=new Master();
Student[] 愣头青们={"张三"，"李四","王五"};
//教官小张没来前，大家随便站
for(int i=0;i<愣头青们.Length,i++)
{
愣头青们[i].Stand();
}
//教官小张来了，要求每个人都站好了
Person[] per=愣头青们;
for(int i=0;i<per.Length,i++)
{
per们[i].Stand();
}
//到中午了，教官小张说，每个人去吃饭
Person[] per2=愣头青们;
for(int i=0;i<per2.Length,i++)
{
per2[i].Eat();
}
}
}
提到多态，就不得不说面向对象。那么什么是面向对象呢？
照我的理解，面向对象就是描述和封装我们所处世界的一种方法，简单的说，就是映射世界，万物皆对象。
而面向对象的伟大这时候就得以显现了一些，一个连世界都能映射出的方法，还有什么是不能做的？
面向对象把我们所能看到的一切东西都看做实例，而我们给这些东西起的名字就是对这些东西的抽象，就是类。笼统点的名字就是抽象类，比如动物；具体一点的就 是继承自抽象类的父类，比如猫；而再具体一点就是继承父类的子类，比如波斯猫；注意了，到现在为止，我们所说的类都是抽象类（或者是没有实例化的类，随 你），这个抽象类包含着异常复杂的属性（每一个属性都是一个枚举变量）和人们所能理解的方法。那么好了，这时候，你就可以有一个活生生的自波斯猫类实例话 的小猫了，我们给它的名字这个属性赋值：“小花”。
而至于你的小花的眼睛是什么颜色，毛发什么颜色这些就取决于上帝给它对应的属性赋什么值了，由于这些属性都是枚举变量，所以没办法，你的小花怎么也个性不 起来，因为这些枚举变量的值都是根据人们的经验所总结出来的。而至于你的小花喜欢尿床，可以认字什么的，就看你让它实现什么接口了。这些都不属于今天想写 的内容，所以就此略过了。
多态的语义看似复杂，其实说起来不外乎两种方式，一个是隐藏方法（new），一个是重写方法（override）。
1.隐藏方法
隐藏方法指的是通过在子类中用new关键字，对父类的同签名方法实现隐藏，实现当子类实例赋值给父类实例后，通过父类实例调用该方法实际调用的是父类实现的方法这一功能。
例子：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test
{
class MyBase
{
public void Func()
{
Console.WriteLine("我是父类方法");
}
}
class MyDerive:MyBase
{
public new void Func()
{
Console.WriteLine("我是子类方法");
}
}
class Test
{
static void Main(string[] args)
{
MyBase mybase = new MyBase();
mybase.Func();
MyDerive myderive = new MyDerive();
myderive.Func();
mybase = myderive;
mybase.Func();
Console.ReadLine();
}
}
}
输出：
我是父类方法
我是子类方法
我是父类方法
2.重写方法
重写方法指的是通过在子类中使用override关键字对，对父类使用virtual关键字修饰的同签名方法进行重写
，实现当子类实例赋值给父类实例后，通过父类实例调用该方法实际是调用子类实现的方法这一功能。
例子：注意这两个例子代码的区别很小，但是结果却很不一样
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test
{
class MyBase
{
public virtual void Func()
{
Console.WriteLine("我是父类方法");
}
}
class MyDerive:MyBase
{
public override void Func()
{
Console.WriteLine("我是子类方法");
}
}
class Test
{
static void Main(string[] args)
{
MyBase mybase = new MyBase();
mybase.Func();
MyDerive myderive = new MyDerive();
myderive.Func();
mybase = myderive;
mybase.Func();
Console.ReadLine();
}
}
}
输出：
我是父类函数
我是子类函数
我是子类函数
你看，多态，就是这么简单。
或许又要纳闷多态在编程上的使用，我就再举个不恰当的例子吧。
现在大学不都开学么，我们把大学里的每个人都看做从“人”这个抽象类继承的子类。这些子类通过实现不同接口又分为 学生类 和 教官类。
好了，军训开始了。
军训训谁，谁训呢？于是我们new了一个 教官对象 “小张” 和 一群 学生对象 “愣头青们”。
然后军训先训站姿，一开始“愣头青们”都由着自己的性子，也就是自己实现stand（）方法，随便站着。这时候“小张”一看不愿意了，于是说：“每个人都 给我站好了”。于是，“愣头青们”开始按照原始的站姿站好了。军训到中午了，“小张”又叫每个人实现Eat()方法，也就是都去吃饭了。
看懂 Eat()和Stand()方法哪个应该用重写，哪个应该用隐藏了么？
还不明白的话，我就写段伪代码，来解释下我上面的这段大白话。
class Person
{
public virtual void Eat();
public void Stand()
{
//标准站法
}
}
class Student:Person,IStudentAble
{
public new void Stand()
{
//每个人站姿不一样
}
public override void Eat()
{
//每个人吃饭口味不一样
}
}
class Master:Person,IMasterAble
{
}
class 大学生活
{
public void 军训()
{
Master 小张=new Master();
Student[] 愣头青们={"张三"，"李四","王五"};
//教官小张没来前，大家随便站
for(int i=0;i<愣头青们.Length,i++)
{
愣头青们[i].Stand();
}
//教官小张来了，要求每个人都站好了
Person[] per=愣头青们;
for(int i=0;i<per.Length,i++)
{
per们[i].Stand();
}
//到中午了，教官小张说，每个人去吃饭
Person[] per2=愣头青们;
for(int i=0;i<per2.Length,i++)
{
per2[i].Eat();
}
}
}