在日常开发过程中时常需要用到设计模式，但是设计模式有23种，如何将这些设计模式了然于胸并且能在实际开发过程中应用得得心应手呢？和我一起跟着《Android源码设计模式解析与实战》一书边学边应用吧！
今天我们要讲的是面向对象的六大原则
单一职责原则
就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。
- 我们在App中往往会用到很多的公共方法，比如获取系统的时间，这个功能可能在App中的很多地方都要用到。这个时候我们一般会单独写个工具类TimeUtils，把处理时间有关的方法都放到这个类里面，这样就能减少重复代码，App的结构会更加清晰。当需要添加其他跟时间有关的方法时，就可以都加到这个TimeUtils类里面，这就是我们平时遵循的单一职责原则。
开闭原则
软件中的对象（类、模块、函数等），应该对于扩展是开放的，而对于修改是封闭的。
- 我们在软件开发过程中就要考虑到后续的扩展和修改。比如说，我们在开发一款类似于universal-image-loader的图片加载框架，可能一开始我们的功能比较简单，图片缓存只有内存缓存。当我们新版本需要添加SD卡缓存时，就要注意尽可能的减少对原来代码的修改，因为这样很可能会引入新的bug。而要做到开闭原则，一般有2种途径，一是通过继承原有的类；二是通过抽象和接口。后面我们会拿书中的图片加载框架来具体说明。
里氏替换原则
所有引用基类的地方必须能透明的使用其子类。通俗的说，就是只要父类能出现的地方子类就可以出现，而且替换为子类以后不会出现任何错误或异常。反过来就不行了，子类出现的地方父类不一定能适应。
- 要实现里氏替换原则，一般需要一个抽象的父类，父类中定义了子类的公共方法，子类继承或是实现父类以后扩展不同的功能，这样以来可以实现根据不同的需要来应用对应的子类，从而达到应用不同的功能的目的，程序的扩展性大大增强。同时这也体现了开闭原则，即当需要增加新功能时，只要继承或实现父类，实现新增的功能就达到了扩展的目的，而不是直接修改原来的代码，也即对扩展开放，对修改封闭。
依赖倒置原则
依赖倒置原则在Java中的表现就是：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。
- 一句话就是依赖抽象而不依赖具体的实现。比如上面我们说开发一个图片加载框架，那我们肯定会根据单一职责原则划分不同的模块，比如网络加载模块，图片缓存模块，以及主模块等。主模块肯定会调用图片缓存模块，如果我们调用的是图片缓存模块的具体实现，那么当我们修改图片模块时就很可能要对应修改主模块，这就是耦合了。一个比较好的做法是将图片缓存模块抽象出来，而主模块调用这个抽象即可，这样也就是依赖抽象了。
接口隔离原则
类间的依赖关系应该建立在最小的接口上。
- 接口隔离原则就是让客户端依赖的接口尽可能的小。就是在上面提到的依赖倒置（依赖抽象而不是实现）原则的基础上，增加一个最小化依赖的原则。说白了就是在依赖接口的基础上依赖尽可能少的接口。
- 这里举个例子：
<!--将图片写入SD卡-->
public void put(String url, Bitmap bitmap) {
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(SDPath url);
bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
}catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
CloseUtils.closeQuietly(fileOutputStream);
}
}
<!--关闭工具类-->
public final class CloseUtils {
private CloseUtils() { }
/**
* 关闭Closeable对象
* @param closeable
*/
public static void closeQuietly(Closeable closeable) {
if (null != closeable) {
try {
closeable.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 上述例子中的CloseUtils的closeQuietly方法的原理就是依赖于Closeable抽象而不是具体实现（依赖倒置原则），并且建立在最小化依赖的基础上，它只要知道这个对象是可以关闭的就行了，其他的一概不用关心，这就是接口隔离原则
迪米特原则
一个对象应该对其他的对象有最少的了解
- 通俗的讲，一个类应该对自己需要耦合或调用的类知道得最少，调用者或是依赖者只要知道它需要的方法即可。要做到这个原则，需要我们对各个模块之间的功能进行很好的区分和分配，把相互之间的依赖和耦合减到最少。
以上就是面向对象的六大原则。
下面我们通过书中的图片加载框架ImageLoader的例子介绍这些原则的具体应用。
- 首先是ImageLoader类
public class ImageLoader {
// 图片缓存，依赖接口，而不是具体实现
// 如果改为MemoryCache mImageCache = new MemoryCache();就不能定制图片缓存的实现，扩展性大大降低，耦合度也会大大提高
ImageCache mImageCache = new MemoryCache();
// 线程池，线程数量为CPU的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// 注入缓存,对扩展开放，对修改关闭
public void setImageCache(ImageCache cache) {
mImageCache = cache;
}
/**
* 显示图片
* @param imageUrl
* @param imageView
*/
public void displayImage(String imageUrl, ImageView imageView) {
Bitmap bitmap = mImageCache.get(imageUrl);
if (bitmap != null) {
imageView.setImageBitmap(bitmap);
return;
}
// 图片没有缓存，提交到线程池下载
submitLoadRequest(imageUrl, imageView);
}
/**
* 下载图片
* @param imageUrl
* @param imageView
*/
private void submitLoadRequest(final String imageUrl, final ImageView imageView) {
imageView.setTag(imageUrl);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(imageUrl);
if (bitmap == null) {
return;
}
if (imageUrl.equals(imageView.getTag())) {
imageView.setImageBitmap(bitmap);
}
mImageCache.put(imageUrl, bitmap);
}
});
}
/**
* 下载图片
* @param imageUrl
* @return
*/
private Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(connection.getInputStream());
connection.disconnect();
}catch (Exception e) {
e.printStackTrace();
}
return bitmap;
}
- 然后是图片缓存接口以及内存缓存
<!--图片缓存接口-->
public interface ImageCache {
public Bitmap get(String url);
public void put(String url, Bitmap bitmap);
}
<!--内存缓存的实现-->
public class MemoryCache implements ImageCache{
private LruCache<String, Bitmap> mMemoryCache;
public MemoryCache() {
//初始化LRU缓存
initImageCache();
}
private void initImageCache() {
// 计算可使用的最大内存
final int maxMemory = (int) (Runtime.getRuntime().maxMemory()/1024);
// 取四分之一的可用内存作为缓存
final int cacheSize = maxMemory / 4;
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
}
};
}
@Override
public Bitmap get(String url) {
return mMemoryCache.get(url);
}
@Override
public void put(String url, Bitmap bitmap) {
mMemoryCache.put(url, bitmap);
}
}
ImageLoader类中的逻辑比较直观，六大原则的体现主要在图片缓存的处理上。
- 将图片缓存单独出去而不是写在ImageLoader一起，体现了单一职责原则
- ImageLoader中依赖的是图片缓存的接口而不是具体的实现，体现了开闭原则、里氏替换原则和依赖倒置原则。
- ImageLoader类和MemoryCache类之间只依赖ImageCache接口，也可以说体现了接口隔离原则
- ImageLoader类只需要知道MemoryCache类的put方法和get方法，其他的实现一概不管，也体现了迪米特原则
