面向对象六大原则之单一职责原则

          单一职责原则的英文名称是Single Responsibility Principle，缩写是SRP。SRP的定义是：就一个类而言，应该仅有一个引起它变化的原因。简单地说，一个类中应该是一种相关性很高的函数，数据的封装。
     首先我们先来看一下不用单一职责原则实现图片加载的代码：

 public class ImageLoader{
//图片缓存
 LruCache<String,Bitmap> mImageCache;
//线程池，线程池的数量为cpu的数量
 ExecutorService mExecutorService=Executors.newFixedThreadPool (Runtime.getRuntime().availableProcessors());
public ImageLoader(){
 initImageCache();
 }
private void initImageCache(){
//计算可使用的最大内存
final int maxMemory=(int) (Runtime.getRuntime().maxMemory() /1024);
final int cacheSize=maxMemory/4;
 mImageCache =new LruCache<String key,Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key,Bitmap bitmap) {
return bitmap.getRowBytes()*bitmap.getHeightBites() / 1024;
 }
 };
 }
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.setTag().equals(url){
 imageView.setImageBitmap(bitmap);
 }
 mImageCache.put(url,bitmap);
 }
 });
}
public Bitmap downloadImage(String imageUrl) {
 Bitmap bitmap=null;
try{
 URL url=new URL(imageUrl);
final HttpURLConnection conn =(HttpURLConnection) url.openConnection();
 bitmap=BitmapFactory.decodeStream(conn.getInputStream());
 conn.disconnect();
 }catch(Exception e) {
 e.printStackTrace();
 }
return bitmap;
 }
} 

聪明的你一定发现了，上述代码在不用单一职责原则的情况下耦合性太严重了，简直就没有设计可言，更不要说扩展性，灵活性了。
接下来我们来看看运用单一职责原则实现上述的代码是怎样的
首先定义一个图片加载类

 public class ImageLoader{
//图片缓存
 ImageCacher mImageCache=new ImageCache();
//线程池，线程数量为CPU的数量
 ExcutorService mExcutorService=Excutors.newFixedThreadPool
 (Runtime.getRuntime().availableProcessors());
//加载图片
public void displayImage(final String url,final ImageView imageview){
 Bitmap bitmap=mImageCache.get(url);
if(bitmap!=null){
 imageView.setImageBitmap(bitmap);
return;
 }
 imageView.setTag(url);
 mExecutorService.submit(new Runtime(){
@Override
public void run(){
 Bitmap bitmap=downloadImage(url);
if(bitmap==null) {
return; 
 }
if(imageView.getTag().equals(url)){
 imageView.setImageBitmap(bitmap);
 }
 mImageCache.put(url,bitmap);
 }
 });
}
public Bitmap downloadImage(String imageUrl) {
 Bitmap bitmap=null;
try{
 Url url=new Url(ImageUrl);
final HttpURLConnection conn=(HttpURLConnection) url.openConnection();
 bitmap= BitmapFactory.decodeStream(conn.getInputStream());
 conn.disconnect();
 }catch (Exception e){
 e.printStackTrace();
 }
return bitmap;
 }
}

然后再添加一个ImageCache类用于处理图片缓存，具体代码如下所示

 public class ImageCache{
 LruCache<String,Bitmap> mImageCache;
public ImageCache() {
 initImageCache();
 }
private void initImageCache() {
//计算可使用的最大内存
final int maxMemory=(int) (Runtime.getRuntime().maxMemory()/1024);
//取四分之一的可用内存作为缓存
final int cacheSize=maxMemory /4;
 mImageCache = new LruCache<String,Bitmap>(cacheSize){
@Override
protected int sizeOf(String key,Bitmap bitmap){
return bitmap.getRowBytes()*bitmap.getHeightBytes()/1024;
 }
 };
}
public void get(String url) {
return mImageCache.get(url);
 }
}

 相信从上述例子中我们都能够体会，单一职责所表达出的用意就是“单一”二字。工程师可以不断审视自己的代码，根据具体的业务，功能对类进行相应的拆分，这是程序员优化代码迈出的第一步。