AndroidAndroid开发Android开发经验谈

Android 设计模式之面向对象的六大原则

2017-10-06  本文已影响512人  AntDream

在日常开发过程中时常需要用到设计模式，但是设计模式有23种，如何将这些设计模式了然于胸并且能在实际开发过程中应用得得心应手呢？和我一起跟着《Android源码设计模式解析与实战》一书边学边应用吧！

设计模式系列文章

今天我们要讲的是面向对象的六大原则

单一职责原则

就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。

开闭原则

软件中的对象（类、模块、函数等），应该对于扩展是开放的，而对于修改是封闭的。

里氏替换原则

所有引用基类的地方必须能透明的使用其子类。通俗的说，就是只要父类能出现的地方子类就可以出现，而且替换为子类以后不会出现任何错误或异常。反过来就不行了，子类出现的地方父类不一定能适应。

依赖倒置原则

依赖倒置原则在Java中的表现就是：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

接口隔离原则

类间的依赖关系应该建立在最小的接口上。
<!--将图片写入SD卡-->
public void put(String url, Bitmap bitmap) {
    FileOutputStream fileOutputStream = null;
    try {
        fileOutputStream = new FileOutputStream(SDPath+url);
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
    }catch (FileNotFoundException e) {
        e.printStackTrace();
    }finally {
        CloseUtils.closeQuietly(fileOutputStream);
    }
}

<!--关闭工具类-->
public final class CloseUtils {

    private CloseUtils() { }

    /**
     * 关闭Closeable对象
     * @param closeable
     */
    public static void closeQuietly(Closeable closeable) {
        if (null != closeable) {
            try {
                closeable.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

迪米特原则

一个对象应该对其他的对象有最少的了解

以上就是面向对象的六大原则。

下面我们通过书中的图片加载框架ImageLoader的例子介绍这些原则的具体应用。
public class ImageLoader {
    // 图片缓存，依赖接口，而不是具体实现
    // 如果改为MemoryCache mImageCache = new MemoryCache();就不能定制图片缓存的实现，扩展性大大降低，耦合度也会大大提高
    ImageCache mImageCache = new MemoryCache();
    // 线程池，线程数量为CPU的数量
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    // 注入缓存,对扩展开放，对修改关闭
    public void setImageCache(ImageCache cache) {
        mImageCache = cache;
    }

    /**
     * 显示图片
     * @param imageUrl
     * @param imageView
     */
    public void displayImage(String imageUrl, ImageView imageView) {
        Bitmap bitmap = mImageCache.get(imageUrl);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return;
        }
        // 图片没有缓存，提交到线程池下载
        submitLoadRequest(imageUrl, imageView);
    }

    /**
     * 下载图片
     * @param imageUrl
     * @param imageView
     */
    private void submitLoadRequest(final String imageUrl, final ImageView imageView) {
        imageView.setTag(imageUrl);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(imageUrl);
                if (bitmap == null) {
                    return;
                }
                if (imageUrl.equals(imageView.getTag())) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(imageUrl, bitmap);
            }
        });
    }

    /**
     * 下载图片
     * @param imageUrl
     * @return
     */
    private Bitmap downloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }

<!--图片缓存接口-->
public interface ImageCache {
    public Bitmap get(String url);
    public void put(String url, Bitmap bitmap);
}

<!--内存缓存的实现-->
public class MemoryCache implements ImageCache{
    private LruCache<String, Bitmap> mMemoryCache;

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


    @Override
    public Bitmap get(String url) {
        return mMemoryCache.get(url);
    }

    @Override
    public void put(String url, Bitmap bitmap) {
        mMemoryCache.put(url, bitmap);
    }
}
ImageLoader类中的逻辑比较直观，六大原则的体现主要在图片缓存的处理上。
当然以上的ImageLoader还只是初版，还有很多有待优化的地方，比如可以把下载的逻辑单独出去，可以增加更多的定制功能等。
六大原则能让我们的代码结构更加合理，扩展性更好，让程序更稳定灵活。这些原则往往都是共同作用的，比如上面例子中的CloseUtils满足了单一职责原则，closeQuietly方法运用了依赖倒置，并且遵循接口隔离原则。赶紧用六大原则优化你的代码吧！！！

源码地址：https://github.com/snowdream1314/DesignPatternsExamples

欢迎扫码关注公众号，咱们一起学习成长吧


AntDream
上一篇 下一篇

猜你喜欢

热点阅读