面向对象的三大特点：封装，继承，多态，外加一个重载概念。

1.封装：

我们有时候不能太去追究概念，封装简单的理解：把现实世界里面的某个功能封装到一个类或者方法里面。
比如我们老例子：

Code
public abstract class CenterBank : IBank
    {

        //银行剩余存款，自己给自己多弄点。
        private decimal _total = 0; //

        //定义一个属性。类似方法
        public decimal Total
        {
            set { _total = value; }
            get { return _total; }
        }

        #region IBank 成员

        public bool SaveMoney(decimal money)
        {
            //throw new NotImplementedException();

            //存钱
            this._total += money; // 等于this._total = this._total + money;
            return true; //存钱成功啦
        }

        public decimal GetMoney(decimal money)
        {
            //throw new NotImplementedException();

            //先判断存款是否够我取的，我们不能透支啊，经济危机来了，要节约哦。
            if (this._total >= money)
            {
                return money;
            }
            else
            {
                return 0;//取钱失败，因为余额不足。
            }
            
        }

        //定义一个抽象方法
        public abstract decimal GetTotal();

        public virtual void AutoAddMoney()
        {
            this._total += 500;
        }

        #endregion
    }

 

在这里例子里面，我们想要得到Total的值，只能通过GetTotal方法。 换句话说，类就是一个盒子，黑盒子，我开了几个口子，每个口子负责不同的任务。盒子外面的人，不能直接把手伸到盒子里面，而只能通过我们开启的口子来得到东西，比如GetTotal方法就是一个口子，你通过这个口子，就能得到总金额。

 

2.继承 (请注意，以下思考过程，也是说明如何把现实业务提取成软件流程，换句话说，就是学习如何做系统架构)

说得继承，我就觉得要提到抽象思维。比如我们的Bank --银行， 这个名字是所有银行的总名字。但是银行有一些共同的部门啊，业务啊，比如存钱和取钱。每个银行都可以存钱和取钱。
但是每个银行存钱或者取钱的方式可能不一样。

那么银行的共同业务，我们就可以定义接口：

Code
    interface IBank
    {
        bool SaveMoney(decimal money);
        decimal GetMoney(decimal money);
    }

 

那么现在中国银行来了：(叫"继承"或者说"实现"这个接口)

 

Code
public class ChinaBank: IBank
    {
        #region IBank 成员

        bool IBank.SaveMoney(decimal money)
        {
            //存钱方法：把钱扔地上，再捡起来存。
        }

        decimal IBank.GetMoney(decimal money)
        {
            // 取钱方法： 先踩几脚，再把钱给你
        }

        #endregion
    }

 

工商银行：

 

Code
    public class ICBC : IBank
    {

        #region IBank 成员

        public bool SaveMoney(decimal money)
        {
            //存钱方法：先把钱放到验钞机看看，有没有假的，没假的再存。
        }

        public decimal GetMoney(decimal money)
        {
            //存钱方法：从金库提金条，放到验钞机（好像放不进去）验验，然后再给你。
        }

        #endregion
    }

 

 

ChinaBank和ICBC 具有相同的存钱和取钱业务，但是他们的实现方式不一样。

 

3. 多态性 -- 通过同一个方法，但表现 出来的结果却不一样，比如下面的例子，都是Draw方法，但是画出来的东西却不一样。这就是“Draw”的多态性[2009-06-17更新]。

上面的例子中其实已经包含了多态性。 比如SaveMoney方法吧。 在IBank接口里面仅仅定义了这个接口，或者说银行仅仅规定了下属银行需要有存钱这个业务。但是总行没有说具体怎么存。到了下面的银行(ChinaBank/ICBC)，他们各自研究出自己的存钱方式，其实这个就是多态性。

再如，我们定义一个画画的接口：

Code
    interface IDraw
    {
        void Draw();
    }

再看下面三个类：

Code
public class DrawLine : IDraw
    {

        #region IDraw 成员

        public void Draw()
        {
            //画一条线
        }

        #endregion
    }

    public class DrawRectangle : IDraw
    {

        #region IDraw 成员

        public void Draw()
        {
            //画个矩形
        }

        #endregion
    }

    public class DrawCircle : IDraw
    {

        #region IDraw 成员

        public void Draw()
        {
            //画个圆
        }

        #endregion
    }

 

分别是画线、矩形、圆。 Draw方法的多态就体现在这里。

 

4.最后一个重要概念：重载

每种语言的实现方式不一样，不过大多数都是相同的。看看C#的重载：

Code
    class Class3
    {
        public void GetString(int i);
        public void GetString(string i);
        public void GetString(decimal i);
        public string GetString(int i,decimal i);
    }

这里有4个GetString，这就叫做重载。 但是这4个GetString的参数的类型,个数,返回类型不一样。也正因为参数的类型,个数,返回类型不一样，才能实现重载。

这里的“参数的类型,个数,返回类型”也叫做方法的“签名” ，换句话说，不同的“参数的类型,个数,返回类型”，就具有不同的“签名”。“签名”这个概念，在后面的委托中要用到。

很好的参考文章：http://www.cnblogs.com/A-Z/archive/2006/03/01/340388.html

 

转载于:https://www.cnblogs.com/nevernet/archive/2009/01/07/1371229.html