依赖倒置原则、接口隔离原则、迪米特原则

设计模式

原文链接：https://www.zybuluo.com/Tyhj/note/1213966

依赖倒置原则

定义：

• 高层模块不应该依赖底层模块
• 抽象不应该依赖细节
• 细节应该依赖抽象

接口隔离原则

定义：

使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(new File(cacheDir, URLEncoder.encode(url, "UTF-8")));
            bmp.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

java中有一个Closeable接口，标志了一个可关闭的对象，只有一个close方法；FileOutputStream也实现了这个接口

新建一个方法来统一关闭这些对象

public class CloseUtil {
    /**
     * 关闭Closeable对象
     * @param closeable
     */
    public static void closeQuietly(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    public void put(String url, Bitmap bmp) {
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(new File(cacheDir, URLEncoder.encode(url, "UTF-8")));
            bmp.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            CloseUtil.closeQuietly(fileOutputStream);
        }
    }

在使用接口隔离原则时，我们需要注意控制接口的粒度，接口不能太小，如果太小会导致系统中接口泛滥，不利于维护；接口也不能太大，太大的接口将违背接口隔离原则，灵活性较差，使用起来很不方便。一般而言，接口中仅包含为某一类用户定制的方法即可，不应该强迫客户依赖于那些它们不用的方法。

迪米特原则

定义：一个对象应该对其他对象保持最少的了解
迪米特法则还有一个更简单的定义：只与直接的朋友通信

类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大

首先来解释一下什么是直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

举个租房的栗子

//房子
public class Room {
    //位置
    public float area;
    //价格
    public float price;
}

//中介
public class Mediator {
    List<Room> roomList = new ArrayList<>();
    public Mediator() {
        roomList.add(new Room(2, 3));
        roomList.add(new Room(2, 4));
    }
    /**
     * 获取房子
     *
     * @return
     */
    public List<Room> getRoomList() {
        return roomList;
    }
}

//租户
public class Tenant {
    //理想价格
    public float roomPrice;
    //理想位置
    public float roomArea;
    //可接受范围
    public static final float diffPrice = 100f;
    public static final float diffArea = 0.005f;
    /**
     * 租房子
     * @param mediator
     */
    public void rentRoom(Mediator mediator) {
        List<Room> roomList = mediator.getRoomList();
        for (Room room : roomList) {
            if (isSuitable(room)) {
                Log.e("租房子", "租到了");
                break;
            }
        }
    }
    //判断合不合适
    private boolean isSuitable(Room room) {
        return Math.abs(room.price - roomPrice) < diffPrice && Math.abs(room.area - roomArea) < diffArea;
    }
}

耦合太高，需要解耦

//中介
public class Mediator {
    List<Room> roomList = new ArrayList<>();
    public Mediator() {
        roomList.add(new Room(2, 3));
        roomList.add(new Room(2, 4));
    }
    /**
     * 获取房子
     *
     * @return
     */
    public List<Room> getRoomList() {
        return roomList;
    }
    /**
     * 租房子
     *
     * @param area
     * @param price
     */
    public Room rentOut(float area, float price) {
        for (Room room : roomList) {
            if (isSuitable(area, price, room)) {
                return room;
            }
        }
        return null;
    }
    //判断合不合适
    private boolean isSuitable(float roomArea, float roomPrice, Room room) {
        return Math.abs(room.price - roomPrice) < Tenant.diffPrice && Math.abs(room.area - roomArea) < Tenant.diffArea;
    }
}

//租客
public class Tenant {
    //理想价格
    public float roomArea;
    //理想位置
    public float roomPrice;
    //可接受范围
    public static final float diffPrice = 100f;
    public static final float diffArea = 0.005f;
    public void rentRoom(Mediator mediator) {
        Log.e("租房子", "租到房子了：" + mediator.rentOut(roomArea, roomPrice));
    }
}