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

时间 2019-12-01

标签 android 设计模式面向对象六大原则栏目 Android 繁體版

原文原文链接

在平常开发过程当中时常须要用到设计模式，可是设计模式有23种，如何将这些设计模式了然于胸而且能在实际开发过程当中应用得驾轻就熟呢？和我一块儿跟着《Android源码设计模式解析与实战》一书边学边应用吧！

设计模式系列文章

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

单一职责原则

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

咱们在App中每每会用到不少的公共方法，好比获取系统的时间，这个功能可能在App中的不少地方都要用到。这个时候咱们通常会单独写个工具类TimeUtils，把处理时间有关的方法都放到这个类里面，这样就能减小重复代码，App的结构会更加清晰。当须要添加其余跟时间有关的方法时，就能够都加到这个TimeUtils类里面，这就是咱们平时遵循的单一职责原则。

开闭原则

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

咱们在软件开发过程当中就要考虑到后续的扩展和修改。好比说，咱们在开发一款相似于universal-image-loader的图片加载框架，可能一开始咱们的功能比较简单，图片缓存只有内存缓存。当咱们新版本须要添加SD卡缓存时，就要注意尽量的减小对原来代码的修改，由于这样极可能会引入新的bug。而要作到开闭原则，通常有2种途径，一是经过继承原有的类；二是经过抽象和接口。后面咱们会拿书中的图片加载框架来具体说明。

里氏替换原则

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

要实现里氏替换原则，通常须要一个抽象的父类，父类中定义了子类的公共方法，子类继承或是实现父类之后扩展不一样的功能，这样以来能够实现根据不一样的须要来应用对应的子类，从而达到应用不一样的功能的目的，程序的扩展性大大加强。同时这也体现了开闭原则，即当须要增长新功能时，只要继承或实现父类，实现新增的功能高就达到了扩展的目的，而不是直接修改原来的代码，也即对扩展开放，对修改封闭。

依赖倒置原则

依赖倒置原则在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();
            }
        }
    }
}
复制代码

上述例子中的CloseUtils的closeQuietly方法的原理就是依赖于Closeable抽象而不是具体实现（依赖倒置原则），而且创建在最小化依赖的基础上，它只要知道这个对象是能够关闭的就好了，其余的一律不用关心，这就是接口隔离原则

迪米特原则

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

通俗的讲，一个类应该对本身须要耦合或调用的类知道得最少，调用者或是依赖者只要知道它须要的方法便可。要作到这个原则，须要咱们对各个模块之间的功能进行很好的区分和分配，把相互之间的依赖和耦合减到最少。

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

下面咱们经过书中的图片加载框架ImageLoader的例子介绍这些原则的具体应用。

首先是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一块儿，体现了单一职责原则
ImageLoader中依赖的是图片缓存的接口而不是具体的实现，体现了开闭原则、里氏替换原则和依赖倒置原则。
ImageLoader类和MemoryCache类之间只依赖ImageCache接口，也能够说体现了接口隔离原则
ImageLoader类只须要知道MemoryCache类的put方法和get方法，其余的实现一律无论，也体现了迪米特原则

固然以上的ImageLoader还只是第一版，还有不少有待优化的地方，好比能够把下载的逻辑单独出去，能够增长更多的定制功能等。

六大原则能让咱们的代码结构更加合理，扩展性更好，让程序更稳定灵活。这些原则每每都是共同做用的，好比上面例子中的CloseUtils知足了单一职责原则，closeQuietly方法运用了依赖倒置，而且遵循接口隔离原则。赶忙用六大原则优化你的代码吧！！！

欢迎扫码关注公众号，我们一块儿学习成长吧设计模式