这篇文章是关于面向对象和面向过程以及一些设计模式的总结，欢迎各路大神拍砖。

 

 

面向过程和面向对象正如图中所展现一样。做蛋炒饭到完成，就是面向过程的体验。而在做盖浇饭到完成是面向对象的体现。

 

面向对象：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;        }    }}