面向对象之封装，继承，多态

封装

一、什么是封装

封装就是将类的一些信息隐藏在类的内部，不允许外部直接进行访问，而是通过这个类提供的方法来进行访问和操作。

二、封装的步骤

1、将属性私有化，就是用private来修饰。

2、提供geter()和seter()方法，供外部访问。

3、在geter()和seter()方法中，添加流程控制语句。

 public class Operation
    {       

        private double _numberA = 0;
        private double _numberB = 0;
        public double numberA
        {
            get
            {
                return _numberA;
            }
            set
            {

                _numberA = value;
            }
        }
        public double numberB
        {
            get
            {
                return _numberB;
            }
            set
            {
                _numberB = value;
            }
        }
｝

三、封装的优点

1、可以隐藏类的实现细节，减少耦合；

2、便于修改，使代码的可维护性增强；

3、通过类提供的方法来访问数据，保证了程序的安全性。

继承

一、什么是继承

   表示一个类型派生于基类型，它拥有该基类型的所有成员字段和函数。在实现继承中，派生类型采用基类型的每个函数的实现代码，除非在派生类型的定义中指定某个函数的实现代码。在需要给现有的类型添加功能，或许多相关的类型共享一组重要的公共功能时，可以使用这种类型的继承。

 class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result=numberA+numberB;
            return result;
           
        }
 
    }

多态

多态性概述：

    当派生类从基类继承时，它会获得基类的所有方法、字段、属性和事件。面向对象的语言使用虚方法表达多态。若要更改基类的数据和行为，您有两种选择：可以使用新的派生成员替换基成员，或者可以重写虚拟的基成员。

1.使用新的派生成员替换基类的成员需要使用 new 关键字。如果基类定义了一个方法、字段或属性，则 new 关键字用于在派生类中创建该方法、字段或属性的新定义。new 关键字放置在要替换的类成员的返回类型之前。例如：

 1public class BaseClass

 2{

 3    public void DoWork() { }

 4    public int WorkField;

 5    public int WorkProperty

 6    {

 7        get { return 0; }

 8    }

 9}

10public class DerivedClass : BaseClass

11{

12    public new void DoWork() { }

13    public new int WorkField;

14    public new int WorkProperty

15    {

16        get { return 0; }

17    }

18}

 

使用 new 关键字时，调用的是新的类成员而不是已被替换的基类成员。这些基类成员称为隐藏成员。如果将派生类的实例强制转换为基类的实例，就仍然可以调用隐藏类成员。例如：

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Calls the old method.

2.为了使派生类的实例完全接替来自基类的类成员，基类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加 virtual 关键字来实现的。然后，派生类可以选择使用 override 关键字而不是 new，将基类实现替换为它自己的实现。例如：

 

public class BaseClass
{
    public virtual void DoWork() { }     
    public virtual int WorkProperty
    {
        get { return 0; }
    }
}
public class DerivedClass : BaseClass
{
    public override void DoWork() { }
    public override int WorkProperty
    {
        get { return 0; }
    }
}

 

字段不能是虚拟的，只有方法、属性、事件和索引器才可以是虚拟的。当派生类重写某个虚拟成员时，即使该派生类的实例被当作基类的实例访问，也会调用该成员。例如：

DerivedClass B = new DerivedClass();
B.DoWork();  // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork();  // Also calls the new method.