迪米特法则

定义：迪米特法则又叫最少知识原则，指一个对象应对其他对象有尽可能少的了解，也就是说，一个模块或对象应尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立，这样当一个模块修改时，影响的模块就会越少，扩展起来更加容易。

自己理解：就是说类之间联系减少、降低耦合。

实例：

有个总公司，下面有一个分公司，现在要查询总公司分公司的员工id

 /// <summary>
    /// 总公司员工
    /// </summary>
    class Employee
    {
        public string id;
        public String ID
        {
            get { return id; }
            set { id = value; }
        }
    }
    /// <summary>
    /// 分公司员工
    /// </summary>
    class SubEmployee
    {
        private string id;
        public string ID
        {
            get { return id; }
            set { id = value; }
        }
    }

    /// <summary>
    /// 总公司管理员工
    /// </summary>
    class Commanymanager
    {
        public List<Employee> GetEmployee()
        {
            List<Employee> list = new List<Employee>();
            for (int i = 1; i < 10; i++)
            {
                Employee emp = new Employee();
                emp.ID = "总公司" + i;
                list.Add(emp);
            }
            return list;
        }

        public void pintAllEmppyee(Subcommanymanag sub)
        {
            sub.Shuchu();
            List<Employee> list = this.GetEmployee();
            foreach (var item in list)
            {
                Console.WriteLine(item.ID);
            }
        }
    }

    /// <summary>
    /// 分公司管理员工
    /// </summary>
    class Subcommanymanag
    {
        public List<SubEmployee> GetSubCommany()
        {
            List<SubEmployee> list = new List<SubEmployee>();
            for (int i = 1; i < 20; i++)
            {
                SubEmployee sub = new SubEmployee();
                sub.ID = "分公司" + i;
                list.Add(sub);
            }
            return list;
        }
        public void Shuchu()
        {
            List<SubEmployee> list = GetSubCommany();
            foreach (var item in list)
            {
                Console.WriteLine(item.ID);
            }
        }

    }

客户端：

Commanymanager comanger = new Commanymanager();
            comanger.pintAllEmppyee(new Subcommanymanag());
            Console.Read();

这样打印的话，就可以打印出总公司和分公司员工的ID

依赖倒置原则：抽象不应该依赖细节，也就是“面向接口编程”，而不是面向实现编程。

接口隔离原则：多个专门的接口要比一个单一的总接口要好，也就是说不要让一个单一的接口承担过多的职责。

总结：迪米特法则、依赖倒置、接口隔离这些原则应该都是比较好理解的，用的时候就要多考虑这些。

最近突发奇想：想写一个贪吃蛇的游戏：

定义类：

1.墙类

1.1显示墙得方法、属性

2.食物类

2.1显示食物的方法

2.2实现食物随机出现的方法

3.蛇

3.1显示蛇的方法/可以改变位置

3.2蛇运动的方法

3.2.1蛇是否吃到食物

3.2.2蛇是否撞墙

3.2.3蛇是否吃到自己

3.2.4蛇通关

键盘操作蛇运动