Interface Isolation Principle（接口隔离原则）

（一）接口隔离原则定义

接口隔离原则和单一职责都是为了提高类内进行，降低他们之间的耦合性，体现了封装的思想。

（1）单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。

（2）单一职责原则主要约束类，它针对的是程序中的实现和细节，接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。

（二）接口隔离原则优点

1. 将复杂庞大的接口分解成众多个小接口，从而降低了类对接口的依赖性，提高系统的灵活性和可维护性。
2. 接口隔离 提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
3. 接口的粒度大小是否定义合理，决定了系统的稳定性，如粒度过多则使程序复杂化（例如：5句代码可以编写一个小功能，而却用了10句代码），过大则降低灵活性（例如：20世纪60,70年代的计算机很庞大，很难移动，而现在的21世纪的计算机很小，很轻薄，很方便移动，从而提高了它的灵活性）

（三）接口隔离原则实现

1. 一个接口只服务于一个子模块或者业务逻辑。
2. 为依赖接口类制定服务，提供调用者需要的方法，屏蔽不需要的方法。
3. 提高内聚，减少对外交互。

由上图可知，总经理为高端管理层，部门经理为中端管理层，部门主管为低端管理层，再者加上还有一个员工管理层，总经理可以增删改查员工的权限，部门经理只有统计和发布任务的权限，部门主管只有执行和反馈的权限等等。

（四）代码案例解析

using System;

namespace Design_Pattern
{
    class Program
    {
        static void Main(string[] args)
        {
            General generals = WYN.GetGeneral();
            Manager managers = WYN.GetManager();
            Executive executives = WYN.GetExecutive();

            generals.add();
            generals.delete();
            generals.update();
            generals.select();

            managers.count();
            managers.Release();

            executives.implement();
            executives.feedback();
        }

        /// <summary>
        /// 总经理接口
        /// </summary>
        public interface General
        {
            /// <summary>
            /// 总经理：添加方法
            /// </summary>
            void add();

            /// <summary>
            /// 总经理：删除方法
            /// </summary>
            void delete();

            /// <summary>
            /// 总经理：修改方法
            /// </summary>
            void update();

            /// <summary>
            /// 总经理：查看方法
            /// </summary>
            void select();
        }

        /// <summary>
        /// 经理接口
        /// </summary>
        public interface Manager
        {
            /// <summary>
            /// 经理：统计方法
            /// </summary>
            void count();

            /// <summary>
            /// 经理：发布方法
            /// </summary>
            void Release();
        }

        /// <summary>
        /// 主管接口
        /// </summary>
        public interface Executive
        {
            /// <summary>
            /// 主管：执行力方法
            /// </summary>
            void implement();

            /// <summary>
            /// 主管：反馈方法
            /// </summary>
            void feedback();
        }

        class WYN : General,Manager,Executive
        {
            private WYN()
            {

            }

            public static General GetGeneral()
            {
                return (General)new WYN();
            }

            public static Manager GetManager()
            {
                return (Manager)new WYN();
            }

            public static Executive GetExecutive()
            {
                return (Executive)new WYN();
            }

            public void add()
            {
                Console.WriteLine("总经理的添加方法！");
            }

            public void delete()
            {
                Console.WriteLine("总经理的删除方法！");
            }

            public void update()
            {
                Console.WriteLine("总经理的修改方法！");
            }

            public void select()
            {
                Console.WriteLine("总经理的查看方法！");
            }

            public void count()
            {
                Console.WriteLine("部门经理的统计方法！");
            }

            public void Release()
            {
                Console.WriteLine("部门经理的分布任务方法！");
            }

            public void implement()
            {
                Console.WriteLine("部门主管的执行力方法！");
            }

            public void feedback()
            {
                Console.WriteLine("部门主管的反馈方法！");
            }
        }
    }
}

总结：为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。