单一职责原则(SRP)

SingleResponsibilityPrinciple
一个类只做一件事或者只做某一类事，比如：单例模式。

优化前

/**
* 单一职责原则
* 图片加载类
* 这个类包含图片加载，图片缓存功能，这也是可以优化的地方
*/
public class ImageLoader {
  // 图片缓存
  LruCache<String, Bitmap> mCache;
  // 线程池，线程数量为CPU数量
  ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
  public ImageLoader() {
    initImageCache();
  }
  public void initImageCache() {
    // 计算可使用的最大内存
    int max = (int) (Runtime.getRuntime().maxMemory() / 1024);
    // 取1/4可用内存做缓存
    mCache = new LruCache<String, Bitmap>(size) {
      @Override
      protected int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight() / 1024;
      }
    };
  }
  public void displayImage(String url, ImageView imageView) {
    imageView.setTag(url);
    service.submit(new Runnable() {
      @Override
      public void run() {
        Bitmap bitmap = downloadImage(url);
        if (bitmap == null) {
          return;
        }
        if (imageView.getTag().equals(url)) {
          imageView.setImageBitmap(bitmap);
        }
        mCache.put(url, bitmap);
      }
    });
  }
  public Bitmap downloadImage(String imgUrl) {
    Bitmap bitmap = null;
    try {
      URL url = new URL(imgUrl);
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      bitmap = BitmapFactory.decodeStream(connection.getInputStream());
      connection.disconnect();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return bitmap;
  }
}

优化后

/**
* 单一职责原则
* 图片加载类
*/
public class ImageLoader {
    // 图片缓存
    ImageCache mCache = new ImageCache();
    // 线程池，线程数量为CPU数量
    ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    public void displayImage(String url, ImageView imageView) {
        Bitmap bitmap = mCache.get(url);
        if (null != bitmap) {
            imageView.setImageBitmap(bitmpa);
            return;
        }  
        imageView.setTag(url);
        service.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mCache.put(url, bitmap);
            }
        });
    }
    public Bitmap downloadImage(String imgUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imgUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());
            connection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

/**
* 图片缓存
**/
public class ImageCache {
    LruCache<String,Bitmap> mCache;
    public ImageCache() {
        initImageCache();
    }
    public void initImageCache() {
        // 计算可使用的最大内存
        int max = (int) (Runtime.getRuntime().maxMemory() / 1024);
        // 取1/4可用内存做缓存
        mCache = new LruCache<String, Bitmap>(size) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }
    public Bitmap get(String url) {
        return mCache.get(url);
    }
    public void put(String url,Bitmap bitmap) {
        mCache.put(url,bitmap);
    }
}

ImageLoader：负责加载图片
ImageCache：负责缓存图片

开闭原则(OCP)

OpenClosePrinciple
类，模块，方法等，对于拓展是开放的，修改是封闭的。

里氏替换原则(LSP)

LiskovSubstitutionPrinciple
只要父类能出现的地方子类就可以出现，而且替换子类也不会产生任何错误或异常，使用者根本不需要知道是父类还是子类。
是否可以理解为Object呢？🤔

迪米特原则(LOD)

LawOfDemeter
最少知道原则，一个对象对其他对象保持最少的了解。为什么要保持最少的了解呢？因为越来越复杂的类与类之间的关系，导致耦合度高，就会出现动一发儿牵一身。对比发现和单例模式有点像，又有点藕断丝连的感觉呢。

接口隔离原则(ISP)

InterfaceSegregationPrinciple
类与类之间的依赖关系应该建立在最小的接口上。简而言之：抽象抽象再抽象。

依赖倒置原则(DIP)

DependenceInversionPrinciple
抽象不依赖细节，细节依赖抽象，抽象与细节不可本(抽象)末(细节)倒置。
类与类如果直接依赖细节，倒置耦合，限制拓展，应该面向接口或者抽象编程。

高层模块不应该依赖底层模块，两者都应该依赖其抽象
抽象不应该依赖细节
细节应该依赖抽象

设计模式

设计原则