蹒跚学步——C#之面向对象

最新推荐文章于 2015-01-28 14:13:17 发布

snow_li

最新推荐文章于 2015-01-28 14:13:17 发布

阅读量1.2k

点赞数

分类专栏： C#面向对象

本文链接：https://blog.csdn.net/u010196821/article/details/21863697

版权

C#面向对象专栏收录该内容

7 篇文章 0 订阅

订阅专栏

接触C#已经有一段时间了，因为前边Vb基础没打好，对于编制知识网也只是停留在一个表层上。这里就先对C#核心——面向对象的三大基本特征宏观简单的小结一下。

封装

每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装。他不用以来与其他对象来完成自己的操作。

其实封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

封装就是将与这个对象相关的属性，方法，都装在这个对象的箱子中，此时这个箱子中的东西是外界不能看到的，但是他拥有一个清晰的对外接口，以供别人的调用。

 public class Customer  //类名字
    {
        protected  string name;
        protected  decimal balance;  //精确到一毛钱  balance 是电话费
        public string CustomerName  //定义属性，对类的成员进行读和写
        {
            get { return name; }
            set { name = value; }

        }
public void RecordfPayment(decimal amountpaid) //amount paid  支出金额  支付账单（recordpayment）
        {
            balance -= amountpaid;   //进行电话计费  如果为零相当于不欠钱
        }

以上例子是对顾客这个类进行封装，有对外公开的方法，也有自己的隐私所要保护的重要的信息。

封装的优点：

良好的封装能够减少耦合。

类内部的实现可以自由地修改

类具有清晰的对外接口

安全性很高

继承

源于抽象类的思想

抽象类包含了事物的共有属性和方法　,为继承提供了一个出发点.

抽象类的作用就是让子类继承,去重新编写抽象类中的抽象方法(也为重写或覆写)

子类不但具有父类的特性，还可以定义新的特性。

 public class Nevermore60Customer:Customer   //继承基类
    {
        private   uint highCostMinutesUsed;
        public override void RecordCall(TypeOfCall callType, uint nMinutes)  //virtual：废墟函数不可改变基类，所以如果要改变基类，同时要有自己的一些特色使用virtual，让此类成为墟，然后调用要使用override
        {
            switch (callType )
            {
                case TypeOfCall.callToLandline: 
                    balance += (0.02M*nMinutes );
                    break ;
                case  TypeOfCall.callToMobile :
                    uint HighCostMinutes , LowCostMinutes; //定义一个最高分钟 高出的要以相应的每分钟多少钱来算，低分钟要按照每分钟多少钱来算
                    uint HighCostMinutesTOGO=(highCostMinutesUsed < 60)? 60-highCostMinutesUsed  :0;  //计算还有多长时间属于高费用的时间 如果所打电话打的分钟大于60，那么直接高计费的为0
                    if (nMinutes >HighCostMinutesTOGO )
                    {
                        HighCostMinutes =HighCostMinutesTOGO ;
                        LowCostMinutes =nMinutes -HighCostMinutes ;


                    }
                    else 
                    {
                        HighCostMinutes =nMinutes; 
                            LowCostMinutes =0;
                    }
                    highCostMinutesUsed +=HighCostMinutes ;
                    balance +=(0.05M*HighCostMinutes +0.02M*LowCostMinutes );
                    
                    break ;
                default :
                    break;



            }
                        
        }

按照上述封装例子，写一个子类。有Customer这一父类，当然打电话超过60分钟的Customer也是其中一种，所以两者为继承关系。我们可以看出来，在子类中的

RecordCall这个方法，是对父类中的RecordCall这个方法的重写，这样做的原因就是因为父类的此方法属于大众化的（大众情人），但是子类也有此方法，但是他比较个性一点，有自己喜欢的人，所以这个方法就要重写一下。

说到重写，不得不说一下重写的特点：

只有虚方法或抽象方法才能实现（virtual关键字）

只有通过使用override关键字来实现

要求(三相同)

相同的方法名

相同的参数列

相同的返回值类型

以上的要求是必须满足的,缺一不可,如果不满足,使用的时候就会出错.

继承的优点是：

继承使得子类公共的部分都放在了父类中，使得代码的到共享，避免重复