對於公司最近一次技術分享的總結

這篇文章是關於面向對象和面向過程以及一些設計模式的總結，歡迎各路大神拍磚。

 

 

面向過程和面向對象正如圖中所展現一樣。做蛋炒飯到完成，就是面向過程的體驗。而在做蓋澆飯到完成是面向對象的體現。

 

面向對象：object oriented programming

我們都知道，一切皆對象。但是說直接一點，那么面向對象是分析解決問題的步驟，然后用函數把這些步驟一步一步的實現，然后在使用的時候一一調用即可。面向對象是把構成問題的事務分解成各個步驟，而建立對象的目的也不是為了完成一個個步驟，而是為了描述某個事物在解決整個問題的過程中所發生的行為。

面向過程：procedure oriented programming

面向過程編程采取的是時間換空間的策略，因為在早期計算機配置低，內存小，如何節省內存則成了首要任務，於是就使用面向過程思想，來犧牲時間。但是隨着硬件技術的發展，硬件不再是瓶頸，能更好模擬現實世界，一些弊端也就凸顯出來，於是面向對象設計應運而生。

面向對象的五大原則：

一·單一職責原則（Single-Responsibility Principle）

     一個對象應該只包含單一的職責，並且該職責被完整地封裝在一個類中。

二·開放封閉原則（Open-Closed Principle）

     軟件實體應當對擴展開發，對修改關閉。

三·依賴倒轉原則（Dependency-Inversion Principle）

     高層模塊不應該依賴底層模塊，他們都應該依賴抽象。抽象不應該依賴於細節，細節應該依賴於抽象。

四·里氏代換原則（Liskov-Substituent Principe） 

     所有引用基類的地方必須能夠透明地使用其子類對象。

五·接口隔離原則（Interface-Segregation Principle）

      客戶端不應該依賴它不需要的接口。

面向對象：

各位看官可以把這個房子看做是一個對象。

面向對象：封裝

封裝是將各個獨立功能設計成一個個獨立的單元，形成一個有規划設計的整體，減少耦合，提高內聚，避免牽一發而動全身，方便對程序的可維護性。

 

面向對象：繼承

繼承是發生在兩個對象之間，繼承對象可以肆意的使用被繼承對象的屬性、方法、函數等等。使代碼重用，減少編碼量，間接減少維護成本

面向對象：多態

封裝是不同的場合做出不同相應，有着不同的特點，可以說是封裝的一個實現。

面向過程：

蛋炒飯由一道一道程序組成的，換言之，做任何一件事都是一種過程化的結果，事物是穩定的，具有因果關系。面向過程編程體現了程序員的邏輯性。

面向對象和面向過程總結：

1.蛋炒飯是邏輯的體現，哪一步亂了都不行。所以程序員的水平也可以在這里體現。

2.從飯館的角度出發，那么做蓋澆飯顯然比做蛋炒飯更有優勢，他可以隨意組合，能夠減少浪費。

3.只有在特定的場景下，才能各取所長。

設計模式的三種類型：

1.創建型模式：簡單工廠、工廠方法模式、抽象工廠模式、建造者模式、原型模式、單例模式

2.結構型模式：適配器模式、橋接模式、裝飾模式、組合模式、外觀模式、享元模式、代理模式

3.行為型模式：模板方法模式、命令模式、迭代器模式、觀察者模式、中介者模式、備忘錄模式、解釋器模式、狀態模式、策略模式、職責鏈模式、訪問者模式

今天這里只分享創建型模式。

簡單工廠：

簡單工廠模式又被稱之為靜態工廠方法，在簡單工廠模式中，可以根據傳遞的參數不同，返回不同類的實例。簡單工廠模式定義了一個類，這個類專門用戶創建其他類的實例，這些被創建的類都有一個共同的父類。

namespace DesignPattern
{
    public class SimpleFactory
    {
        public static Operation GetOperation(op op, double a, double b)
        {
            switch (op)
            {
                case op.add: return new Add(a, b);
                case op.sub: return new Sub(a, b);
                case op.mul: return new Mul(a, b);
                case op.div: return new Div(a, b);
                default: return new undef(a, b);
            }
        }
    }

    public enum op
    {
        add = '+',
        sub = '-',
        mul = '*',
        div = '/'
    }

    public abstract class Operation
    {
        public double a, b;
        public Operation(double a, double b)
        {
            this.a = a;
            this.b = b;
        }
        public abstract double GetResult();
    }

    public class Add : Operation
    {
        public Add(double a, double b) : base(a, b) { }

        public override double GetResult()
        {
            return a + b;
        }
    }

    public class Sub : Operation
    {
        public Sub(double a, double b) : base(a, b) { }

        public override double GetResult()
        {
            return a - b;
        }
    }

    public class Mul : Operation
    {
        public Mul(double a, double b) : base(a, b) { }

        public override double GetResult()
        {
            return a * b;
        }
    }

    public class Div : Operation
    {
        public Div(double a, double b) : base(a, b) { }

        public override double GetResult()
        {
            try
            {
                return a / b;
            }
            catch (DivideByZeroException e)
            {
                throw e;
            }
        }
    }

    public class undef : Operation
    {
        public undef(double a, double b) : base(a, b) { }

        public override double GetResult()
        {
            throw new NotImplementedException();
        }
        
    }
}

工廠方法模式：

工廠方法模式定義了一個創建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法模式讓實例化推遲到子類。

工廠方法和簡單工廠區別在於，每個工廠只管生產自己對應的產品，而簡單工廠是生產各種產品。

namespace DesignPattern
{
    public interface ILogger
    {
        void write(string log);
    }
    public class EventLogger : ILogger
    {
        public void write(string log)
        {
            Console.WriteLine("EventLog:" + log);
        }
    }
    public class FileLogger : ILogger
    {
        public void write(string log)
        {
            Console.WriteLine("FileLog:" + log);
        }
    }

    public interface ILoggerFactory
    {
        ILogger CreateLogger();
    }
    public class EventLoggerFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            return new EventLogger();
        }
    }
    public class FileLoggerFactory : ILoggerFactory
    {
        public ILogger CreateLogger()
        {
            return new FileLogger();
        }
    }
}

抽象工廠模式：

抽象工廠模式提供一個接口，用於創建相關或則依賴對象的家族，而不需要明確指定具體類。抽象工廠允許客戶使用抽象的接口來創建一組相關的產品，而不需要關系實際產出的具體產品是什么。這樣一來，客戶就可以從具體的產品中被解耦。

抽象工廠和工廠方法主要區別在於，抽象工廠內要像像定義中說的一樣，創建一組相關的產品。

那么，簡單工廠是一個工廠生產多個產品、工廠方法是拆分成子工廠，分別生產各自產品、抽象工廠整合了工廠方法和簡單工廠，隨着子工廠規模變大，也可以生產多個類似的產品。

namespace DesignPattern
{
    //抽象實體
    public abstract class absSalary
    {
        protected double salary;
        protected double bonus;
        protected double tax;
        public absSalary(double sal, double bns, double t)
        {
            this.salary = sal;
            this.bonus = bns;
            this.tax = t;
        }
        public abstract double CalculateTax();
    }
    public class ChineseSalary : absSalary
    {
        public ChineseSalary(double sal, double bns, double t)
            : base(sal, bns, t)
        {
        }
        public override double CalculateTax()
        {
            return (base.salary + base.bonus - 3500) * base.tax;
        }
    }
    public class ForeignerSalary : absSalary
    {
        public ForeignerSalary(double sal, double bonus, double tax)
            : base(sal, bonus, tax)
        {
        }
        public override double CalculateTax()
        {
            return (base.salary + base.bonus - 4000) * base.tax;
        }
    }

    public abstract class absSocialSecurity
    {
        protected double SocialSecurity;

        public absSocialSecurity()
        {
            this.SocialSecurity = 0;
        }
        public virtual double GetSocialSecurity()
        {
            return this.SocialSecurity;
        }
    }
    public class ChineseSocialSecurity : absSocialSecurity
    {
        public ChineseSocialSecurity(double socialsecurity)
            : base()
        {
            base.SocialSecurity = socialsecurity < 1000 ? 1000 : socialsecurity;
        }
    }
    public class ForeignerSocialSecurity : absSocialSecurity
    {
        public ForeignerSocialSecurity(double socialsecurity)
            : base()
        {
            base.SocialSecurity = socialsecurity < 1500 ? 1500 : socialsecurity;
        }
    }

    //抽象工廠，生產一系列產品（多個Create方法，分別對應不同產品）
    public interface AbstractFactory
    {
        absSalary CreateSalary(double sal, double bonus, double tax);
        absSocialSecurity CreateSocialSecurity(double socialsecurity);
    }
    public class ChineseFactory : AbstractFactory
    {
        public absSalary CreateSalary(double sal, double bonus, double tax)
        {
            return new ChineseSalary(sal, bonus, tax);
        }
        public absSocialSecurity CreateSocialSecurity(double socialsecurity)
        {
            return new ChineseSocialSecurity(socialsecurity);
        }
    }
    public class ForeignerFactory : AbstractFactory
    {
        public absSalary CreateSalary(double sal, double bonus, double tax)
        {
            return new ForeignerSalary(sal, bonus, tax);
        }
        public absSocialSecurity CreateSocialSecurity(double socialsecurity)
        {
            return new ForeignerSocialSecurity(socialsecurity);
        }
    }
}

建造者模式：

建造者模式也稱之為創建者模式。

建造者模式將一個復雜對象的構建與表示分離，使得同樣的構建過程可以創建不同的表示。建造者模式構建復雜對象就像造汽車一樣，是一個個組件一個個步驟創建出來的，它允許用戶通過制定的對象類型和內容來創建他們，但是用戶不需要知道這個復雜對象是如何創建的，它只需要明白通過這樣做我可以得到一個完整的復雜對象實例。

建造者模式和工廠方法很像，建造者是一個Builder內每個方法分別創建產品零部件，而工廠方法是每個工廠生產的一個產品。如何把Builder的零部件當做一個完整產品，是不是就像Builder又再一次封裝了工廠。

namespace DesignPattern
{
    public class Meal
    {
        private string food;
        private string drink;
        public Meal() { }
        public void setFood(string food)
        {
            this.food = food;
        }
        public void setDrink(string drink)
        {
            this.drink = drink;
        }
        public string getFood()
        {
            return this.food;
        }
        public string getDrink()
        {
            return this.drink;
        }
    }

    //建造者，分別建造不同部件，然后返回整體
    public abstract class Builder
    {
        protected Meal meal = new Meal();
        public abstract void buildFood();
        public abstract void buildDrink();
        public Meal GetMeal()
        {
            return meal;
        }
    }

    public class MealABuilder : Builder
    {
        public override void buildFood()
        {
            meal.setFood("A food");
        }
        public override void buildDrink()
        {
            meal.setDrink("A drink");
        }
    }
    public class MealBBuilder : Builder
    {
        public override void buildFood()
        {
            meal.setFood("B food");
        }
        public override void buildDrink()
        {
            meal.setDrink("B drink");
        }
    }

    public class Waitor
    {
        public void PrepareMeal(Builder builder)
        {
            builder.buildDrink();
            builder.buildFood();
        }
    }
}

原型模式：

原型模式就是用原型實例指定創建對象的種類，並且通過復制這些原型來創建新的對象。

復制有深/淺兩張復制，這是面向對象的值類型和引用類型的差異。

深復制：把引用對象的變量指向復制過的新對象，而不是原有的被引用的對象。

淺復制：被復制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用都依然指向原來的對象。

 

namespace DesignPattern
{
    [Serializable]
    public class other
    {
        public int value { get; set; }
        public other()
        {
            value = 10;
        }
    }

    [Serializable]
    public abstract class ColorPrototype
    {
        public int red { get; set; }
        public int green { get; set; }
        public int blue { get; set; }

        public other o = new other();

        //淺拷貝
        public virtual ColorPrototype Clone()
        {
            return (ColorPrototype)this.MemberwiseClone();
        }
    }

    public class Red : ColorPrototype
    {
        public override ColorPrototype Clone()
        {
            return base.Clone();
        }
    }

    [Serializable]
    public class Green : ColorPrototype
    {
        public override ColorPrototype Clone()
        {
            BinaryFormatter formatter = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();
            formatter.Serialize(stream, this);
            stream.Position = 0;
            ColorPrototype obj = (ColorPrototype)formatter.Deserialize(stream);
            return obj;
        }
    }
}

單例模式：

單例模式可以說是設計模式中最簡單的一種模式。單例模式的目的是使得類的一個對象成為系統中的唯一實例。

namespace DesignPattern
{
    public class Singleton
    {
        private int cnt = 0;
        private static Singleton instance = null;
        private volatile static Singleton safeInstance = null;
        private static readonly object lockedobj = new object();
        private Singleton()
        {
        }
        public static Singleton GetInstance()
        {
            if (instance == null) instance = new Singleton();
            return instance;
        }
        public static Singleton GetSafeInstance()
        {
            if (safeInstance == null)
            {
                lock (lockedobj)
                {
                    if (safeInstance == null)
                    {
                        safeInstance = new Singleton();
                    }
                }
            }
            return safeInstance;
        }
        public void count()
        {
            cnt += 1;
        }
        public int getCnt()
        {
            return cnt;
        }
    }

}