对于公司最近一次技术分享的总结

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

 

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

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

}