zoukankan      html  css  js  c++  java
  • 设计模式之迪米特法则

      What

      Least Konwledge Principle(LCP):最少知识原则,一个对象应该对其他的对象了解的最少。

      Why

      降低系统的耦合度,使类与类之间保持松散的耦合关系。

      How

      员工类

        class Employee
        {
            private string name;
    
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
        }

      老板类

       class Boss
        {
            private List<Employee> employees;
    
            public List<Employee> Employees
            {
                get { return employees; }
                set { employees = value; }
            }
    
            //将消息通知到各个员工
            public void Notify(string message)
            {
                foreach (var item in Employees)
                {
                    Console.WriteLine(item.Name + message);
                }
            }
        }

      客户端调用

        class Program
        {
            static void Main(string[] args)
            {
                Boss boss = new Boss();
                boss.Employees = new List<Employee>();
                boss.Employees.Add(new Employee() { Name = "张三" });
                boss.Employees.Add(new Employee() { Name = "李四" });
    
                boss.Notify("放假一天观看世界杯决赛");
    
                Console.ReadLine();
            }
        }

      需求是完成了,但是我们来细想一下其中类之间的关系。对于Boss类来说,他需要知道所有员工,并且如果有消息的话,需要一个一个通知员工,对于规模不大的公司可能这样的是可行的,但是如果是大规模的公司,这样明显是不合适的,老板不需要知道每一个员工,老板是要做出决定,通知这种事情应该是由行政部门来协调。Boss知道了他不需要知道的事情,承担了他没有必要承担的职责,这样一个类的职责过重,也增加了类之间的耦合性,我们软件设计的目标是高耦合、低内聚。那么现实中,老板是有秘书的,一般是由秘书来完成这些工作,那么我们这里就新增一个秘书类,目前,秘书的职责是将老板宣布的消息通知相关人员(需求以后可能会改,可能增加了各个部门,通知部门等等,但我们不需要过度设计,而是当发生了小变化的时候及时做出改变)。

      秘书类

       class Secretary : Employee
        {
            private List<Employee> employees;
    
            public List<Employee> Employees
            {
                get { return employees; }
                set { employees = value; }
            }
    
            //将消息通知到各个员工
            public void Notify(string message)
            {
                foreach (var item in Employees)
                {
                    Console.WriteLine(item.Name + message);
                }
            }
        }

      老板类

       class Boss
        {
            private Secretary bossSecretary;
    
            public Secretary BossSecretary
            {
                get { return bossSecretary; }
                set { bossSecretary = value; }
            }
    
            public void AnnounceMessage(string message)
            {
                if (BossSecretary != null)
                {
                    BossSecretary.Notify(message);
                }
            }
        }

    客户端调用

        class Program
        {
            static void Main(string[] args)
            {
                Boss boss = new Boss();
                Secretary secretary = new Secretary() { Name = "小丽" };
    
                secretary.Employees = new List<Employee>();
                secretary.Employees.Add(new Employee() { Name = "张三" });
                secretary.Employees.Add(new Employee() { Name = "李四" });
                secretary.Employees.Add((Employee)secretary);
    
                boss.BossSecretary = secretary;
                boss.AnnounceMessage("放假一天观看世界杯决赛");
    
                Console.ReadLine();
            }
        }

      这样的改变之后,类之间的结构就更加的清晰和稳定,达到了松耦合的效果,Boss类与Employee类现在比较松散,在设想以后成立了新的部门的时候,我们也只需要对秘书类进行相应的处理,而Boss类是相对来说比较稳定的,

  • 相关阅读:
    Linux学习笔记(八)权限管理命令
    Linux学习笔记(七)关机、重启及常用的网络命令
    Linux学习笔记(六)压缩和解压缩命令
    Linux学习笔记(五)搜索命令
    Linux学习笔记(四)帮助命令
    Linux学习笔记(三)目录和文件都能操作的命令
    Linux学习笔记(二)文件操作命令
    Linux学习笔记(一)目录处理命令
    面试题((A)null).fun()——java中null值的强转
    idea注册码
  • 原文地址:https://www.cnblogs.com/XzcBlog/p/4193463.html
Copyright © 2011-2022 走看看