深刻分析面向對象中的封裝做用

時間 2019-11-06

原文原文鏈接

以前我（夢在旅途）發表過一篇名爲《深刻分析面向對象中的對象概念》的文章，裏面主要講解了類與對象的關係以及對象的概念、狀態、行爲、角色幾個知識點，讓你們對對象有了一些深刻的瞭解，而本文則再來談談面向對象的三大特性之一：封裝，封裝是實現面向對象的基礎，深刻的理解封裝的特性，有利於咱們能更好的領悟面向對象的思想以及實現面向對象編程。如下均爲本人憑藉多年開發經驗總結的我的觀點，你們若發現有誤或不足的地方，歡迎指正和交流，謝謝！html

1、什麼是封裝？程序員

顧名思義，封:封閉，裝：裝起來，將具體的實現細節裝到一個容器中，並封閉起來，防止容器外部直接訪問容器內部的實現細節，僅公開暴露指定的訪問路徑；生活中的例子：到飯館吃飯，你只須要跟服務員講你要吃什麼飯菜，服務員就會跟後臺廚房的廚師說明一下，等待一段時間後，飯菜就被服務員直接遞送到你面前，做爲客戶的你是不知道也無需知道飯菜的具體作法，後臺廚房的廚師及作飯菜的過程就是被封裝的細節，而服務員則是公開暴露的訪問路徑，你只能經過服務員點餐而後得到飯菜，而不能直接去到後臺廚房要求廚師如何作飯菜；面試

示例代碼以下：編程

    /// <summary>
    /// 飯館
    /// </summary>
    class FanGuan
    {
        private string doFoodName;

        /// <summary>
        /// 點餐
        /// </summary>
        /// <param name="foodName"></param>
        public void ChooseFood(string customer, string foodName)
        {
            doFoodName = foodName;
            Console.WriteLine("顧客：{0}，點餐：{1}", customer, foodName);
        }

        /// <summary>
        /// 得到飯菜
        /// </summary>
        /// <returns></returns>
        public string GetFood()
        {
            string cookeResult = CookeFood("廚師甲");
            return string.Format("{0},請您用餐，謝謝！", cookeResult);
        }

        /// <summary>
        /// 廚師作菜，私有方法，外部不可訪問
        /// </summary>
        /// <param name="cooker"></param>
        /// <returns></returns>
        private string CookeFood(string cooker)
        {
            Console.WriteLine("廚師：{0}開始作菜：{1}>>>>", cooker, doFoodName);
            Console.WriteLine("開火");
            Console.WriteLine("放油");
            Console.WriteLine("放食材，翻炒");
            Console.WriteLine("加入佐料");
            Console.WriteLine("菜熟起鍋，盛到盤子遞給服務員");
            Console.WriteLine("結束<<<<");

            return string.Format("菜：{0}已作好", doFoodName);
        }
    }


//實際用法：
        static void Main(string[] args)
        {
            FanGuan fanGuan = new FanGuan();
            fanGuan.ChooseFood("夢在旅途", "紅燒茄子");
            string food = fanGuan.GetFood();
            Console.WriteLine(food);
            Console.WriteLine("用餐");

            Console.ReadKey();
        }

該示例很是簡單，演示結果就再也不截圖出來了。設計模式

2、封裝的做用是什麼？架構

1．隔離性：
被封裝後的對象（這裏的對象是泛指代碼的編程單元，通常指：程序集，命名空間，類，方法，屬性，變量等）其外部對象是沒法直接訪問對象的內部實現細節，內部實現細節的的改動不會影響到外部對象的訪問原則（即：對象內部修改後，在公開暴露指定的訪問路徑不變的狀況下，外部訪問它的對象是無需修改的），這是隔離性的體現，同時也是實現高內聚，低耦合的最根本的思想之一；
2．可複用性：
被封裝後的對象能夠被外部多個對象訪問，而無需爲每一個外部對象去指定不一樣的服務對象；如：全部的對象的基類都是object類，object類裏面的公共成員能夠被其全部子類使用，Ado.Net相關的數據訪問類及其公共成員都可被其它全部的對象使用等。
3．可讀性：
被封裝後的對象的名稱（如：程序集名，類名，方法名）若是命名恰當，那麼就能在不看裏面的實現細節的前提下，瞭解該對象的做用；如：DataTable就是用來裝表格數據的；ToString就是轉換爲字符串,Length就是指長度等。函數

3、封裝的範圍有哪些？post

1．封裝成常量/變量：
如：計算圓周長度，未封裝前的代碼以下：學習

            //封裝前：
            decimal result = 2 * 3.141592653M * 10.8M;
            Console.WriteLine("圓周長度是：{0}", result);

封裝後的代碼以下：this

            //封裝後：
            const decimal PI = 3.141592653M;
            decimal radius = 10.8M;

            decimal circumference = 2 * PI * radius;

            Console.WriteLine("圓周長度是：{0}", circumference);

你以爲哪一種可讀性更高一些呢？從我看來，很顯然封裝後的代碼更易被他人所理解，由於圓周長的計算公式就是：C=2πr;從circumference就知道是圓周長的結果，而等號右邊恰好符合圓周長計算公式，因此很是的直觀，可讀性由此體現出來；
2．封裝成方法/函數/屬性：

//計算圓周長
static decimal ComputeCircumference(decimal radius)
        {
            const decimal PI = 3.141592653M;
            return 2 * PI * radius;
        }


//用法：
Console.WriteLine("圓周長度是：{0}", ComputeCircumference(10.8M));

經過封裝成方法後，咱們看到ComputeCircumference方法，就知道是計算圓周長，同時我能夠用此方法來計算全部的不一樣半徑的圓的周長，可讀性、複用性由此體現出來；
3．封裝成類：

    /// <summary>
    /// 圓類
    /// </summary>
    class Circle
    {
        //原點X座標
        public int OriginX
        { get; set; }

        //原點Y座標
        public int OriginY
        { get; set; }

        //半徑
        public decimal Radius
        { get; set; }

        public Circle(int originX, int originY, decimal radius)
        {
            this.OriginX = originX;
            this.OriginY = OriginY;
            this.Radius = radius;
        }

        /// <summary>
        /// 獲取圓周長度
        /// </summary>
        /// <returns></returns>
        public decimal GetCircumference()
        {
            const decimal PI = 3.141592653M;
            return 2 * PI * this.Radius;
        }
    }


//用法：
Circle circle = new Circle(10,10,10.8M);
Console.WriteLine("圓周長度是：{0}", circle.GetCircumference());

從上述示例代碼能夠看出，我定義（封裝）了一個圓類，圓類有原點及半徑，同時有一個獲取圓周長度的方法，該圓類能夠用來表示多個不周大小不一樣位置的圓，並且都能得到圓的圓周長，至於圓周長是如何計算的，PI的精度是多少，咱們無需知道也沒法直接更改，故隔離性、可讀性、複用性都體現出來了；
4．封裝成層/包/程序集：

有的時候因系統架構的須要，咱們可能須要將描述各類圖形類信息的代碼單獨封裝成一個程序集、包、命名空間，以便於代碼的管理，因而咱們能夠將上述Circle類放到一個單獨的程序集中，同時程序集及命名空間名稱定爲：Math.Shape，意爲數學.圖形，從名字就知道這個程序集或命名空間下都是用來處理數學與圖形相關的。

示例代碼以下：

namespace Math.Shape
{
     public class Circle
     {
         //省略，同上
      }

}

//用法：
Math.Shape.Circle circle = new Math.Shape.Circle(10, 10, 10.8M);
Console.WriteLine("圓周長度是：{0}", circle.GetCircumference());

4、封裝的禁忌

1. 忌封裝過分

如：

            string a = "a";
            string b = "b";
            string c = "c";
            string d = "d";
            string joinString = a + b + c + d;

            Console.WriteLine(joinString);

改進後的代碼：

            string joinString = "{0}{1}{2}{3}";
            joinString = string.Format(joinString, "a", "b", "c", "d");

這是典型的封裝過分，太過原子化，爲每個字符串都定義一個變量，代碼量增長，且效率也不高，而改進後代碼精簡且效率高。

固然還有一些封裝過分，好比：一個方法或一個類的代碼量很是多，假設有一個數學計算類，能夠計算全部的數字類型和全部的數學計算方法，想象一下它的代碼量會有多少，這個時候就應該考慮進行適當的拆分封裝，至少能夠拆成數學類型類及數學計算類。
2. 忌不恰當的封裝

如：

        static bool IsNullOrEmpty(string str)
        {
            return string.IsNullOrEmpty(str);
        }

        static bool IsNotNullOrEmpty(string str)
        {
            return !string.IsNullOrEmpty(str);
        }

從上述代碼能夠看出，String的IsNullOrEmpty已經能夠知足需求，但有些人可能還會多此一舉，增長這麼兩個類，而即便是爲了想不寫string.這樣的，那也沒有必需寫兩個方法，一個方法能夠了，由於這兩個方法自己就是對立的，只可能同時存在一種狀況，能夠進行以下改進：

        static bool IsNullOrEmpty(object obj)
        {
            if (obj == null)
            {
                return true;
            }

            return string.IsNullOrEmpty(obj.ToString());
        }

這樣改進後，明顯的IsNullOrEmpty能夠用來判斷全部的類型是否爲Null 或者 Empty，若是須要判斷不須要爲Null 或者 Empty，只需調用該方法並取反便可，如：!IsNullOrEmpty("zuowenjun")

5、結尾

這篇文章原本打算自去年發佈了《深刻分析面向對象中的對象概念》後就當即寫這篇，我通常寫一些總結性很強的文章都是先在WORD中寫好後再COPY過來的，這篇文章一樣也是，但因爲以前工做緣由一直是隻寫了一個提綱，故今天看到了這篇博文躺在個人文件夾中，同時又聯想最近我當面試官及新進人員的情況（我發表過一篇文章《由面試引起的思考：B/S與C/S到底是何物》），因而果斷在今天花了一個下午的時間，邊想邊寫，終於給寫完了，也但願你們可以從中受益，這兩篇文章自己沒有很深很新的技術，但做爲一個程序員，若想技術上有所造詣，必需先學好基本功，我再重複一下個人觀點：

技術就如同武術，基本功很重要，只要基本功紮實了，再去學習架構、設計模式，就會比較容易，同時這些看似高大上的東西，如：AOP，SOA,DI,IOC,DDD,CQRS等，只要明白其原理，觸類旁通就能達到「無招勝有招」的最高境界。