常用设计模式（一）

设计模式

1、 目的

为了代码复用，增强代码可维护性。

2、 UMl类图(http://uml.riaoo.com/)

统一建模语言,是客户需求和实际开发的桥梁。

2.1类

分为三层，第一层显示类的名称，如果是抽象类，则用斜体显示，第二层是类的特性，通常就是字段和属性，第三层是类的操作，通常是方法和行为，前面是+表示public，-表示private，#表示protected。

 

2.2 接口

顶部有<<interface>>

第一行：接口名称

第二行：接口方法

 

   2.3 继承

  

   3.3 关联关系

  

   3.4 聚合关系

   A对象可以包含B对象，但B对象不是A对象的一部分，

  

   3.5 组合关系

   A是B的一部分，部分和整体的关系。

  

   3.6 依赖关系

  

   3.7 实现

  

3、 简单工厂模式

Demo1

Operation类：

/// <summary>
    /// 运算类
    /// </summary>
    public class Operation
    {
        private double _numberA = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        private double _numberB = 0;

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        public virtual double GetRuselt()
        {
            double result = 0;
            return result;
        }
    }

OperationFactory类：

 /// <summary>
    /// 简单工厂类
    /// </summary>
    public class OperationFactory
    {
        public static Operation CreateOperate(string operate)
        {
            Operation oper=null;
            switch (operate)
            { 
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }

OperationAdd类：

/// <summary>
    /// 加法类
    /// </summary>
    public class OperationAdd:Operation
    {
        public override double GetRuselt()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

OperationDiv类

/// <summary>
    /// 除法类
    /// </summary>
    public class OperationDiv : Operation
    {
        public override double GetRuselt()
        {
            double result = 0;
            if (NumberB == 0)
            {
                throw new Exception("除数不能为0");
            }
            result = NumberA / NumberB;
            return result;
        }
    }

OperationMul类

 /// <summary>
    /// 乘法类
    /// </summary>
    public class OperationMul : Operation
    {
        public override double GetRuselt()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

OperationSub类：

  /// <summary>
    /// 减肥类
    /// </summary>
    public class OperationSub : Operation
    {
        public override double GetRuselt()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

调用：

 public partial class Form1 : Form
    {
        public string strOper;
        public double dNumber1;
        public double dNumber2;
        public string sLinkNumber;
        public bool b = false;
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 运算符
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_Click(object sender, EventArgs e)
        {
            textBox1.Text = "";
            sLinkNumber = "";
            Button btn = sender as Button;
            strOper = btn.Text;
            b = true;
        }


        /// <summary>
        /// 等于
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button15_Click(object sender, EventArgs e)
        {
            if (b == false)
            {
                return;
            }
            Operation oper;
            oper = OperationFactory.CreateOperate(strOper);
            oper.NumberA = dNumber1;
            oper.NumberB = dNumber2;
            textBox1.Text = oper.GetRuselt().ToString();
            sLinkNumber = textBox1.Text;
            b = false;
        }
        public void Clear()
        {
            b = false;
            textBox1.Text = "";
            dNumber1 = 0;
            dNumber2 = 0;
            sLinkNumber = "";
        }
        /// <summary>
        /// 数字
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            Button btn = sender as Button;
            sLinkNumber += btn.Text;
            if (b)
            {
                dNumber2 = Convert.ToDouble(sLinkNumber);
            }
            else
            {
                dNumber1 = Convert.ToDouble(sLinkNumber);
            }
            textBox1.Text = sLinkNumber;
        }

        private void button13_Click(object sender, EventArgs e)
        {
            Clear();
        }
    }

Demo2

   面向对象编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

CashSuper类：

/// <summary>
    /// 现金收取抽象类
    /// </summary>
    public abstract class CashSuper
    {
        public abstract double AcceptCach(double money);
    }

CashContext类：

 public class CashContext
    {
        private CashSuper cs = null;
        public CashContext(string type)
        {
            switch (type)
            {
                case "正常收费":
                    CashNormal cs0 = new CashNormal();
                    cs = cs0;
                    break;
                case "满300返100":
                    CashReturn cs1 = new CashReturn("300","100");
                    cs = cs1;
                    break;
                case "打八折":
                    CashRebate cs2 = new CashRebate("0.8");
                    cs = cs2;
                    break;
            }
        }
        public double GetRusult(double money)
        {
            return cs.AcceptCach(money);
        }

    }

CashNormal类：

 /// <summary>
    /// 正常收费子类
    /// </summary>
    public class CashNormal:CashSuper
    {
        public override double AcceptCach(double money)
        {
            return money;
        }
    }

CashRebate类：

/// <summary>
    /// 打折收费子类
    /// </summary>
    public class CashRebate:CashSuper
    {
        private double moneyRebate = 1d;
        public CashRebate(string moneyRebate)
        {
            this.moneyRebate = double.Parse(moneyRebate);
        }
        public override double AcceptCach(double money)
        {
            return money * moneyRebate;
        }
    }

CashReturn类：

/// <summary>
    /// 返利收费子类
    /// </summary>
    public class CashReturn:CashSuper
    {
        private double moneyCondition = 0.0d;
        private double moneyReturn = 0.0d;
        public CashReturn(string moneyCondition, string moneyReturn)
        {
            this.moneyCondition = double.Parse(moneyCondition);
            this.moneyReturn = double.Parse(moneyReturn);
        }
        public override double AcceptCach(double money)
        {
            double result = money;
            if (money >= moneyCondition)
            {
                result = money - Math.Floor(money / moneyCondition) * moneyReturn;
            }
            return money;
        }
    }

调用：

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        double total = 0.0d;
        private void button1_Click(object sender, EventArgs e)
        {
            CashContext cs = new CashContext(comboBox1.SelectedItem.ToString());
            double totalPrices = 0d;
            totalPrices = cs.GetRusult(Convert.ToDouble(textBox1.Text) * Convert.ToDouble(textBox2.Text));
            total += totalPrices;
            listBox1.Items.Add("单价：" + textBox1.Text + "数量：" + textBox2.Text + " " + comboBox1.SelectedItem + "合计：" + totalPrices.ToString());
            label5.Text = total.ToString();
        }
    }

4、 单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。严格地控制客户怎样访问以及合适访问实例。

Demo3

Singleton类：

public class Singleton
    {
        private static Singleton instance;
        private Singleton() { }//构造方法私有，就堵死了外界利用new创建此类实例的可能
        public static Singleton GetInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

调用：

 class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();
            if (s1 == s2)
            {
                Console.WriteLine("两个对象是相同的对象");
            }
            Console.ReadKey();
        }
    }

5、 适配器模式

适配器模式使得原本由于接口不兼容而不能在一起工作的那些类可以在一起工作。

Demo4

Player类：

public abstract class Player
    {
       protected string name;
       public Player(string name)
       {
           this.name = name;
       }
       public abstract void Attack();//进攻方法
       public abstract void Defense();//防守方法
    }

Forwards类：

 /// <summary>
    /// 前锋类
    /// </summary>
    class Forwards:Player
    {
        public Forwards(string name)
            : base(name)
        { 
        
        }
        public override void Attack()
        {
            Console.WriteLine("前锋{0}进攻", name);
        }
        public override void Defense()
        {
            Console.WriteLine("前锋{0}防守", name);
        }
    }

Guards类：

class Guards:Player
    {
        public Guards(string name)
            : base(name)
        { 
        
        }
        public override void Attack()
        {
            Console.WriteLine("后卫{0}进攻", name);
        }
        public override void Defense()
        {
            Console.WriteLine("后卫{0}防守", name);
        }
    }

Translator类：

  /// <summary>
    /// 翻译者
    /// </summary>
    class Translator:Player
    {
        private ForeignCenter fc = new ForeignCenter();
        public Translator(string name)
            : base(name)
        {
            fc.Name = name;
        }
        public override void Attack()
        {
            fc.进攻();
        }
        public override void Defense()
        {
            fc.防守();
        }
    }

ForeignCenter类：

调用：

class Program
    {
        static void Main(string[] args)
        {
            Player b = new Forwards("巴蒂尔");
            b.Attack();
            Player m = new Guards("麦克格雷迪");
            m.Attack();

            Player ym = new Translator("姚明");//翻译者告诉姚明，教练要求你进攻
            ym.Attack();
            Console.ReadKey();
        }
    }

6、 模版方法模式

模板方法模式是通过把不变行为搬移到超类，去除子类中的重复代码来体现它的优势。就是提供了一个很好的代码复用平台。

Demo5

AbstractClass类：

 abstract class AbstractClass
    {
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();
        /// <summary>
        /// 模板方法
        /// </summary>
        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
    }

ConcreteClassA类：

class ConcreteClassA:AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具体类A方法1实现");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类A方法2实现");
        }
    }

ConcreteClassB类：

class ConcreteClassB:AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具体类B方法1实现");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类B方法2实现");
        }
    }

调用：

  class Program
    {
        static void Main(string[] args)
        {
            AbstractClass c;
            c = new ConcreteClassA();
            c.TemplateMethod();
            c = new ConcreteClassB();
            c.TemplateMethod();
            Console.ReadKey();
        }
    }

7、 外观模式

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

Demo6

Facade类：

class Facade
    {
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        SubSystemFour four;
        public Facade()
        {
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
            four = new SubSystemFour();
        }
        public void MethodA()
        {
            Console.WriteLine("
方法组A()-----");
            one.MethodOne();
            two.MethodTwo();
            three.MethodThree();
            four.MethodFour();
        }
        public void MethodB()
        {
            Console.WriteLine("
方法组B()-----");
            two.MethodTwo();
            three.MethodThree();
        }
    }

SubSystemOne类:

 class SubSystemOne
    {
        public void MethodOne()
        {
            Console.WriteLine("子系统方法一");
        }
    }

SubSystemTwo类：

 class SubSystemTwo
    {
        public void MethodTwo()
        {
            Console.WriteLine("子系统方法二");
        }
    }

SubSystemThree类：

class SubSystemThree
    {
        public void MethodThree()
        {
            Console.WriteLine("子系统方法三");
        }
    }

SubSystemFour类：

class SubSystemFour
    {
        public void MethodFour()
        {
            Console.WriteLine("子系统方法四");
        }
    }

调用：

 class Program
    {
        static void Main(string[] args)
        {
            Facade f = new Facade();
            f.MethodA();
            f.MethodB();
            Console.ReadKey();
        }
    }