面向对象的六大原则之 —— 开闭原则

学习了何红辉、关爱民写的《Android设计模式》，对于面向对象的六大原则有进一步的理解，特此根据自己的理解记录总结一下

什么是开闭原则

一个类、模块、函数等应该对于扩展是开放的，但是对于修改是封闭的，简单说就是当你的系统要升级维护需要对原有的代码进行修改时，可能会将错误引入到了原来的旧代码中，因此，在软件升级维护时，应该尽可能的通过扩展的方式而不是修改原有的代码，虽然在实际开发中，修改原本的代码跟扩展代码都是同时存在的，但是为了程序的可扩展性，在制作初期，应该遵循开闭原则。

以上一篇《面向对象的六大原则之 —— 单一原则》的例子为例继续讲解

在ImageCache类中，使用了内存缓存，可是内存缓存很有限，而且还容易丢失，比如应用关闭后，原来缓存在内存的图片会丢失，再打开需要重新加载，所以我们考虑加入SD卡缓存。

加入DiskCache类，缓存图片到SD卡中

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.graphics.BitmapFactory;  
3.   
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7.   
8. /** 
9.  * Created by Administrator on 2016/3/1. 
10.  */  
11. public class DiskCache {  
12.     public static final String cacheDir="sdcard/cache/";  
13.   
14.     /** 
15.      * 获取sd卡的图片缓存 
16.      * @param url 图片url 
17.      * @return 返回bitmap 
18.      */  
19.     public Bitmap get(String url){  
20.         Bitmap bitmap=null;  
21.         bitmap= BitmapFactory.decodeFile(cacheDir+url);  
22.         return bitmap;  
23.     }  
24.   
25.     /** 
26.      * 缓存到sd卡 
27.      * @param url 图片的url 
28.      * @param bitmap bitmap对象 
29.      */  
30.     private void put(String url ,Bitmap bitmap){  
31.         FileOutputStream output = null;  
32.         try {  
33.             output = new FileOutputStream(cacheDir+url);  
34.             bitmap.compress(Bitmap.CompressFormat.PNG,100,output);  
35.         } catch (FileNotFoundException e) {  
36.             e.printStackTrace();  
37.         }finally {  
38.             //无论是否有异常，都要关闭流  
39.             try {  
40.                 if(output!=null){  
41.                     output.close();  
42.                 }  
43.             } catch (IOException e) {  
44.                 e.printStackTrace();  
45.             }  
46.         }  
47.   
48.     }  
49. }  

因为加入了sd卡的缓存方式，所以要修改ImageLoader类

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.graphics.BitmapFactory;  
3. import android.widget.ImageView;  
4.   
5. import java.io.IOException;  
6. import java.net.HttpURLConnection;  
7. import java.net.MalformedURLException;  
8. import java.net.URL;  
9. import java.util.concurrent.ExecutorService;  
10. import java.util.concurrent.Executors;  
11.   
12. /** 
13.  * Created by Administrator on 2016/3/1. 
14.  */  
15. public class ImageLoader {  
16.   
17.     public ImageLoader() {  
18.     }  
19.     //内存缓存类  
20.     ImageCache imageCache=new ImageCache();  
21.     //sd卡缓存类  
22.     DiskCache diskCache=new DiskCache();  
23.     //是否使用sd卡缓存  
24.     boolean isUseDiskCache=false;  
25.     //线程池，线城数量为cpu的数量  
26.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
27.   
28.     /** 
29.      * 显示图片 
30.      * @param url 图片的url 
31.      * @param imageView 要显示的view 
32.      */  
33.     public void displayImage(final String url, final ImageView imageView) {  
34.         Bitmap bitmap=isUseDiskCache()?diskCache.get(url):imageCache.get(url);  
35.         if(bitmap!=null){  
36.             imageView.setImageBitmap(bitmap);  
37.             return;  
38.         }  
39.         imageView.setTag(url);  
40.         mExecutorService.submit(new Runnable() {  
41.             @Override  
42.             public void run() {  
43.                 Bitmap bitmap = downloadImage(url);  
44.                 if (bitmap == null) {  
45.                     return;  
46.                 }  
47.                 if (imageView.getTag().equals(url)) {  
48.                     imageView.setImageBitmap(bitmap);  
49.                 }  
50.                 imageCache.put(url, bitmap);  
51.         diskCache.put(url,bitmap);  
52.             }  
53.         });  
54.     }  
55.     /** 
56.      * 下載圖片 
57.      * @param imageUrl 网络图片地址 
58.      * @return 返回bitmap对象 
59.      */  
60.     public Bitmap downloadImage(String imageUrl) {  
61.         Bitmap bitmap = null;  
62.         try {  
63.             URL url = new URL(imageUrl);  
64.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
65.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
66.             conn.disconnect();  
67.         } catch (MalformedURLException e) {  
68.             e.printStackTrace();  
69.         } catch (IOException e) {  
70.             e.printStackTrace();  
71.         }  
72.         return bitmap;  
73.     }  
74.   
75.     public boolean isUseDiskCache() {  
76.         return isUseDiskCache;  
77.     }  
78.   
79.     public void setIsUseDiskCache(boolean isUseDiskCache) {  
80.         this.isUseDiskCache = isUseDiskCache;  
81.     }  
82. }  

ImageLoader类中加入了少量代码就添加了sd卡缓存的功能，用户还能通过setIsUseDiskCache设置使用哪种缓存，但是以上还有个问题，使用内存缓存的时候，就没有sd卡缓存，用户要两种策略都用，首先缓存优先使用内存缓存， 如果内存没有就查找sd卡缓存，sd卡没有就从网络获取，，这才是最好的缓存策略，依照这种想法，修改代码，加入DoubleCache类，实现双缓存

[java] view plain copy

1. import android.graphics.Bitmap;  
2.   
3. /** 
4.  * Created by Administrator on 2016/3/1. 
5.  */  
6. public class DoubleCache {  
7.     //内存缓存  
8.     ImageCache mImageCache=new ImageCache();  
9.     //sd卡缓存  
10.     DiskCache mDiskCache=new DiskCache();  
11.   
12.     /** 
13.      * 获取缓存图片 
14.      * @param url 图片url 
15.      * @return 返回bitmap对象 
16.      */  
17.     public Bitmap get(String url){  
18.         Bitmap bitmap=null;  
19.         bitmap=mImageCache.get(url);  
20.         if(bitmap==null){  
21.             bitmap=mDiskCache.get(url);  
22.         }  
23.         return bitmap;  
24.     }  
25.   
26.     /** 
27.      * 缓存图片 
28.      * @param url 图片url 
29.      * @param bitmap  
30.      */  
31.     public void put(String url,Bitmap bitmap){  
32.         mImageCache.put(url,bitmap);  
33.         mDiskCache.put(url,bitmap);  
34.     }  
35. }  

ImageLoader类修改如下

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.graphics.BitmapFactory;  
3. import android.widget.ImageView;  
4.   
5. import java.io.IOException;  
6. import java.net.HttpURLConnection;  
7. import java.net.MalformedURLException;  
8. import java.net.URL;  
9. import java.util.concurrent.ExecutorService;  
10. import java.util.concurrent.Executors;  
11.   
12. /** 
13.  * Created by Administrator on 2016/3/1. 
14.  */  
15. public class ImageLoader {  
16.   
17.     public ImageLoader() {  
18.     }  
19.   
20.     //内存缓存类  
21.     ImageCache imageCache=new ImageCache();  
22.     //sd卡缓存类  
23.     DiskCache diskCache=new DiskCache();  
24.     //双缓存  
25.     DoubleCache doubleCache=new DoubleCache();  
26.     //是否使用sd卡缓存  
27.     boolean isUseDiskCache=false;  
28.     //是否使用双缓存  
29.     boolean isUseDoubleCache=false;  
30.     //线程池，线城数量为cpu的数量  
31.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
32.   
33.   
34.   
35.     /** 
36.      * 显示图片 
37.      * @param url 图片的url 
38.      * @param imageView 要显示的view 
39.      */  
40.     public void displayImage(final String url, final ImageView imageView) {  
41.         Bitmap bitmap=null;  
42.         if(isUseDoubleCache()){  
43.             bitmap=doubleCache.get(url);  
44.         }else if(isUseDiskCache()){  
45.             bitmap=diskCache.get(url);  
46.         }else{  
47.             bitmap=imageCache.get(url);  
48.         }  
49.         if(bitmap!=null){  
50.             imageView.setImageBitmap(bitmap);  
51.             return;  
52.         }  
53.         imageView.setTag(url);  
54.         mExecutorService.submit(new Runnable() {  
55.             @Override  
56.             public void run() {  
57.                 Bitmap bitmap = downloadImage(url);  
58.                 if (bitmap == null) {  
59.                     return;  
60.                 }  
61.                 if (imageView.getTag().equals(url)) {  
62.                     imageView.setImageBitmap(bitmap);  
63.                 }  
64.                 //缓存到内存跟sd卡中  
65.                 doubleCache.put(url, bitmap);  
66.             }  
67.         });  
68.     }  
69.     /** 
70.      * 下載圖片 
71.      * @param imageUrl 网络图片地址 
72.      * @return 返回bitmap对象 
73.      */  
74.     public Bitmap downloadImage(String imageUrl) {  
75.         Bitmap bitmap = null;  
76.         try {  
77.             URL url = new URL(imageUrl);  
78.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
79.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
80.             conn.disconnect();  
81.         } catch (MalformedURLException e) {  
82.             e.printStackTrace();  
83.         } catch (IOException e) {  
84.             e.printStackTrace();  
85.         }  
86.         return bitmap;  
87.     }  
88.   
89.     public boolean isUseDiskCache() {  
90.         return isUseDiskCache;  
91.     }  
92.   
93.     public void setIsUseDiskCache(boolean isUseDiskCache) {  
94.         this.isUseDiskCache = isUseDiskCache;  
95.     }  
96.   
97.     public boolean isUseDoubleCache() {  
98.         return isUseDoubleCache;  
99.     }  
100.   
101.     public void setIsUseDoubleCache(boolean isUseDoubleCache) {  
102.         this.isUseDoubleCache = isUseDoubleCache;  
103.     }  
104. }  

经过修改之后，我们的图片加载器已经实现了双缓存的功能了，可是细心的你可能发现了，每次加入新的缓存方法都要修改原来的代码，而且还会让ImageLoader变的越来越复杂，一堆的if{}else{}判断，条件多了就容易造成错误，而且如果现在用户想要自己扩展一个缓存方式，都要动ImageLoader类里面的东西，本文最上面已经说了，开闭原则的目的就是为了让扩展是开发的，修改是封闭的，当软件需要变化时，我们应该尽可能的通过扩展的方式来实现变化，而不要通过修改已有的代码来实现，按照这个思维，我们来想想应该如何修改，首先，我们的ImageLoader的职责就是加载图片跟设置缓存的，而缓存的实现不由它管，我们的目的是让缓存的方式能让用户自己扩展，所以我们定义ImageCache接口，接口中有两个方法，一个是put(String url,Bitmap bitmap)用来添加到缓存，一个是get(String url);用来获取缓存，具体实现不管，而是由实现了这个接口的实现类来具体实现。

ImageCache类如下：

[java] view plain copy

1. import android.graphics.Bitmap;  
2.   
3. /** 
4.  * Created by Administrator on 2016/3/1. 
5.  */  
6. public interface ImageCache {  
7.     /** 
8.      * 添加缓存 
9.      * @param url    缓存的图片url作为缓存的key 
10.      * @param bitmap 缓存的bitmap 
11.      */  
12.     public void put(String url, Bitmap bitmap);  
13.   
14.     /** 
15.      * 获取缓存的图片 
16.      * @param url 
17.      * @return 
18.      */  
19.     public Bitmap get(String url);  
20. }  

我们可以将接口当成是一个标准，比如电脑的usb接口，想要通过usb连接到电脑，就必须要按照usb这个插口的标准走，不然你想插也插不进去，我们的图片加载器也是一样，想要自己扩展一个缓存方式，就要按我的标准来。

所以，上面的内存缓存、sd卡缓存、双缓存三个类，我们全部修改实现ImageCache类

内存缓存类（MemoryCache）

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.util.LruCache;  
3.   
4. /** 
5.  * Created by Administrator on 2016/3/1. 
6.  */  
7. public class MemoryCache implements ImageCache{  
8.   
9.     public MemoryCache() {  
10.         //初始化图片缓存  
11.         initImageCache();  
12.     }  
13.   
14.     //图片缓存类  
15.     LruCache<String, Bitmap> memoryCache;  
16.   
17.     /** 
18.      * 初始化缓存 
19.      */  
20.     private void initImageCache() {  
21.         //计算可使用的最大内存  
22.         int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
23.         //只用最大内存的四分之一作为缓存大小  
24.         int cacheSize = maxMemory / 4;  
25.         memoryCache = new LruCache<String, Bitmap>(cacheSize) {  
26.             @Override  
27.             protected int sizeOf(String key, Bitmap value) {  
28.                 return value.getRowBytes() * value.getHeight() / 1024;  
29.             }  
30.         };  
31.     }  
32.   
33.     /** 
34.      * 添加缓存 
35.      * 
36.      * @param url    缓存的图片url作为缓存的key 
37.      * @param bitmap 缓存的bitmap 
38.      */  
39.     public void put(String url, Bitmap bitmap) {  
40.         memoryCache.put(url, bitmap);  
41.     }  
42.   
43.     /** 
44.      * 获取缓存的图片 
45.      * 
46.      * @param url 
47.      * @return 
48.      */  
49.     public Bitmap get(String url) {  
50.         Bitmap bitmap = null;  
51.         bitmap = memoryCache.get(url);  
52.         return bitmap;  
53.     }  
54. }  

SD卡缓存类（DiskCache）

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.graphics.BitmapFactory;  
3.   
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7.   
8. /** 
9.  * Created by Administrator on 2016/3/1. 
10.  */  
11. public class DiskCache implements ImageCache{  
12.     public static final String cacheDir="sdcard/cache/";  
13.   
14.     /** 
15.      * 获取sd卡的图片缓存 
16.      * @param url 图片url 
17.      * @return 返回bitmap 
18.      */  
19.     public Bitmap get(String url){  
20.         Bitmap bitmap=null;  
21.         bitmap= BitmapFactory.decodeFile(cacheDir+url);  
22.         return bitmap;  
23.     }  
24.   
25.     /** 
26.      * 缓存到sd卡 
27.      * @param url 图片的url 
28.      * @param bitmap bitmap对象 
29.      */  
30.     public void put(String url ,Bitmap bitmap){  
31.         FileOutputStream output = null;  
32.         try {  
33.             output = new FileOutputStream(cacheDir+url);  
34.             bitmap.compress(Bitmap.CompressFormat.PNG,100,output);  
35.         } catch (FileNotFoundException e) {  
36.             e.printStackTrace();  
37.         }finally {  
38.             //无论是否有异常，都要关闭流  
39.             try {  
40.                 if(output!=null){  
41.                     output.close();  
42.                 }  
43.             } catch (IOException e) {  
44.                 e.printStackTrace();  
45.             }  
46.         }  
47.   
48.     }  
49. }  

双缓存类（DoubleCache）

[java] view plain copy

1. import android.graphics.Bitmap;  
2.   
3. /** 
4.  * Created by Administrator on 2016/3/1. 
5.  */  
6. public class DoubleCache implements ImageCache{  
7.     //内存缓存  
8.     MemoryCache mMemoryCache =new MemoryCache();  
9.     //sd卡缓存  
10.     DiskCache mDiskCache=new DiskCache();  
11.   
12.     /** 
13.      * 获取缓存图片 
14.      * @param url 图片url 
15.      * @return 返回bitmap对象 
16.      */  
17.     public Bitmap get(String url){  
18.         Bitmap bitmap=null;  
19.         bitmap= mMemoryCache.get(url);  
20.         if(bitmap==null){  
21.             bitmap=mDiskCache.get(url);  
22.         }  
23.         return bitmap;  
24.     }  
25.   
26.     /** 
27.      * 缓存图片 
28.      * @param url 图片url 
29.      * @param bitmap 
30.      */  
31.     public void put(String url,Bitmap bitmap){  
32.         mMemoryCache.put(url,bitmap);  
33.         mDiskCache.put(url,bitmap);  
34.     }  
35. }  

最后我们的ImageLoader类修改如下：

[java] view plain copy

1. import android.graphics.Bitmap;  
2. import android.graphics.BitmapFactory;  
3. import android.widget.ImageView;  
4.   
5. import java.io.IOException;  
6. import java.net.HttpURLConnection;  
7. import java.net.MalformedURLException;  
8. import java.net.URL;  
9. import java.util.concurrent.ExecutorService;  
10. import java.util.concurrent.Executors;  
11.   
12. /** 
13.  * Created by Administrator on 2016/3/1. 
14.  */  
15. public class ImageLoader {  
16.   
17.     public ImageLoader() {  
18.     }  
19.   
20.     //默认使用内存缓存  
21.     ImageCache imageCache=new MemoryCache();  
22.   
23.     //线程池，线城数量为cpu的数量  
24.     ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());  
25.   
26.     /** 
27.      * 设置要使用哪种缓存 
28.      * @param imageCache 缓存类 
29.      */  
30.     public void setImageCache(ImageCache imageCache) {  
31.         this.imageCache = imageCache;  
32.     }  
33.   
34.     /** 
35.      * 显示图片 
36.      * @param url 图片的url 
37.      * @param imageView 要显示的view 
38.      */  
39.     public void displayImage(final String url, final ImageView imageView) {  
40.         Bitmap bitmap=imageCache.get(url);  
41.   
42.         if(bitmap!=null){  
43.             imageView.setImageBitmap(bitmap);  
44.             return;  
45.         }  
46.         imageView.setTag(url);  
47.         mExecutorService.submit(new Runnable() {  
48.             @Override  
49.             public void run() {  
50.                 Bitmap bitmap = downloadImage(url);  
51.                 if (bitmap == null) {  
52.                     return;  
53.                 }  
54.                 if (imageView.getTag().equals(url)) {  
55.                     imageView.setImageBitmap(bitmap);  
56.                 }  
57.                 //添加到缓存  
58.                 imageCache.put(url, bitmap);  
59.             }  
60.         });  
61.     }  
62.   
63.     /** 
64.      * 下載圖片 
65.      * @param imageUrl 网络图片地址 
66.      * @return 返回bitmap对象 
67.      */  
68.     public Bitmap downloadImage(String imageUrl) {  
69.         Bitmap bitmap = null;  
70.         try {  
71.             URL url = new URL(imageUrl);  
72.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
73.             bitmap = BitmapFactory.decodeStream(conn.getInputStream());  
74.             conn.disconnect();  
75.         } catch (MalformedURLException e) {  
76.             e.printStackTrace();  
77.         } catch (IOException e) {  
78.             e.printStackTrace();  
79.         }  
80.         return bitmap;  
81.     }  
82. }  

在ImageLoader中，我们去掉了其他的缓存类，只加入了ImageCache接口，而且还开放了一个设置缓存的方法，也就是通常说的依赖注入，经过以上修改之后，用户的使用方式如下：

[java] view plain copy

1. <span style="white-space:pre">    </span>ImageLoader imageLoader=new ImageLoader();  
2.         /** 
3.          * 内存缓存方式 
4.          */  
5.         imageLoader.setImageCache(new MemoryCache());  
6.         /** 
7.          * SD卡缓存方式 
8.          */  
9.         imageLoader.setImageCache(new DiskCache());  
10.         /** 
11.          * 双缓存方式 
12.          */  
13.         imageLoader.setImageCache(new DoubleCache());  
14.         /** 
15.          * 自定义缓存方式 
16.          */  
17.         imageLoader.setImageCache(new ImageCache() {  
18.             @Override  
19.             public void put(String url, Bitmap bitmap) {  
20.                 //用户自定义的缓存方式  
21.             }  
22.   
23.             @Override  
24.             public Bitmap get(String url) {  
25.                 //从缓存中获取图片  
26.                 return null;  
27.             }  
28.         });  

通过以上的修改，发现现在的ImageLoader的可扩展性、灵活性变的很高，三种缓存方式各自的具体实现都不一样，但是他们都实现了ImageCache接口，即有了这个标准，而用户想要自定义缓存实现的时候，只需要实现ImageCache接口，将其setImageCache进去即可。

以上就是开闭原则，对于修改是封闭的，对于扩展是开发的，遵循开闭原则的重要手段应该是通过抽象，由于实际开发中，可能会不尽人意，但是我们在设计的时候，应该尽量通过扩展的方式，这里说尽量是因为，可能原本的代码就是有问题的，必须要修改。