设计模式的一些笔记

1.1.代码容易存在的毛病

​ a.命名不规范

string A= Console.ReadLine();	//显著问题是A这样的命名极其不规范

​ b.判断分支

if(A=='+'){};
if(A=='-'){};	//这样会进行多次if的判断
...

1.2.面向对象的优点

​ a.可维护

​ b.可重复使用

​ c.可拓展

​ d.灵活性好

通过封装，继承，多态把程序的耦合度降低

1.3.封装

​ 总结来说就是把运算和显示分开

//operation 运算类
public class Operation
{
    public static double GetResult(double A,double B,string Operation){};//求解运算结果的函数
}

//客户端代码
static void Main(string[] args)
{
	try
    {
        Console.write("输入数字A：");
        string A=Console.ReadLine();
        //输入B
        result=GetResult(A,B);//调用函数GetResult得到结果
        //显示结果
    }
    catch(Exception ex)
    {
        //输出错误信息
    }
}

1.4.紧耦合和松耦合（继承和多态）

​ 简单概括就是将原先的operation 运算类拆成俩个部分，在运算类里面不定义函数方法，只定义基本规则，但在类外使用类的继承方法来进行继承

operation 运算类
public class Operation
{
    private double _A=0;
    private double _B=0;
    
    public double NumberA
    {
        get{return _A;}
        set{_A=value;}
    }
    //同理可以构筑B
    
    public virtual double GetResult()	//虚函数
    {
        double result=0;
        return result;
    }
    
}

//加减乘除类
class OperationADD: Operation
{
    public override double GetResult()
    {
    	double result=0;
        result = NumberA+NumberB;	//调用的是上面的定义NumberA这里
        return resule;
    }
    
    //减法和乘除继承
}

1.5.简单工厂模式

​ 简单工厂模式的内涵就是，利用一个单独的类来做创造实例的过程

//简单工厂类
public class OperationFactory
{	
    Operation oper=null;
    switch(operate)
    {
        case "+":
            oper=new OperationADD();	//另外去构建OperationADD的类，参照上面进行继承和编写
            break;
        //同理构建其他方法
    }
    return oper;
}

//客户端代码
Operation oper;	//
oper = OperationFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result = oper.GetResult();	//结果在result上

1.6.UML类图

类:

​ 第一行：类名称（如果为抽象类则用斜体，比如动物）

​ 第二行：特征（抽象类则用斜体表示）

​ 第三行：操作（方法或者行为）

​ +：public

​ -：private

​ #：protected

继承：空心三角形+实线

依赖：虚线箭头（“动物”依赖“氧气和水”）

关联：实现箭头（”企鹅“需要知“气候”变化）

2.1策略模式

收银软件举例：

v1.0

double total = 0.0d	//来记录总价

private void btnOk_Click(Object sender,EventArgs e)
{
    //声明一个double变量totalPrices来计算每个商品的单价和数量后的乘积
    double totalPrices= Convert.ToDouble(txtPrice.Text)*Convert.ToDouble(txtNum.Text);
    //将每个商品合计计入总价
    total = total + totalPrices;	//累加
    lbxList.Item.Add("单价："+txtPrice.Text+"数量："+txtNum.Text+"合计："+totalPrices.ToString());	//显示信息
    lblRestlt.Text=total.ToSting();	//显示总价
}

但如果要增加一个折扣呢？在原有基础上的修改如何不改变原本而作为一个分支呢？

v1.1

double total = 0.0d	//来记录总价

private void Form1_Load(object sender,EventArgs e)	//界面设计
{
    cbxType.Ttems.AddRange(new object[] {"正常收费","八折","七折","五折"});
    cbxType.SelectedIndex = 0;
}

private void btnOk_Click(Object sender, EventArgs e)	// 
{
    double totalPrices= 0d;
    switch(cbxType.SelectedIndex)
    {
        case 0:
            totalPrices=Convert.ToDouble(txtPrice.Text)*Convert.ToDouble(txtNum.Text);
            break;
        case 1:
            totalPrices=Convert.ToDouble(txtPrice.Text)*Convert.ToDouble(txtNum.Text)*0.8;	//选择八折优惠时
            break;
        //其他情况不再展开叙述
    }
    total += totalPrices;
    //最后显示部分照旧
}

依旧存在的问题：

​ 1.如果再增加满300-50这样的折扣选择呢，继续增加子类吗？

​ 2.很多相同的部分也有很多的重复，比如Convert.ToDouble（）出现了八次

总结：

​ 面对对象的变成，类的数量不是越多越好，因为类的划分是为了封装，但分类的基础是抽象，所有具有相同属性和功能的对象的抽象集合才是类

v1.2 简单工厂

//现金收费抽象类
abstract class CashSuper
{
    public abstract double acceptCash(double money)
}

//正常收费类
class CashNormal : CashSuper
{
    public overrible double acceptCash(double money)
    {
        return money;
    }
}

//打折收费类
class CashRebate : CashSuper
{
    private double moneyRebate = 1d;
    public CashRebate(string moneyRebate)
    {
        this.moneyRebate =double.Parse(money)
    }
}

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

//现金收费工厂
class CashFactory
{
    public static CashSuper createCashAccept(string type)
    {
        CashSuper cs = null;
        switch(type)
        {
            case "正常收费":
                cs = new CashNormal();
                break;
            case "满300返100":
                CashReturn cr1 = new CashReturn("300","100");
                cs=cr1;
                break;
            //剩下的部分不再展示
        }
        return cs;
    }
}

//客户端部分
double  total = 0.0d;
private void btnOk_Click(object sender, EventArgs e)
{
    CashSuper csuper = CashFactory.createCashAccept(cbxType.SelectionItem.ToString());
    double totalPrices = 0d;
    totalPrices =csuper.acceptCash(Convert.ToDouble(txtPrice.Text)*Convert.ToDouble(txtNum.Text));
    total += totalPrice ;
    //最后为输出部分
}

策略模式和工厂的区别

​ 工厂：用作客户端的接口使用

​ 策略模式：利用Strategy来进行封装转化

V2.0 策略模式

//Strategy类，定所所有支持算法的公共接口
abstract class Strategy
{
	//算法方法
	publicabstract void AlgorithmInterface();
}

//ConcreteStrategy封装了具体的算法或者行为，继承于Stratepy
class ConcreteStrategy : Strategy
{
	//算法A的实现方法
	public override void Alg
}