学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下
在开发中，我们要注意程序设计的六大原则：
一、单一责任原则
二、开闭原则
三、里氏替换原则
四、依赖倒置原则
五、接口隔离原则
六、迪米特原则
什么是单一原则
单一原则的意思就是就一个类而言，它需要做的事情就一件，这一件事可以是拆分的很细的一件事（如：一台电脑，显示器就是显示用的，键盘就是打字用的，usb接口就是连接用的等等，有些人就把电脑整体理解成一台上网的机器，各有各的理解），单一原则的划分不是很清晰，一般都是看个人的理解来界定。
我们用一个简单图片加载器程序来说明单一原则的使用，需求是这样，我们要一个图片加载器，而且还能将图片缓存起来的，以此需求，我们写一个ImageLoader类
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.LruCache;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageLoader {
public ImageLoader() {
//初始化图片缓存
initImageCache();
}
//图片缓存类
LruCache<String, Bitmap> imageCache;
//线程池，线城数量为cpu的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
* 初始化缓存
*/
private void initImageCache() {
//计算可使用的最大内存
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//只用最大内存的四分之一作为缓存大小
int cacheSize = maxMemory / 4;
imageCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
/**
* 显示图片
* @param url 图片的url
* @param imageView 要显示的view
*/
public void displayImage(final String url, final ImageView imageView) {
imageView.setTag(url);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(url);
if (bitmap == null) {
return;
}
if (imageView.getTag().equals(url)) {
imageView.setImageBitmap(bitmap);
}
imageCache.put(url, bitmap);
}
});
}
/**
* 下載圖片
* @param imageUrl 网络图片地址
* @return 返回bitmap对象
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
可以看到，虽然上面的加载器已经实现了图片的加载以及缓存到内存的功能，但是有一个很明显的问题，所有东西都堆在了这个ImageLoader类里面了，耦合太严重，一点扩展性跟灵活性都没有，以后随着功能的增加，这个类会变的越来越大、臃肿，依照单一原则，把ImageLoader拆分一下，将功能独立出来
修改ImageLoader
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.LruCache;
import android.widget.ImageView;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageLoader {
public ImageLoader() {
}
//图片缓存类
ImageCache imageCache=new ImageCache();
//线程池，线城数量为cpu的数量
ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
/**
* 显示图片
* @param url 图片的url
* @param imageView 要显示的view
*/
public void displayImage(final String url, final ImageView imageView) {
Bitmap bitmap=imageCache.get(url);
if(bitmap!=null){
imageView.setImageBitmap(bitmap);
return;
}
imageView.setTag(url);
mExecutorService.submit(new Runnable() {
@Override
public void run() {
Bitmap bitmap = downloadImage(url);
if (bitmap == null) {
return;
}
if (imageView.getTag().equals(url)) {
imageView.setImageBitmap(bitmap);
}
imageCache.put(url, bitmap);
}
});
}
/**
* 下載圖片
* @param imageUrl 网络图片地址
* @return 返回bitmap对象
*/
public Bitmap downloadImage(String imageUrl) {
Bitmap bitmap = null;
try {
URL url = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
}
import android.graphics.Bitmap;
import android.util.LruCache;
/**
* Created by Administrator on 2016/3/1.
*/
public class ImageCache {
public ImageCache() {
//初始化图片缓存
initImageCache();
}
//图片缓存类
LruCache<String, Bitmap> imageCache;
/**
* 初始化缓存
*/
private void initImageCache() {
//计算可使用的最大内存
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
//只用最大内存的四分之一作为缓存大小
int cacheSize = maxMemory / 4;
imageCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight() / 1024;
}
};
}
/**
* 添加缓存
*
* @param url 缓存的图片url作为缓存的key
* @param bitmap 缓存的bitmap
*/
public void put(String url, Bitmap bitmap) {
imageCache.put(url, bitmap);
}
/**
* 获取缓存的图片
*
* @param url
* @return
*/
public Bitmap get(String url) {
Bitmap bitmap = null;
bitmap = imageCache.get(url);
return bitmap;
}
}
经过拆分之后，ImageLoader只负责图片的加载逻辑，而ImageCache负责图片的缓存逻辑，这样ImageLoader的代码量也就少了，而且职责也变的清晰，以后要修改缓存的逻辑就不需要去动ImageLoader类了，同样，修改图片加载的逻辑，也不需要动ImageCache类。
以上只是对单一原则的一个解释，因为单一原则不是定死的，每个人对一个职责的认定是不同的，这个要根据个人的经验以及具体的业务逻辑来定。