来自  资质荣誉 2019-10-06 06:03 的文章
当前位置: 澳门太阳娱乐手机登录 > 资质荣誉 > 正文

面向对象的标准化之开闭原则,开闭原则

开闭原则(Open Closed Principle)是Java世界里最基础的布署条件,它指导大家什么样树立八个平安的、灵活的系统。

开闭原则的意大利语全称是Open Close Principle,缩写是OCP,它是Java世界里最基础的图谋基准,它教导大家怎么树立叁个和煦的、灵活的系统。开闭原则的定义是:软件中的对象(类、模块、函数等)应该对此扩大是开放的,可是对于修改是密封的。

大约的说正是在改造须要的时候,应该尽量通过增加来兑现转移,而不是经过退换已有代码来落到实处转换。

勃兰特-梅耶在一九八七年问世的《面向对象软件构造》一书中建议这一准绳---开闭原则。这一想方设法以为,程序一旦付出形成,程序中二个类的完结只应该因错误而被改换,新的要么转移的特色应该经过新建分化的类实现,新建的类能够透过延续的艺术来重用原类的代码。显著梅耶的概念提倡实现三番五次,已存在的实现类对于修改时密封的,不过新的类能够透过覆写父类的接口应对转移。

举三个简约的例证: 在图片加载器ImageLoder中,我们供给将图片缓存来加速软件速度和节约顾客流量。我们一初始容许会设想将从网络上赢获得的图样加载到内部存款和储蓄器中去,并在其次次索要加载此图片时直接从内部存款和储蓄器中获取。于是,大家创立二个MemoryCache类。

引进别的缓存格局

说了如此多,上面照旧以四个粗略示例来表明开闭原则:

在对ImageLoader进行了一回重构之后的ImageLoader任务单一、结构清晰,算是个正确的起来。随着顾客的扩张,有个别难点起始展表露来:缓存系统是最让我们嘲谑的地点,通过内部存款和储蓄器缓存消除了历次从互联网加载图片的标题,但是,Android应用的内部存款和储蓄器很简单,且具有易失性,即当使用重新开动之后,原本已经加载过的图片将会甩掉,那样重启之后及索要再行下载图片!而这又会导致加载缓慢、耗开支户流量的主题材料。针对上述难题考虑引进SD卡缓存,那样下载过的图纸就能够缓存到本地,尽管重启应用也不要求再行下载了,接下去起首完成SDHC卡缓存。

DiskCache.java类,将图片缓存到SD内部存款和储蓄器卡中:

package com.deason.library.ocp;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * SD卡图片缓存
 * Created by liuguoquan on 2016/3/17.
 */
public class DiskCache {

    public static final String CACHE_DIR = "/sdcard/cache/";

    /**
     * 从缓存中获取图片
     * @param url
     * @return
     */
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(CACHE_DIR + url);
    }

    /**
     * 将图片存入SD卡中
     * @param url
     * @param bitmap
     */
    public void put(String url,Bitmap bitmap) {

        FileOutputStream out = null;
        try {
            out = new FileOutputStream(CACHE_DIR + url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MemoryCache类,把图纸缓存到内存中

package com.deason.library.ocp;

import android.graphics.Bitmap;
import android.util.LruCache;

/**
 * 处理图片缓存
 * Created by liuguoquan on 2016/3/14.
 */
public class MemoryCache {

    /**
     * 图片缓存
     */
    LruCache<String, Bitmap> mImageCache;
    public MemoryCache() {
        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 value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    /**
     * 将图片存入缓存
     * @param key
     * @param bitmap
     */
    public void put(String key,Bitmap bitmap) {
        mImageCache.put(key,bitmap);
    }

    /**
     * 取出缓存图片
     * @param key
     * @return
     */
    public Bitmap get(String key) {
        return mImageCache.get(key);
    }
}

因为急需将图片缓存到CF内部存款和储蓄器卡中,全体ImageLoader代码有所立异,具体代码如下:

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

    /**
     * 图片缓存
     */
    MemoryCache mMemoryCache = new MemoryCache();

    /**
     * SD卡缓存
     */
    DiskCache mDiskCache = new DiskCache();

    /**
     * 是否使用SD卡缓存
     */
    private boolean isUseDiskCache = false;

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        //判断使用哪种缓存
        Bitmap bitmap =  isUseDiskCache ? mDiskCache.get(url) :  mMemoryCache.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);
                }
                //将下载的图片存入内存
                mMemoryCache.put(url,bitmap);
                mDiskCache.put(url,bitmap);
            }
        });
    }

    /**
     * 设置是否用SD卡缓存
     * @param isUseDiskCache
     */
    public void useDiskCache(boolean isUseDiskCache) {
        this.isUseDiskCache = isUseDiskCache;
    }

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

从上述的代码中得以见见,仅仅新扩展了二个DiskCache类和往ImageLoader类中参预了少许代码就加多了TF闪存卡缓存的效果,顾客能够透过useDiskCache方法来对采纳哪个种类缓存举办设置,比如

ImageLoader mImageLoader = new ImageLoader();
//使用SD卡缓存
mImageLoader.useDiskCache(true);
//使用内存缓存
mImageLoader.useDisCache(false);

因此useDiskCache方法来让顾客安装不一致的缓存那个思路是对的,不过会稍为扎眼的主题材料,正是采取内部存款和储蓄器缓存时客商不可能选拔TF存款和储蓄卡缓存。类似地,使用TF卡缓存时顾客就不可能运用内部存款和储蓄器缓存。

其实,顾客供给这两种缓存的回顾,首先缓存优先选用内部存款和储蓄器缓存,借使内部存款和储蓄器缓存未有图片再使用SD卡缓存,借使SDHC卡中也未有图片最终才从互连网上获得,那才是最佳的缓存攻略。

接下去,大家后续重构,新建三个双缓冲类DoubleCache,具体代码如下:

package com.deason.library.ocp;


import android.graphics.Bitmap;

/**
 * 双缓冲。获取图片时先从内存中获取,如果内存中没有缓存该图片,再从SD卡中获取
 * Created by liuguoquan on 2016/3/17.
 */
public class DoubleCache {

    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();

    /**
     * 先从内存获取图片,没有再从SD卡获取
     * @param url
     * @return
     */
    public Bitmap get(String url) {

        Bitmap bitmap = mMemoryCache.get(url);

        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }

        return bitmap;
    }

    /**
     * 将图片缓存到内存和SD卡中
     * @param url
     * @param bitmap
     */
    public void put(String url, Bitmap bitmap) {
        mMemoryCache.put(url, bitmap);
        mDiskCache.put(url, bitmap);
    }
}

咱俩再来看看最新的ImageLoader类,代码更新也非常少:

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

    /**
     * 图片缓存
     */
    MemoryCache mMemoryCache = new MemoryCache();

    /**
     * SD卡缓存
     */
    DiskCache mDiskCache = new DiskCache();
    //双缓存
    DoubleCache mDoubleCache = new DoubleCache();

    /**
     * 是否使用SD卡缓存
     */
    private boolean isUseDiskCache = false;
    //使用双缓存
    private boolean isUseDoubleCache = false;

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        //判断使用哪种缓存
        Bitmap bitmap =  null;
        if (isUseDoubleCache) {
            bitmap = mDoubleCache.get(url);
        } else if (isUseDiskCache) {
            bitmap = mDiskCache.get(url);
        } else {
            bitmap = mMemoryCache.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);
                }
                //将下载的图片存入内存
                mMemoryCache.put(url,bitmap);
                mDiskCache.put(url,bitmap);
            }
        });
    }

    /**
     * 设置是否用SD卡缓存
     * @param isUseDiskCache
     */
    public void useDiskCache(boolean isUseDiskCache) {

        this.isUseDiskCache = isUseDiskCache;
    }

    /**
     * 设置是否使用双缓存
     * @param isUseDoubleCache
     */
    public void useDoubleCache(boolean isUseDoubleCache) {

        this.isUseDoubleCache = isUseDoubleCache;
    }

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

那时先后更为灵活了,通过增添短短几行代码就能够一挥而就这么主要的效劳。

大家总会把美好的工作讲在后边,最终给您来个“然则”,我们先来剖判一下地点的程序:每回在程序中插手新的缓存完成都亟需修改ImageLoader类,然后通过三个布尔类型的变量来让顾客选择选取哪一类缓存,由此,就使得ImageLoader中存在各个if-else判定语句,通过这几个判别语句来鲜明使用哪个种类缓存。随着大气逻辑的援引,代码变得愈加复杂亏弱,要是一不当心写错某些if条件,势必会开销多量的时光去调节和测验程序,整个ImageLoader类也会来得臃肿。最关键的是,客商不可能和睦达成缓存注入到ImageLoader类中,可扩大性非常糟糕,而可扩充性是框架的最主要的特征之一。

瞩目:下面代码只是模仿,省略了具体完毕

流入方式设置缓存格局

“软件中的对象(类、模块、函数等)应该对此增添是开放的,可是对于修改则是查封的,那正是开放-关闭原则。也正是说,大家应有尽可能通过增加的主意来完结转换,并非由此改动已部分代码来兑现”。今后,大家来贯彻终极应用方案,遵守开闭原则。

首先,大家先画出UML图,如下

图片 1

开闭原则.png

接下来,完毕UML图上的类和接口,先重构ImageLoader类:

/**
 * Created by liuguoquan on 2016/3/17.
 */
public interface ImageCache {

    /**
     * 获取图片
     * @param url
     * @return
     */
    public Bitmap get(String url);

    /**
     * 缓存图片
     * @param url
     * @param bitmap
     */
    public void put(String url, Bitmap bitmap);
}

透过重构后,少了if-else语句,没有了多样两种的缓存达成目的、布尔变量,代码确实清晰、轻便了大多。须求留意的是,本次重构的ImageCache把它提取成二个图片缓存的接口,用来抽象图片缓存的功力,大家来看看该接口的宣示:

/**
 * 图片加载类
 * Created by liuguoquan on 2016/3/14.
 */
public class ImageLoader {

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

    /**
     * 注入缓存实现
     * @param cache
     */
    public void setIamgeCache(ImageCache cache) {
        mImageCache = cache;
    }

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

    /**
     * 显示图片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        Bitmap bitmap =  mImageCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            return ;
        }

        //没有缓存则提交线程池下载
        submitLoadRequest(url, imageView);

    }

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

    /**
     * 下载图片
     * @param url
     * @return
     */
    public Bitmap downloadImage(String imageUrl) {

        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            HttpURLConnection mConnection = (HttpURLConnection) url.openConnection();
            int code = mConnection.getResponseCode();

            if (200 == code) {
                bitmap = BitmapFactory.decodeStream(mConnection.getInputStream());
            }
            mConnection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

ImageCache接口简单定义了获得、缓存图片七个章程,缓存的能够是图形的url,值是图片的自己。内部存款和储蓄器缓存、SD闪存卡缓存、爽缓存都落实该接口,大家看看几个缓存的完毕:

MemoryCache.java

public class MemoryCache implements ImageCache {

    /**
     * 图片缓存
     */
    LruCache<String, Bitmap> mMemoryCache;
    public MemoryCache() {
        initImageCache();
    }

    /**
     * 初始化LRU缓存
     */
    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 value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }
    @Override
    public Bitmap get(String url) {
        return mMemoryCache.get(url);
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        mMemoryCache.put(url, bitmap);
    }
}

DiskCache.java

/**
 * Created by liuguoquan on 2016/3/17.
 */
public class DiskCache implements  ImageCache {

    public static final String CACHE_DIR = "/sdcard/cache/";
    @Override
    public Bitmap get(String url) {
        return BitmapFactory.decodeFile(CACHE_DIR + url);
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        FileOutputStream out = null;

        try {
            out = new FileOutputStream(CACHE_DIR + url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,out);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Double.java

/**
 * Created by liuguoquan on 2016/3/17.
 */
public class DoubleCache implements ImageCache {

    ImageCache mMemoryCache = new MemoryCache();
    ImageCache mDiskCache = new DiskCache();

    @Override
    public Bitmap get(String url) {
        Bitmap bitmap = mMemoryCache.get(url);

        if (bitmap == null) {
            bitmap = mDiskCache.get(url);
        }

        return bitmap;
    }

    @Override
    public void put(String url, Bitmap bitmap) {

        mMemoryCache.put(url, bitmap);
        mDiskCache.put(url, bitmap);
    }
}

上述重构后的ImageLoader类中增添了四个setImageCache(ImageCache cache)方法,客商能够透过该函数设置缓存达成,也便是日常所说的借助于注入

上边看看顾客如何通过运用ImageLoader来设置缓存实现的:

ImageLoader mImageLoader = new ImageLoader();

//使用内存缓存
mImageLoader.setIamgeCache(new MemoryCache());

//使用SD卡缓存
mImageLoader.setIamgeCache(new DiskCache());

//使用双缓存
mImageLoader.setIamgeCache(new DoubleCache());

//使用自定义的图片缓存实现
mImageLoader.setIamgeCache(new ImageCache() {
    @Override
    public Bitmap get(String url) {
        return null;
    }

    @Override
    public void put(String url, Bitmap bitmap) {

    }
});

在上述代码中,通过setImageCache(ImageCache cache)方法注入差异的缓存达成,那样不只能够使ImageLoader更简短、健壮,也使得ImageLoader可课扩大性、灵活性更加高。

MemeryCache、DiskCache、DoubleCache缓存图片的切实可行落到实处完全差异,不过,它们有三个特征是,都完结了ImageCache接口。当顾客须求自定义缓存完毕时,只须要新建二个贯彻ImageCache接口的类,然后构造该类的对象,何况经过setImageCache(ImageCache cache)注入到ImageLoader中就能够了,那样ImageLoader就兑现了阪上走丸的缓存攻略,且扩展那几个缓存计谋并不会促成ImageLoader类的修改。经过此次重构,ImageLoader在设计情势上着力已经过关了。

开闭原则指导大家,当软件要求转移时,应该尽或然通过扩充的秘技来落到实处调换,实际不是经过改换已部分代码来促成。这里的“应该尽量”4个字表达OCP原则实际不是说纯属不得以修改原始类的。当明确原本的代码已经“腐化”时,应该及早的重构,以便让代码恢复生机带不奇怪的事态,实际不是透过连续等方式增加新的代码。因而,在支付进度中要求团结组合具体意况进行勘测,是通过更改旧代码照旧经过持续使得软件系统更妥帖、更加灵活,在保管去除“变质代码”的还要,也准保原有模块的不利。

//ImageLoder类 ,用于图片加载

优点

  • 日增牢固性
  • 可扩张性提升
public class ImageLoder { //内存缓存类 MemoryCache mMemoryCache; //加载图片 public void displayImage(final String url, final ImageView imageView, Context context) { //使用缓存 useCache(String url,mMemoryCache); } private void useCache(String url,MemoryCache mMemoryCache){ //从内存中去获取 Bitmap bitmap= mMemoryCache.get; //如果内存中没有就通过网络下载 if(bitmap==null){ //开启线程,从网上下载图片 bitmap=downloadBitmap(); } //将图片存入内存缓存 mMemoryCache.put; } }

//MemoryCache 内存缓存类

public class MemoryCache { /* ** 省略具体实现,具体实现使用LruCache类 * put()方法用来将图片存入缓存。 * get()用于从缓存中取出图片 */ public void put(String url, Bitmap bitmap) { /* ** 省略具体实现 */ } public Bitmap get(String url) { /* ** 省略具体实现 */ }}

上边的MemoryCache 化解了历次从网络下载图片的标题,可是Android 内部存款和储蓄器有数。<font color=red face=“石籀文”>单个应用的最大内部存款和储蓄器能够那样获取:Runtime.getRuntime().maxMemory()</font> 并且,具备易失性,即每一回应用重启后,原本加载的图片都会抛弃,这样又得从互连网下载。所以,我们怀想加盟四个SD读取卡缓存类。那样下载的图形将缓存到地头。

//DiskCache sd卡缓存类

public class DiskCache { /* ** 省略具体实现 * put()方法用来将图片存入缓存。 * get()用于从缓存中取出图片 */ public Bitmap get(String url) { /* ** 省略具体实现 */ } public void put(String url, Bitmap bitmap) { /* ** 省略具体实现 */ }}

下边是修改后的ImageLoder类

public class ImageLoder { //内存缓存类 MemoryCache mMemoryCache; //sd卡缓存类 DiskCache mDiskCache; //用于判断是否用MemoryCache,默认使用 boolean isUseMemoryCache = true; //加载图片 public void displayImage(final String url, final ImageView imageView, Context context) { //根据useMemoryCahce来判断Cache使用的类型 if(useMemoryCahce){ useMemoryCache(String url,mMemoryCache); }else{ useDiskCache(String url,mMemoryCache); } } //使用MemoryCache private void useMemoryCache(String url,MemoryCache mMemoryCache){ Bitmap bitmap= mMemoryCache.get; if(bitmap==null){ //开启线程,从网上下载图片 bitmap=downloadBitmap(); } //将图片存入内存缓存 mMemoryCache.put; } //使用DiskCache private void useDiskCache(String url,DiskCache mDiskCache){ Bitmap bitmap= mDiskCache.get; if(bitmap==null){ //开启线程,从网上下载图片 bitmap=downloadBitmap(); } //将图片存入内存缓存 mDiskCache.put; } //获取isUseMemoryCache private boolean useMemoryCahce(){ return isUseMemoryCache ; } //设置isUseMemoryCache private void SetUseMemoryCache(boolean isUseMemoryCache){ this.isUseMemoryCache =isUseMemoryCache ; }}

在地方的代码中,大家修改了 ImageLoader类,通过useMemoryCahce()方法来推断使用哪一品类的cache.能够见见大家投入了四个if else语句来促成缓存的挑选功用。但是借使现在将cache的体系扩充到拾三个以致几11个的时候,大家便须求再修改ImageLoder类,扩展它的if else语句。在退换中也许会因各类因素使大家发出不必要的荒谬。显明那不相符OCP原则。

有未有如何艺术能够让我们摆脱if - else 语句(有的人说用switch语句....那一个这几个)或然说让我们不退换ImageLoader类来贯彻新职能吗?答案自然是有个别。

上边大家运用接口来兑现下方面包车型地铁功用,给出一个uml类图。

图片 2此处写图片描述

不会看UML类图的请参谋 5分钟学会看UML类图

在上海体育场所中,创设了二个接口类,全数Cache类都落实该接口天公地道写put 和get 方法。并扩充了setImageCache(ImageCache mImageCache)方法用于客户自定义cache类型,而要是有新的cache类型发生的时候,只必要贯彻ImageCache接口,然后调用setImageCache方法就能够兑现并运用新cache类型。切合OCP的标准化。

上边是重构后的类。//接口类

public interface ImageCache { public Bitmap get(String url); public void put(String url, Bitmap bitmap);}

//MemoryCache 内存缓存类

public class MemoryCache implements ImageCache { /* ** 省略具体实现,具体实现使用LruCache类 * put()方法用来将图片存入缓存。 * get()用于从缓存中取出图片 */ public void put(String url, Bitmap bitmap) { /* ** 省略具体实现 */ } public Bitmap get(String url) { /* ** 省略具体实现 */ }}

//DiskCache sd卡缓存类

public class DiskCache implements ImageCache { /* ** 省略具体实现 * put()方法用来将图片存入缓存。 * get()用于从缓存中取出图片 */ public Bitmap get(String url) { /* ** 省略具体实现 */ } public void put(String url, Bitmap bitmap) { /* ** 省略具体实现 */ }}

//ImageLoder类 ,用于图片加载

public class ImageLoder { //默认使用内存缓存类,也可以是其他Cache ImageCache cache = new MemoryCache(); //用于自定义Cache类型 public void setImageCache(ImageCache mImageCache) { this.mImageCache = mImageCache; } //加载图片 public void displayImage(final String url, final ImageView imageView, Context context) { //使用缓存 useCache(String url,mImageCache); } private void useCache(String url,ImageCachemImageCache){ Bitmap bitmap= mImageCache.get; if(bitmap==null){ //开启线程,从网上下载图片 bitmap=downloadBitmap(); } //将图片存入内存缓存 mImageCache.put; }}

开闭原则:当软件须求修改时应竭尽通过扩充的主意来兑现,并不是说决不能够由此改换已部分代码来落到实处。具体是或不是使用相应由近日项目具体意况具体深入分析。

本文由澳门太阳娱乐手机登录发布于 资质荣誉,转载请注明出处:面向对象的标准化之开闭原则,开闭原则

关键词: