定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
也就是说，如果修改或者添加一个功能，应该是通过扩展原来的代码，而不是通过修改原来的代码。

比如，在图片加载类中，有内存缓存，磁盘缓存，还有双缓存：

//内存缓存
public class MemoryCache {

    LruCache<String, Bitmap> mLruCache;

    public MemoryCache() {
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        int cacheSize = maxMemory / 4;
        mLruCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    public Bitmap get(String url) {
        return return mLruCache.get(url);
    }

    public void put(String url, Bitmap bmp) {
        // do something
    }
}

//磁盘缓存
public class DiskCache {
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(url);
    }

    public void put(String url, Bitmap bmp) {
       //do something
    }
}

//双缓存
public class DoubleCache {
    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();

    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap==null){
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }

    public void put(String url, Bitmap bmp) {
        //do something
    }
}

如果不用开闭原则，那么在图片加载类中，可能会这么写：

public class ImageLoader {

    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();
    DoubleCache mDoubleCache = new DoubleCache();

    boolean isDiskCache = false; //使用磁盘缓存
    boolean isDoubleCache = false; //使用双缓存

    public ImageLoader() {
    }

    public void displayImage(String url, ImageView mImageView) {
        Bitmap bitmap = null;
        if (isDoubleCache) {
            bitmap = mDoubleCache.get(url);
        } else if (isDiskCache) {
            bitmap = mDiskCache.get(url);
        } else {
            bitmap = mMemoryCache.get(url);
        }
        if (bitmap != null) {
            mImageView.setImageBitmap(bitmap);
        } else {
            //没有缓存，下载图片
        }
    }

    public void setDiskCache(boolean diskCache) {
        isDiskCache = diskCache;
    }

    public void setDoubleCache(boolean doubleCache) {
        isDoubleCache = doubleCache;
    }
}

这样写，可能会出现这样的问题：
if-else 的判断条件太多，如果写错了其中一个，就会化很多时间去查找和解决，ImageLoader 类也会变得臃肿，而且用户不能自己实现缓存注入到 ImageLoader 中，可扩展性差。

那么，通过分析可以知道，每个缓存都用 set 和 put 方法，那么可以把它抽象出来。
UML图：

UML

这样通过接口就可以实现不同的缓存，而且不需要改变 ImageLoader 的代码。

首先创建接口 ImageCache：

public interface ImageCache {
    void put(String url, Bitmap bmp);
    Bitmap get(String url);
}

然后将原来的三种缓存都继承它：

//内存缓存
public class MemoryCache implements ImageCache {

    LruCache<String, Bitmap> mLruCache;

    public MemoryCache() {
        //初始化LruCache
    }

    @Override
    public void put(String url, Bitmap bmp) {
        mLruCache.put(url, bmp);
    }

    @Override
    public Bitmap get(String url) {
        return mLruCache.get(url);
    }
}

//磁盘缓存
public class DiskCache implements ImageCache{

    @Override
    public void put(String url, Bitmap bmp) {
        //将Bitmap写入文件
    }

    @Override
    public Bitmap get(String url) {
       return BitmapFactory.decodeFile(url); //从文件中获取Bitmap
    }
}

//双缓存
public class DoubleCache implements ImageCache {
    ImageCache mMemoryCache = new MemoryCache();
    ImageCache mDiskCache = new DiskCache();

    @Override
    public void put(String url, Bitmap bmp) {
        mMemoryCache.put(url, bmp);
        mDiskCache.put(url, bmp);
    }

    @Override
    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);
        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }
}

那么，ImageLoader 类就可以改写成：

public class ImageLoader {

    ImageCache mImageCache = new MemoryCache();

    public void setImageCache(ImageCache imageCache) {
        mImageCache = imageCache;
    }

    public ImageLoader() {
    }

    public void displayImage(String url, ImageView mImageView) {
        Bitmap bitmap = mImageCache.get(url);
        if (bitmap != null) {
            mImageView.setImageBitmap(bitmap);
        }
        //图片没缓存，下载
        // do something
    }
}

比原来的简洁很多。

那么在使用的时候这样：

ImageLoader imageLoader = new ImageLoader();
//选择使用内存缓存
imageLoader.setImageCache(new MemoryCache());
//选择使用磁盘缓存
imageLoader.setImageCache(new DiskCache());
//选择使用双缓存
imageLoader.setImageCache(new DoubleCache());
//不选择封装好的缓存，自己实现缓存
imageLoader.setImageCache(new ImageCache() {
    @Override
    public void put(String url, Bitmap bmp) {

    }

    @Override
    public Bitmap get(String url) {
        return null;
    }
});

可以看到，用户通过 setImageCache 方法可以自由设置缓存的实现方式，而不用通过修改 ImageLoader 来实现。setImageCache 就是通常说的依赖注入。使得 ImageLoader 类更加健壮，这就是开闭原则。

这里，应该明白开闭原则是怎么一回事了。

参考：《Android源码设计模式解析与实践》