封装继承多态

面向对象语言有三大法宝：封装、继承和多态。其功能就一条，加快程序开发，方便理解。

封装

：在面向对象编程中，封装（encapsulation）是将对象运行所需的资源封装在程序对象中——基本上，是方法和数据。意思就是说，把该单独拿出来的方法或者属性单独新建个类。，把他们放到一起。

例如说：

namespace IArraylIst
{
    class Score
    {
        ArrayList a1 = new ArrayList();

        /// <summary>
        /// 添加分数的方法
        /// </summary>
        public void AddMark()
        {
            int i = 0;
            while(true)
            {
                Console.WriteLine("输入评分，以-1结束");
                i = int.Parse(Console.ReadLine());
                if(-1 != i)
                {
                    a1.Add(i);
                }
                else
                {
                    break;
                }
            }
        }

        /// <summary>
        /// 删除最大最小分数
        /// </summary>
        public void Del()
        {
            if(a1.Count > 2)
            {
                a1.Sort();
                a1.RemoveAt(0);
                a1.RemoveAt(a1.Count - 1);
            }
        }
        
        /// <summary>
        /// 求平均分
        /// </summary>
        /// <returns>返回平均分</returns>
        public double Average()
        {
            double sum = 0;
            foreach (int  i in a1)
            {
                sum += i;                
            }
            return sum / a1.Count;
        }

    }
}

当然这个类的命名我命的不太好，一般以“I”开头的是是声明的接口，这里我就不管了，这个类实现的是把数组最值去掉，然后算平均分，下面的代码是主函数：

namespace IArraylIst
{
    class Program
    {
        //评委平均分 ，去掉最高和最低
        static void Main(string[] args)
        {
            Score s = new Score();
            s.AddMark();
            s.Del();
            s.Average();
            Console.WriteLine($"平均分为{s.Average()}");
            Console.ReadLine();
          
        }
    }
}

这样的把这个程序的功能和方法类单独写是不是很友好，是不是看着很方便， 因为我给我的小伙伴们培训的时候，他们习惯把 主函数和方法写到一个 .cs文件里面去，主函数的代码量贼多，看着乱，让代码看着顺眼是封装的一个小甜点，其主要功能是把该放到一起的代码，整理到一起。类似于以前我写项目链接数据库时写的 SqlHelper.cs 的类，把程序与后台数据库交互的方法单独写到一起，这样有利于开发。

继承

：继承是软件复用的一种形式。使用继承可以复用现有类的数据和行为，为其赋予新功能而创建出新类。节省开发时间，重用经过实践检测和调试的高质量代码，提供系统的质量。在现有类（基类、父类）上建立新类（派生类、子类）的处理过程称为继承。派生类能自动获得基类的除了构造函数和析构函数以外的所有成员，可以在派生类中添加新的属性和方法扩展其功能。

这句话就简单了，继承是依托于封装的一个好东西，为什么好呢，我们从故事开始：

话说啊，在村东头有个老刘头，他遗传了他祖上传下来的技能：说话。他儿子厉害了，他儿子小刘比他多一项技能，什么呢？吹牛皮。老刘头的孙子可就更厉害了，他不但继承了老刘头的说话，还继承了他爹小刘的吹牛皮，更是把吹牛皮发扬光大，变成了把牛皮吹上了天。

故事完了，你说老刘那里我是不是只写一个 说话的方法（speak)就可以了啊,小刘我是不是要写一个继承他爹老刘头的 speak 还要再写一个说谎（TellLie）的方法？那小小刘是不是要写一个speak和telllie好要在写个 Tell_Big_Lie的方法？

这样代码的冗余度是不是在小小刘那里就体现出来了， 因为他爷爷老刘头的speak方法他们刘氏祖孙三代都会啊，而且内容一样啊。把代码复写，是不是比较烦躁，令人头疼，所以我么可以把利用继承，把他们能传下来的方法继承下来，这些方法我就可以不写了。例如：

namespace Inheritance
{
    class Granson :Father
    {
        public string Tell_Big_Lie()
        {
            return "我是小小刘，我会把牛吹上天";
        }
    }
}

namespace Inheritance
{
    class Father :GrandFather
    {
        public string Tell_Lie()
        {
            return "我是小刘，我会吹牛";
        }
    }
}

namespace Inheritance
{
    class GrandFather
    {
        public string Speak()
        {
            return "我是老刘头，我会说话";
        }
    }
}

类似于这样的，因为时间有限，我先将一点点，其余的有时间再写