C#面向对象之封装

一、封装

　　下面我设计了一个空调类，对于要使用这个空调类的其他类我可以称它们为用户。用户需要了解空调类的使用方法，才能更好的使用空调。空调类如下：

public class Air
{
    /// <summary>
    /// 空调温度
    /// </summary>
    public int temperature;

    /// <summary>
    /// 空调上下方向（用int量化方向，0代表下，1代表中下，2代表中，3代表中上，4代表上）
    /// </summary>
    public int verticalDirection;

    /// <summary>
    /// 空调开关（false代表关，true代表开）
    /// </summary>
    public bool switch_C;

    public Air()
    {
        temperature = 28;
        verticalDirection = 3;
        switch_C = false;
    }
}

用户使用我设计的空调类，如果他对使用方法不太熟，它可能给空调上下方向设置成5或者其它数字；或者今天天气特别热，它把空调温度设置成0度甚至更低，或者失误设置成100度。

public class User
{
    public void UseAir()
    {
        Air air = new Air();
        air.switch_C = true;
        air.verticalDirection = 5;  //空调上下方向没有5这个设置
        air.temperature = 0;        //空调温度设置成0度
        air.temperature = 100;      //如果我的空调类什么温度都能达到，那可能要用户老命！！！
    }
}

可以看出我的空调类设计得有问题，我应该限制空调温度和空调上下方向的设置范围，那么首先用户不能直接设置它们的值，所以我要把空调温度和空调上下方向定义成私有的，然后设计公共方法来限制它们的设置范围，同时还要设计公共方法为用户提供查询操作。空调开关也可以通过这种方式简化用户操作。第二版空调类如下：

public class Air
{
    /// <summary>
    /// 空调温度
    /// </summary>
    private int temperature;

    /// <summary>
    /// 空调上下方向（用int量化方向，0代表下，1代表中下，2代表中，3代表中上，4代表上）
    /// </summary>
    private int verticalDirection;

    /// <summary>
    /// 空调开关（false代表关，true代表开）
    /// </summary>
    private bool switch_C;


    /// <summary>
    /// 获取空调温度
    /// </summary>
    public int GetTemperature()
    {
        return temperature;
    }

    /// <summary>
    /// 设置空调温度
    /// </summary>
    /// <param name="degree"></param>
    public void SetTemperature(int degree)
    {
        if (degree > 16 && degree < 30)
        {
            temperature = degree;
        }
        else
        {
            //提示设置错误
        }
    }

    /// <summary>
    /// 获取空调上下方向
    /// </summary>
    /// <returns></returns>
    public int GetVerticalDirection()
    {
        return verticalDirection;
    }

    /// <summary>
    /// 设置空调上下方向
    /// </summary>
    /// <param name="direction"></param>
    public void SetVerticalDirection(int direction)
    {
        if (direction >= 0 && direction < 5)
        {
            verticalDirection = direction;
        }
        else
        {
            //提示设置错误
        }
    }

    public bool GetSwitch()
    {
        return switch_C;
    }

    public void SetSwitch()
    {
        switch_C = switch_C ? false : true;
    }

    //---设置有参构造函数时，调用相应set方法做对应限制---
    public Air(int num, int upOrdown, bool openOrClose)
    {
        SetTemperature(num);
        SetVerticalDirection(upOrdown);
        switch_C = openOrClose;
    }
}

上面我设计的第二版空调类所做的事就是封装，通过相应的Get和Set方法对外公开数据的操作，又能做到相应的限制，即保护字段数据不出现意外的值，又能对外隐藏操作数据方式的细节（无论SetTemperature方法的实现多么复杂，用户只需要知道如何使用就行了，好比你使用空调时只需要知道如何使用空调的功能，而不需要知道空调是如何完成这些功能的）。

二、属性

　　属性是对Get方法和Set方法的简化形式，也是C#提供的强制封装字段的方式。除此之外，它的最大优势是可以像使用字段一样使用属性。只读属性和只写属性即只有Get方法的属性和只有Set方法的属性。属性版空调类如下：

public class Air
{
    private int temperature;
    private int verticalDirection;
    private bool switch_C;

    /// <summary>
    /// 空调温度的属性(属性的返回值类型同对应的字段类型，属性的名字一般首字母大写)
    /// </summary>
    public int Temperature
    {
        //get作用域等同GetTemperature()方法
        get { return temperature; }
        //set作用域等同SetTemperature(int degree)方法，value等于参数degree
        set
        {
            if (value > 16 && value < 30)
            {
                temperature = value;
            }
            else
            {
                //提示设置错误
            }
        }
    }

    /// <summary>
    /// 空调上下方向的属性
    /// </summary>
    public int VerticalDirection
    {
        get { return verticalDirection; }
        set
        {
            if (value >= 0 && value < 5)
            {
                verticalDirection = value;
            }
            else
            {
                //提示设置错误
            }
        }
    }

    /// <summary>
    /// 空调开关的属性
    /// </summary>
    public bool Switch_C
    {
        //只读属性
        get { return switch_C; }
    }

    //SetSwitch方法没有bool参数，不能简化成属性，它是一个普通方法
    public void SetSwitch()
    {
        switch_C = switch_C ? false : true;
    }

    #region 构造函数直接调用属性,可以做到各司其职，构造函数只做初始化，检查字段有效范围则交给属性
    public Air() : this(28, 3, false) { }

    public Air(int num, int upOrdown, bool openOrClose)
    {
        Temperature = num;
        VerticalDirection = upOrdown;
        //只读属性只有Get方法没有Set方法，所以无法通过构造函数赋值，只能通过为其私有字段赋值，间接为属性赋值
        switch_C = openOrClose;
    }
    #endregion
}
public class User
{
    public void UseAir()
    {
        Air air = new Air();
        //开启空调
        air.Switch_C();
        //像字段一样使用属性
        air.Temperature += 1;
        air.VerticalDirection = 0;
    }
}

 　　当你获取属性的值时执行属性的get作用域，背后其实调用的是一个无参数且返回值类型同其封装的字段类型的方法；当你设置属性的值时执行属性的set作用域，背后其实调用的是一个有且仅有一个类型同其封装的字段类型的参数且返回值为void的方法。

三、自动属性

　　当属性只对封装字段作简单的包装时，可以使用自动属性简化封装字段数据的过程。结构如下：

//private int duration;
public int Duration
{
    get; //{ return duration; }
    set; //{ duration = value; }
}

自动属性省略了定义私有字段和get/set实现逻辑，这些省略的部分会由编译器在编译代码是为其自动生成。

注：在C#6.0语法以前自动属性不能设计成只读或只写自动属性，C#6.0语法开始允许设计只读自动属性。代码如下：

/// <summary>
/// C#6.0以前
/// </summary>
public class Air
{
    //不能设计只读或只写自动属性
    //public int Temperature { get; }
    //public int VerticalDirection { set; }
    //只能把相应的部分设计成private的
    public int Temperature { get; private set; }
    public int VerticalDirection { private get; set; }

    public Air(int num, int upOrdown)
    {
        //不能设计成只读自动属性的原因：只有Get方法没有Set方法无法赋值，所以永远不会有值。
        //Temperature = num;
        //不能设计成只写自动属性的原因：只有Set方法没有Get方法可以赋值，但永远无法被使用。
        VerticalDirection = upOrdown;
    }
}
/// <summary>
/// C#6.0开始
/// </summary>
public class Air
{
    //可以设计只读自动属性，但依然不能设计只写自动属性
    public int Temperature { get; }
    public int VerticalDirection { private get; set; }
}

疑问解答：自动属性存在的意义？控制可变的风险。自动属性实现封装服务的第二种作用，对外隐藏操作数据方式的细节。如果我直接使用字段定义数据，后期该字段业务需求发生改变需要做一定的限制，则需要添加方法来作限制，而此时使用这个字段的用户成千上万，全部从使用字段修改到使用方法代价极大；而使用自动属性则只需要在属性内添加限制即可，因为自动属性不写业务或写业务对用户使用起来没有区别。