浅析面对对象 六大原则（一）

面对对象，作为使用JAVA进行开发的我，在刚开始接触这个新名词的时候，第一感觉就是，什么鬼？？？ 但是随着对面对对象的了解，渐渐知道了以前的自己对于开发都是面向过程，虽然在开始接触JAVA时，就接触过这个名词，但是根本就没又去好好的了解，所以在开发的过程中，经常碰到牵一发而动全身的情况，修改更新起来相当麻烦，然后就重新回去看了相关的文章和书籍，在这里做个简单的剖析。

PS：此系列文章主要以Android代码讲解

1.单一职责原则（优化代码第一步）

单一职责原则原则的英文名字是Single Responsiblity Principlel（SRP），定义是：就一个类而言，应该仅有一个引起它变化的原因，简单来讲，一个类中应该有一组相关相关性很高的函数、数据的封装。因为单一职责原则的划分其实并不是很清晰，会根据个人而异（PS：所以当自己有观点和其他开发人员观点相矛盾的时候，可以拿这个原则和他正面怼），当然 ，使用单一职责原则时，最该注意的是问题就是对职责的定义，对类的职责的定义，以及怎么划分类的职责。

For example:
以ImageLoader为例（简易ImageLoader）；

首先，ImageLoader需要一个容器类，用来存放加载出来的Bitmap缓存，定义为ImageCache，简易ImageCache只实现单一的内存缓存，代码如下：

public class ImageCache {
    //图片URL的缓存
    private LruCache<String, Bitmap> mImageCache;

    public ImageCache() {
        initImageCache();
    }

    //初始化缓存大小
    private void initImageCache() {
        //获得最大的缓存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //取1/4最大的缓存作为缓存容量
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    //从缓存中获取Bitmap
    public Bitmap getBitmap(String key){
        return mImageCache.get(key);
    }

    //将加载出来的Bitmap存入缓存
    public void putBitmap(String key , Bitmap bitmap){
        mImageCache.put(key,bitmap);
    }

}

定义完ImageCache类，我们可以发现，其中的方法initImageCache()，getBitmap(String)，putBitmap(String, Bitmap)只是简单单一的功能，而从大的方面讲，这三个方法也只是对于内存缓存的主要职责进行了分化，初始化内存，从内存中获取Bitmap，放Bitmap于LruCache中。

接下来看下ImageLoader的代码：

public class ImageLoader {

    //图片缓存
    ImageCache mImageCache = new ImageCache();

    //线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors
            .newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    //加载图片，并设置到对应的ImageView上
    public void displayImage(final String url, final ImageView imageView) {
        //先从缓存中获取
        Bitmap bitmap = mImageCache.getBitmap(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
            //缓存中没有图片，再去网络请求加载
                Bitmap bm = downloadBitmap(url);
                if (bm == null) {
                    Log.e("Chay", "请求出现未知问题。");
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bm);
                    mImageCache.putBitmap(url, bm);
                }
            }
        });
    }

    //加载图片
    private Bitmap downloadBitmap(String url) {
        Bitmap bitmap = null;
        try {
            URL uUrl = new URL(url);
            final HttpURLConnection coon = (HttpURLConnection) uUrl.openConnection();
            bitmap = BitmapFactory.decodeStream(coon.getInputStream());
            coon.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

}

从上述ImageLoader中可以看出，此类主要有两个方法，displayImage(final String, final ImageView)加载图片到Imageview，downloadBitmap(String)下载图片，每个方法都有自己的职责，只做自己职责的事情，虽然存在调用问题，但是调用也只是从稍微大一点的职责上看，你的职责在另一个方法体中有体现。

总而言之，单一职责原则的划分界限并不总是那么清晰，很多时候要根据个人经验和需求来分。