设计模式---简单工厂和单例

1.设计模式的概念：   

设计模式：设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

2.设计模式的优点:

  为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

 

---------简单工厂设计模式

 所谓简单工厂设计模式，就肯定有一个工厂类，这个工厂类中有一个方法。

1.对于这个方法的一些注意点：

01.必须是静态的

02.返回值是父类类型。

03.传递参数（通过题目的不同给予不同的参数）

eg：

public static Pizza getdo（string type）{}

2.通过switch选择结构选择覆盖父类的子类

创建父类对象，赋值为null

Pizza pizza=null；

switch（传入的参数）

{

      case 1：

        pizza=new ChessePizza（）；

       break；

       case 2：

      pizza=new pgPizza（）；

      break；

}

return pizza；

---------------------01简单工厂（制作比萨案例）---------------

首先要创建一个父类比萨类：这个类是抽象的也就是说这个类是abstract修饰的。

这个类中有一个抽象的方法，用于制作比萨。

 父类底层有量个子类分别是CheesePizza(奶酪比萨类)PgPizza（培根比萨类）

子类必须重写父类的抽象的方法。

 //比萨类
   public abstract class Pizza
    {
       public abstract string Show();
    }

  //培根比萨
  public  class PgPizza:Pizza
    {

        public override string Show()
        {
            return "培根比萨制作完成!";
        }
    }
 //奶酪比萨
    public class CheesePizza:Pizza
    {
        public override string Show()
        {
            return "奶酪比萨制作完成!";
        }
    }
  //工厂类
   public class PizzaFactory
    {
       public static Pizza dopizza(string type) 
       {
           Pizza ps = null;
           switch (type)
           {
               case "培根比萨":
                   ps = new PgPizza();
                   break;
               case"奶酪比萨":
                   ps = new CheesePizza();
                   break;
             
           }
           return ps;

       }

    }

 

在form窗体中调用

private void btndo_Click(object sender, EventArgs e)
        {
            if (rbBacon.Checked==true)
            {
                //调用工厂中的制作方法,返回值用父类类型接收，传入制作的比萨类型
                Pizza ps = PizzaFactory.dopizza(rbBacon.Text);
                string work = ps.Show();
                MessageBox.Show(work);
            }
            else 
            {

                Pizza ps = PizzaFactory.dopizza(rbCheese.Text);
                string work = ps.Show();
                MessageBox.Show(work);
            }
        }

---------------------02简单工厂（制作计算器）---------------

   //计算类:父类
    public abstract class Calculate
    {
        public double num1 { get; set; }//第一个操作数
        public double num2 { get; set; }//第二个操作数
       //抽象方法计算结果
        public abstract double Cal();
    }


//加法计算
    public class Add:Calculate
    {
        public override double Cal()
        {
            return this.num1 + this.num2;
        }
    }

 //减法计算
   public class Reduce:Calculate
    {
       public override double Cal()
       {
           return this.num1 - this.num2;
       }
    }

 //乘法计算
    public class Ride:Calculate
    {
        public override double Cal()
        {
            return this.num1 * this.num2;
        }
    }


  //除法计算
   public  class Div:Calculate
    {
        public override double Cal()
        {
            double result = 0.0;
            if (this.num2 == 0)
            {
                throw new Exception("被除数不能为0");
            }
            else 
            {
                  result=this.num1 / this.num2;

            }
            return result;

        }
    }

 //工厂
  public  class OpearFactory
    {
      public static Calculate Calresult(string opear) 
      {
          Calculate cal = null;
          switch (opear)
          {
              case"+":
                  cal = new Add();
                  break;
              case "-":
                  cal = new Reduce();
                  break;
              case "*":
                  cal = new Ride();
                  break;
              case "/":
                  cal = new Div();
                  break;
          }
          return cal;
      
      }
    }

在From窗体中调用

当点击窗口计算按钮的时候，调用工厂类的静态方法，根据下拉框所选的运算符作为方法的参数，得出的一个父类返回值类型，然后自定义一个父类类型接受一下！

把窗口TextBox的两个运算参数传给自定义父类类型的两个参数，再由传进去的运算符进入工厂类决定New哪个子类，然后父类调用子类的计算方法得出一个结果！

 private void btnok_Click(object sender, EventArgs e)
        {
           //获取第一个操作数
          double num1 = Convert.ToInt32(txtnum1.Text);
            //获取第二个操作数
          double num2 = Convert.ToInt32(txtnum2.Text);
            //获取运算符
            string opear = cboOpear.Text;
            //传入opear返回值类型为父类类型
           Calculate cal= OpearFactory.Calresult(opear);
           cal.num1 = num1;
           cal.num2 = num2;
           double result = 0.0;
           try
           {
               //调用子类对应方法
                result = cal.Cal();
           }
           catch (Exception ex)
           {

               MessageBox.Show(ex.Message);
           }
         
          lblresults.Text = result.ToString();
        }

-----------------------单例设计模式---------------
单例模式的概念：

单例模式就是保证在整个应用程序的生命周期中，在任何时刻，被指定的类只有一个实例，

并为客户程序提供一个获取该实例的全局访问点。简单的说 就是这个类只能被实例化一次,

以后取出来的都是它的实例.

在S1阶段结束时做了一个KTV点歌系统，每次点击一个窗口进行播放，都会new出一个窗口，如何让他只new一次，这就涉及到了单例设计模式：

01：创建一个窗体类FrmKTVplay。

02：把系统公有初始化组件方法改为私有

    private  FrmKTVplay()
        {
            InitializeComponent();
        }

03：定义一个静态的和窗口类同类型的自定义变量

效果为：private static FrmKTVplay play;

04：再定义一个公有的静态窗口类型的方法

效果为：public static FrmPlay Show()
       {
           if (play == null)
           {
               play = new FrmKTVplay();
           }
           return play;
       }