如何提高代码的扩展性

public class Rectangle {    private double length;    private double height;     // getters/setters ... }
public class AreaManager {    public double calculateArea(ArrayList<Rectangle>... shapes) {        double area = 0;        for (Rectangle rect : shapes) {            area += (rect.getLength() * rect.getHeight());         }        return area;    }}
AreaManager类现在运行良好，直到几周之后，我们又有一种新的形状——圆形：public class Circle {    private double radius;     // getters/setters ...}
由于有新的形状需要考虑，我们必须修改我们的AreaManager类：public class AreaManager {    public double calculateArea(ArrayList<Object>... shapes) {        double area = 0;        for (Object shape : shapes) {            if (shape instanceof Rectangle) {                Rectangle rect = (Rectangle)shape;                area += (rect.getLength() * rect.getHeight());                            } else if (shape instanceof Circle) {                Circle circle = (Circle)shape;                area += (circle.getRadius() * cirlce.getRadius() * Math.PI;            } else {                throw new RuntimeException("Shape not supported");            }                    }        return area;    }}
从这段代码开始，我们察觉到了问题。如果我们遇到一个三角形，或者其他形状呢，这时候我们就必须一次又一次的修改AreaManager类。这个类的设计就违背了开闭原则，没有做到对修改的封闭性以及对扩展的开放性。我们必须避免这种事情的发生~基于继承的开闭原则的实现AreaManager类的职责是计算各种形状的面积，而每一种形状都有其独特的计算面积的方法，因此将面积的计算放入到各个形状类中是特别合理的。AreaManager类仍然需要知道所有的形状，否则它就无法判断所有的形状类是否都包含了计算面积的方法。当然了，我们可以通过反射来实现。其实有一种更简单的方式也可以实现——让所有的形状类都继承一个接口：Shape（也可以是抽象类）public interface Shape {    double getArea(); }
每一个形状类都实现这个接口（如果接口无法满足你的需求，也可以通过继承某个抽象类）：public class Rectangle implements Shape {   private double length;   private double height;    // getters/setters ... 
   @Override   public double getArea() {       return (length * height);   }}
public class Circle implements Shape {   private double radius;    // getters/setters ...
   @Override   public double getArea() {       return (radius * radius * Math.PI);   }}
现在，我们可以通过这个抽象方法将AreaManager构造成一个符合开闭原则的类。public class AreaManager {    public double calculateArea(ArrayList<Shape> shapes) {        double area = 0;        for (Shape shape : shapes) {            area += shape.getArea();        }        return area;    }}
通过这种方式， AreaManager类符合了对修改关闭，对扩展开放的要求。如果我们需要增加一种新形状，比如：八边形。新的类只需要继承Shape接口即可，AreaManager根本不需要做任何的修改。

作者：4d3bf4cac28c链接：https://www.jianshu.com/p/6c8a9611b38b来源：简书著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、场景示例下面就以我们传统行业的订单操作为例来说明下接口隔离的必要性。1、胖接口软件设计最初，我们的想法是相同功能的方法放在同一个接口里面，如下，所有订单的操作都放在订单接口IOrder里面。理论上来说，这貌似没错。我们来看看如何设计。
 　　public interface IOrder    {        //订单申请操作        void Apply(object order);
        //订单审核操作        void Approve(object order);
        //订单结束操作        void End(object order);
    }
刚开始只有销售订单，我们只需要实现这个接口就好了。
    public class SaleOrder:IOrder    {        public void Apply(object order)        {            throw new NotImplementedException();        }
        public void Approve(object order)        {            throw new NotImplementedException();        }
        public void End(object order)        {            throw new NotImplementedException();        }    }
后来，随着系统的不断扩展，我们需要加入生产订单，生产订单也有一些单独的接口方法，比如：排产、冻结、导入、导出等操作。于是我们向订单的接口里面继续加入这些方法。于是订单的接口变成这样：
    public interface IOrder    {        //订单申请操作        void Apply(object order);
        //订单审核操作        void Approve(object order);
        //订单结束操作        void End(object order);
        //订单下发操作        void PlantProduct(object order);
　　　　 //订单冻结操作        void Hold(object order);
        //订单删除操作        void Delete(object order);
        //订单导入操作        void Import();
        //订单导出操作        void Export();    }
我们生产订单的实现类如下
    //生产订单实现类    public class ProduceOrder : IOrder    {        /// <summary>        /// 对于生产订单来说无用的接口        /// </summary>        /// <param name="order"></param>        public void Apply(object order)        {            throw new NotImplementedException();        }
        /// <summary>        /// 对于生产订单来说无用的接口        /// </summary>        /// <param name="order"></param>        public void Approve(object order)        {            throw new NotImplementedException();        }
        /// <summary>        /// 对于生产订单来说无用的接口        /// </summary>        /// <param name="order"></param>        public void End(object order)        {            throw new NotImplementedException();        }
        public void PlantProduct(object order)        {            Console.WriteLine("订单下发排产");        }
　　　　 public void Hold(object order)        {            Console.WriteLine("订单冻结");        }
        public void Delete(object order)        {            Console.WriteLine("订单删除");        }
        public void Import()        {            Console.WriteLine("订单导入");        }
        public void Export()        {            Console.WriteLine("订单导出");        }    }
销售订单的实现类也要相应做修改
    //销售订单实现类    public class SaleOrder:IOrder    {        public void Apply(object order)        {            Console.WriteLine("订单申请");        }
        public void Approve(object order)        {            Console.WriteLine("订单审核处理");        }
        public void End(object order)        {            Console.WriteLine("订单结束");        }
        #region 对于销售订单无用的接口方法        public void PlantProduct(object order)        {            throw new NotImplementedException();        }
　　　　 public void Hold(object order)        {            throw new NotImplementedException();        }
        public void Delete(object order)        {            throw new NotImplementedException();        }
        public void Import()        {            throw new NotImplementedException();        }
        public void Export()        {            throw new NotImplementedException();        }         #endregion    }
需求做完了，上线正常运行。貌似问题也不大。系统运行一段时间之后，新的需求变更来了，要求生成订单需要一个订单撤销排产的功能，那么我们的接口是不是就得增加一个订单撤排的接口方法CancelProduct。于是乎接口变成这样：
public interface IOrder    {        //订单申请操作        void Apply(object order);
        //订单审核操作        void Approve(object order);
        //订单结束操作        void End(object order);
        //订单下发操作        void PlantProduct(object order);
        //订单撤排操作        void CancelProduct(object order);
        //订单冻结操作        void Hold(object order);
        //订单删除操作        void Delete(object order);
        //订单导入操作        void Import();
        //订单导出操作        void Export();    }
这个时候问题就来了，我们的生产订单只要实现这个撤销的接口貌似就OK了，但是我们的销售订单呢，本来销售订单这一块我们不想做任何的变更，可是由于我们IOrder接口里面增加了一个方法，销售订单的实现类是不是也必须要实现一个无效的接口方法？这就是我们常说的“胖接口”导致的问题。由于接口过“胖”，每一个实现类依赖了它们不需要的接口，使得层与层之间的耦合度增加，结果导致了不需要的接口发生变化时，实现类也不得不相应的发生改变。这里就凸显了我们接口隔离原则的必要性，下面我们就来看看如何通过接口隔离来解决上述问题。2、接口隔离我们将IOrder接口分成两个接口来设计
    //删除订单接口    public interface IProductOrder    {        //订单下发操作        void PlantProduct(object order);
        //订单撤排操作        void CancelProduct(object order);
        //订单冻结操作        void Hold(object order);
        //订单删除操作        void Delete(object order);
        //订单导入操作        void Import();
        //订单导出操作        void Export();    }
    //销售订单接口    public interface ISaleOrder    {        //订单申请操作        void Apply(object order);
        //订单审核操作        void Approve(object order);
        //订单结束操作        void End(object order);    }
对应的实现类只需要实现自己需要的接口即可
    //生产订单实现类    public class ProduceOrder : IProductOrder    {        public void PlantProduct(object order)        {            Console.WriteLine("订单下发排产");        }
        public void CancelProduct(object order)        {            Console.WriteLine("订单撤排");        }
        public void Hold(object order)        {            Console.WriteLine("订单冻结");        }
        public void Delete(object order)        {            Console.WriteLine("订单删除");        }
        public void Import()        {            Console.WriteLine("订单导入");        }
        public void Export()        {            Console.WriteLine("订单导出");        }    }
    //销售订单实现类    public class SaleOrder : ISaleOrder    {
        public void Apply(object order)        {            Console.WriteLine("订单申请");        }
        public void Approve(object order)        {            Console.WriteLine("订单审核处理");        }
        public void End(object order)        {            Console.WriteLine("订单结束");        }    }