设计原则笔记

单一职责

single responsibility principle(SRP)一个类应该仅有一个引起它变化的原因：一个类应该是一组相关性很高的函数、数据的封装。
优化ImageLoader
    思路：拆分功能独立的模块进行封装

开闭原则

单一职责原则英文名Single Responsibility Principle,缩写SRP
定义:就一个类而言,应该仅有一个引起它变化的原因,简单来说,一个类中应该是一组相关性很高的函数,数据的封装.(界限因情况而定)

public class ImageLoader {
    LruCache

缓存功能
    public class OptimizingImageCache {
    LruCache

public class OptimizingImagLoader {
    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    //单一职责,缓存功能只做缓存的工作
    OptimizingImageCache mImageCache = new OptimizingImageCache();
    public void displayImage(final String url, final ImageView imageView) {
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = dowloadImage(url);
                if (bitmap == null) {
                    return;
                }
                if (imageView.getTag().equals(url)) {
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url, bitmap);
            }
        });
    }
    public Bitmap dowloadImage(String imageUrl) {
        Bitmap bitmap = null;
        try {
            URL url = new URL(imageUrl);
            final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(connection.getInputStream());

        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

接口隔离

import java.io.Closeable;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public final class CloseUtils {
    private CloseUtils(){
    }
    public static void closeQuietly(Closeable closeable){
    if(closeable!=null){
        try {
            closeable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    }
    //FileOutputStream 父类实现了Closeable接口，通过封装CloseUtils进行统一管理
    public void put(String url, Bitmap bitmap) {
        FileOutputStream fileOutputStream=null;
        try {
            fileOutputStream=new FileOutputStream(cacheDir+url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            CloseUtils.closeQuietly(fileOutputStream);
        }
    }

依赖倒置

• 模块之间依赖通过抽象发生，实现类之间不发生直接的依赖关系，其次依赖关系是通过接口或者抽象类产生的。

public class ImageLoader {
//对于细节依赖
        ImageCache mImageCache = new ImageCache();
        ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
        public void setImageCache(ImageCache cache) {
            this.mImageCache = cache;
        }

    public class ImageLoader {
    //对于抽象依赖，初始有一个默认实现
        ImageCache mImageCache = new MemoryCache();
        ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
        public void setImageCache(ImageCache cache) {
            this.mImageCache = cache;
        }

迪米特原则-更好的扩展性

迪米特原则英文全称为Law of Demeter,缩写LOD 也成为最少知识原则(Least Knowledge Principle)即:一个对象应该对其他对象有最少的了解.通俗的讲--一个类应该对自己需要耦合或者调用的类知道得最少,类内部如何实现与调用或者依赖者关系,调用者或依赖者只需要知道它需要的方法即可,其他一概不管.
先看一下下面的demo

房子信息
    public class Room {
    public float area;
    public float price;
    public Room(float area, float price) {
        this.area = area;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Room[area=" + area + ",price=" + price + "]";
    }
}

中介
    public class Mediator {
    List mRooms = new ArrayList();

    Mediator() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }
    public List getAllRooms() {
        return mRooms;
    }
}

租户
    public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;

    public void rentRoom(Mediator mediator) {
        List rooms = mediator.getAllRooms();
        for (Room room : rooms) {
            if (isSuitable(room))
                System.out.println("租到房子了!" + room);
            break;
        }
    }
    private boolean isSuitable(Room room) {
        return Math.abs(room.price) > diffPrice && Math.abs(room.area) > diffArea;
    }
}

上面代码用户Tenant 不仅依赖了Mediator类还需要频繁的与Room类打交道,租户的需求只是找到适合的房子,如果把这些检索条件都放在tenant类中那么中介的功能就被弱化,导致tenant与room类耦合较高,那么从用户的角度来看,我的"朋友"是Mediator类,需要的信息来自于它.
代码调整后如下(主要对Mediator以及Tenant类)

public class Mediator_Op {
    List mRooms = new ArrayList();
    public Mediator_Op() {
        for (int i = 0; i < 5; i++) {
            mRooms.add(new Room(14 + i, (14 + i) * 150));
        }
    }
    //符合条件的房子输出给用户
    public Room rentOut(float area, float price) {
        for (Room room : mRooms) {
            if (isSuitable(room, area, price)) {
                return room;
            }
        }
        return null;
    }
    //判断条件在中介内完成
    private boolean isSuitable(Room room, float area, float price) {
        return Math.abs(room.price - price) > Tenant.diffPrice && Math.abs(room.area - area) > Tenant.diffArea;
    }
}

public class Tenant_op {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = 100.0001f;
    public static final float diffArea = 0.00001f;
    //只需要拿到结果
    public void rentRoom(Mediator_Op mediator) {
        System.out.println("租到房子了!" + mediator.rentOut(roomArea, roomPrice));
    }
}

    参考文献<<android源码设计模式解析与实战>>