学习笔记-设计原则和设计模式-2020.6

设计原则

1.单一职责原则 – SRP（Single Resonsibility Principle）

一个类只应该做和一个职责相关的事情，不要把过多的业务放在一个类中完成。不要存在多于一个导致类变更的原因

实例：
完成一个餐厅出菜的流程实现，后面可能会有流程的增加

class Kitchen{
               public void work(String type)
               {
                          Console.WriteLine(type+“做菜”);
                 }         
   class Test
   {
        static void Main(String [] args)
        {
               Kitchen kitchen1 =new Kitchen();
               kitchen1.work("厨师") ;
         }
    }                
                }

运行结果：
== 厨师做菜 ==

添加一个服务员的上菜流程，我们可以在Kitchen类中添加IF语句进行判断

class Kitchen{
               public void work(String type)
               {if("厨师".equals(type))
               {
			Console.WriteLine(type+"做菜");
		       }
	        	else if("服务员".equals(type))
			    {
			    Console.WriteLine(type+"上菜");
		        }                    
                 else
                          Console.WriteLine("输入错误");
                 }    

但上述代码不满足单一职责原则，如果根据单一职责原则，把厨房的工作分为两类，厨师做菜，服务员上菜，Kitchen类细分为BackKitchen和FrontKitchen类

class BackKitchen{
               public void work(String type)
               {
                          Console.WriteLine(type+"做菜");
                 }         
                 }
class FrontKitchen{
               public void work(String type)
               {
                          Console.WriteLine(type+"上菜");
                 }         
                   }
   class Test
   {
        static void Main(String [] args)
        {
               BackKitchen backkitchen1 =new BackKitchen();
               backkitchen1.work("厨师") ;
               Frontkitchen frontkitchen1=new FrontKitchen();
               frontkitchen1.work("服务员");
         }
    }                
                }

运行结果：
== 厨师做菜 ==
==服务员上菜 ==

遵循单一职责原的优点有：

• 可以降低类的复杂度，一个类只负责一项职责，其逻辑肯定要比负责多项职责简单的多；
  提高类的可读性，提高系统的可维护性；
• 变更引起的风险降低，变更是必然的，如果单一职责原则遵守的好，当修改一个功能时，可以显著降低对其他功能的影响。

2.开闭原则 – OCP（Open Close Principle）

对修改关闭，对扩展开放

根据开闭原则对程序进行修改，厨房(Kitchen)变成抽象基类，工作(work)变成抽象方法,使用抽象工厂模式，添加新功能时，直接增加新的工厂类。

Kitchen接口

public interface Kitchen
{
    public void work() { }
}

两个实现类

public class Kitchief : Kitchen
{

public void work()
{
    Console.WriteLine("厨师做菜");
}

    
}
public class Kitwaiter : Kitchen
{
  
public void work()
{
    Console.WriteLine("服务员上菜");
}
}

Factory接口

public interface Provider
{
    public Kitchen produce();
}

两个工厂类：

public class chiefFactory : Provider
{

    public Kitchen produce()
    {
        return new Kitchief();
    }
}
public class waiterFactory : Provider
{

    public Kitchen produce()
    {
        return new Kitwaiter();
    }
}

测试类

public class Test
{
    public static void Main(String[] args)
    {
        chiefFactory provider1 = new chiefFactory();
        Kitchen kitch1=provider1.produce();
        kitch1.work();
        waiterFactory provider2 = new waiterFactory();
        Kitchen kitch2 = provider2.produce();
        kitch2.work();
    }
}

运行结果：
== 厨师做菜 ==
== 服务员上菜 ==

如果需要增加一个流程（功能），只需要再写一个工厂类和实现类，而不用修改已经写好的类，满足了开闭原则对修改关闭，对扩展开放的基本思想。

参考资料

1. https://blog.csdn.net/eleanoryss/article/details/79555200?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-1
2. https://blog.csdn.net/llussize/article/details/80276627