面向对象的六大原则之 —— 单一原则

学习了何红辉、关爱民写的《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;
    }
}

加入ImageCache.java

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类。

以上只是对单一原则的一个解释，因为单一原则不是定死的，每个人对一个职责的认定是不同的，这个要根据个人的经验以及具体的业务逻辑来定。

下一篇：《面向对象的六大原则之——开闭原则》