2011-12-28 面向对象若干知识点

1.重载和覆写

方法重载:当类包含两个名称相同但签名不同(方法名相同,参数列表不同)的方法时发生方法重载,用方法重载来提供在语义上完成相同功能的不同方法.

覆写:在类的继承使用中,通过覆写override来实现改变父类虚方法的实现.需要注意的是,在方法覆写的过程中,一些方法有必要调用父类的方法,覆写中必须留父类方法.

 

2.接口与继承的区别?什么时候使用接口?什么时候使用继承?

1)接口定义一个类型需要实现的方法,属性,,索引和时间,包括可能的参数类型和返回值类型,而把具体的实现交由相应的类或结构来做,从而为组建提供多态能力.

2)继承常用于在一个现有父类的基础上的功能扩展,往往是我们将几个类中相同的成员提取出来放在父类中实现,然后再各自的子类中加以继承.

3)接口可以实现多接口继承,而继承只能实现但继承

4)实现继承可继承父类型的实现,由于接口中没有定义方法的实现,因此必须实现继承后该接口的所有方法.

5)为父类添加方法可能不影响使用集成子该类实现的用户,而为接口添加方法导致用户必须为新方法添加实现.

6)当派生类和基类是is-a的关系是使用”继承”,典型案例”苹果is –a 水果”,存在can-do的关系时使用”接口”.

一个类只能继承于一个父类,但是可以实现多个接口.

我们来看一个简单的计算器代码:

 

class Operation
    {
        private double _numberA, _numberB;
        
        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        /// <summary>
        /// 得到两个数的运算结果
        /// </summary>
        /// <param name="numberA">用户输入的第一个数</param>
        /// <param name="numberB">用户输入的第二个数</param>
        /// <returns>运算后的结果</returns>
        public virtual double getResult(double numberA,double numberB)
        {
            double result=0;
            return result;
        }
    }

 

这是一个简单的计算器类,通过继承,我们可以将它扩展出家法和减法操作

 

class OperationAdd:Operation
    {
        /// <summary>
        /// 加法操作
        /// <see cref="StudyCon1.Operation.getResult(double NumberA,double NumberB)"/>
        /// </summary>
        /// <param name="NumberA"></param>
        /// <param name="NumberB"></param>
        /// <returns></returns>
        public override double getResult(double NumberA, double NumberB)
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

 

class OperationSub:Operation
    {
        /// <summary>
        /// 减法操作
        /// <see cref="StudyCon1.Operation.getResult(double NumberA,double NumberB)"/>
        /// </summary>
        /// <param name="NumberA"></param>
        /// <param name="NumberB"></param>
        /// <returns></returns>
        public override double getResult(double NumberA, double NumberB)
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

 

这样就可以大大扩展了Operation的功能,使操作更具体.

接下来看一下使用接口实现同样的方法:

 

首先定义一个接口

interface IOperation
    {
        double getResult();
    }

 

然后实现这个接口:

 

    class ImplOperationAdd:IOperation
    {
        private double _numberA, _numberB;
        ImplOperationAdd(double a, double b)
        {
            _numberA = a;
            _numberB = b;
        }
        public double getResult()
        {
            return _numberA + _numberB;
            throw new NotImplementedException();
        }
    }

 

这样我们就从接口中实现了一个两数加法的类.

 

    class ImplOperationSub:IOperation
    {
        private double _numberA, _numberB;
        ImplOperationSub(double a, double b)
        {
            _numberA = a;
            _numberB = b;
        }
        public double getResult()
        {
            return _numberA - _numberB;
            throw new NotImplementedException();
        }
    }

 

从接口实现的减法类