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

1.简称

单一职责原则的英文名称是Single Responsibility Principle， 简称RSP。

2.定义

就一个类而言，应该仅有一个引起它变化的原因，简单的说，一个类中应该是一组相关性很高的函数、数据的封装。即一个类只负责一项职责，而不应该同时负责多个职责。

3.问题

比如C类负责两个不同的职责D1和D2。D1功能需求发生变化时，更改C类，有可能使原本正常运行的D2发生错误,代码耦合性太高，较复杂。

4.解决

把功能独立出来，让它们满足单一职责原则。比如创建两个类C1和C2,C1完成功能D1, C2完成功能D2.任何一个功能出现问题都不会造成另一个功能出问题。
举例:

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, Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes()* bitmap.getHeight() /1024;
            }
        };
    }

    private 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);
                }

                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;
    }
}

这个图片加载类，将图片的缓存即加载全部放在一个类里，耦合性太高，随着功能的增加，ImageLoader的代码就会越来越多，不便于扩展，灵活性查。
进行如下拆分：

public class ImageLoader {
    ImageCache mImageCache =new ImageCache();//图片缓存
    //线程池 线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
   
    private 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 Runnable() {
            @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;
    }
}


public class ImageCache {
    LruCache<String,Bitmap> mImageCache;//图片LRU缓存
    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.getHeight() /1024;
            }
        };
    }

    public void put(String url,Bitmap bitmap){
        mImageCache.put(url,bitmap);
    }

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

ImageLoader只负责图片的加载逻辑，ImageCache只负责处理图片的缓存，当与缓存相关的逻辑需要改变时，不需要修改ImageLoader类，而图片的加载逻辑需要修改时，也不会影响到缓存的逻辑。结构变得清晰，当扩展性还比较欠缺，这节我们只了解单一原则，后面再说如何使程序更灵活。

5 总结：

单一原则的优点：
（1）减低类的复杂度，一个类只负责一项职责了，其业务逻辑自然就变简单了。
（2）降低类的耦合度，减少需求更改带来的风险
（3）提高可读性