1.

需求： 一个人有多种回家方式：火车、飞机。

    public class Person
    {
        public void GoHome(string type)
        {
            switch (type) 
            {
                case "火车":
                    break;
                case "飞机":
                    break;
            }
        }
    }
        static void Main()
        {
            Person person1 = new Person();
            person1.GoHome("飞机");
        }

类图

2 .

• 需求：火车、飞机的回家方式不满足，需增加汽车的回家方式。
  方式1：修改原Person中代码

    public class Person
    {
        public void GoHome(string type)
        {
            switch (type) 
            {
                case "火车":
                    break;
                case "飞机":
                    break;
                case "汽车":
                    break;
            }
        }
    }
        static void Main()
        {
            Person person1 = new Person();
            //person1.GoHome("飞机");
            person1.GoHome("汽车");
        }

• 方式2：为了实现交通方式改变，不对Person类进行修改，需重新设计类结构，将交通方式抽象出来，调用具体的交通方式同样不满足开闭原则，就需要将所有的交通方式抽象化，为达到这一要求，必须调用抽象组件，及下面所说的依赖倒置原则。
  使用方式2，及时需求变化，要添加更多的交通方式，也只需要增加继承自Transportation的类就可以了。及需求变化哪（交通方式变化），就只改哪（增加新的交通模块），不波及无辜（Person）。
  依赖倒置（依赖抽象）：
  客户端代码(调用的类)尽量依赖(使用)抽象的组件。
  抽象的是稳定的。实现是多变的。

    public abstract class Transportation
    {
        public abstract void Transport();
    }
    public class Train : Transportation
    {
        public override void Transport()
        {
            //具体实现
        }
    }
//其余交通方式依次类推

    public class Person
    {
        //方法2
        public void GoHome(Transportation transport)
        {
            transport.Transport();
        }
    }

        static void Main()
        {
            Person person1 = new Person();
            //乘坐火车回家，在此处无论更换哪种乘坐方式，都不会影响到Person类，只是对交通方式模块的调用。
            person1.GoHome(new Train());
        }

类图

• 分析：
  变化点为回家方式，将变化点拿出来单独做类，每个回家方式做一个类。为了满足交通方式的变化，实现时需依赖抽象，即依赖倒置（依赖抽象）。
  而方式1不符合开闭原则：
  开闭原则：对扩展开放，对修改关闭。
  增加新功能，不改变原有代码。