码迷,mamicode.com
首页 > 其他好文 > 详细

迪米特法则

时间:2014-12-30 15:03:55      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:

  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类是相对来说比较稳定的,

迪米特法则

标签:

原文地址:http://www.cnblogs.com/XzcBlog/p/4193463.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!