面向对象六大原则--迪米特原则

在学习了之前的五个原则后，相信大家对面向对象的精髓有了一定的了解，如果没有学习之前的，建议大家先去学习下面向对象的里氏替换、依赖倒置、接口隔离原则、

迪米特原则

迪米特原则英文全称为Law of Demeter,缩写是LOD，也称为最少知识原则（Least Knowledge Principle）。虽然名字不同，但描述的是同一个原则：一个对象应该对其他对象有最少的了解。通俗的说，一个类应该对自己需要耦合或调用的类知道的最少，类的内部如何实现与调用者或者依赖者没关系，调用者或者依赖者只需要知道它需要的方法即可，其他的可一概不用管。类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。

迪米特法则还有一个英文解释是 Only talk to your immedate friends，翻译过来就是：只与直接的朋友通信。每个对象都必然会与其他对象有耦合关系，两个对象之间的耦合就成为朋友关系，这种关系的类型有很多，如组合、聚合、依赖等。

接下来我们还是用代码来理解吧，我们设定的情况为：我在北京找房子，需要通过中介，我只要求房间的面积和租金，其他一概不管，中介将符合我要求的房子提供给我就可以。

/**
 * 房间
 */
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<Room> mRooms = new ArrayList<Room>();

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

/**
 * 租户
 */
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = f;
    public static final float diffArea = f;
    public void rentRoom(Mediator mediator){
        List<Room> rooms = mediator.getAllRooms();
        for (Room room:rooms) {
            if(isSuitable(room)){
                System.out.println("租到房间啦！ "+room);
                break;
            }
        }
    }
    public boolean isSuitable(Room room){
        return Math.abs(room.price-roomPrice)<diffPrice && Math.abs(room.area - roomArea)<diffArea;
    }
}
           

从上面的代码可以看到，Tenant 不仅依赖了Mediator 类，还需要频繁地与Room类打交道。租户类的要求只是通过中介找到一个适合自己的房间，如果这些检测条件都放在Tenant类中，那么中介的功能就被弱化，而导致Tenant与Room的耦合较高，因为Tenant必须知道许多关于Room的细节。当Room变化时Tenant也必须跟着变化。Tenant又与Mediator耦合，这就出现了纠缠不清的关系，这个时候我们需要分清谁才是我们真正的“朋友”。

既然耦合太严重，我们只能解耦了。首先明确的是，我们只和我们的朋友通信，这里就是指Mediator对象。必须将Room相关的操作从Tenant中移除，而这些操作应该属于Mediator。我们就进行一下重构：

/**
 * 中介
 */
public class Mediator {
    List<Room> mRooms = new ArrayList<Room>();

    public Mediator() {
        for (int i=;i<;i++){
            mRooms.add(new Room(+i, (+i) * ));
        }
    }
    public Room rentOut(float area, float price){
        for (Room room:mRooms){
            if(isSuitable(area,price,room)){
                return room;
            }
        }
        return  null;
    }
    public boolean isSuitable(float area,  float price,  Room room){
        return Math.abs(room.price-price)<Tenant.diffPrice && Math.abs(room.area - area)<Tenant.diffArea;
    }
}
           

/**
 * 租户
 */
public class Tenant {
    public float roomArea;
    public float roomPrice;
    public static final float diffPrice = f;
    public static final float diffArea = f;
    public void rentRoom(Mediator mediator){
        System.out.println("租到房间啦！ "+mediator.rentOut(roomArea,roomPrice));
    }
}
           

只是将对于Room的判定操作移到了Mediator类中，这本应该是Mediator的职责，根据租户设定的条件查找符合要求的房子，并且将结果交给租户就可以。租户并不需要知道太多关于Room的细节。通过上面的可以联想下前几篇博客中提到的ImageLoader加载图片缓存，就拿SD卡缓存来说，ImageCache就是用户的直接朋友，而SD卡缓存内部使用的是DIskLruCache，这个就不属于用户的朋友了。用户只需要与ImageCache打交道即可，用户根本不知道DiskLruCache的实现，这就很好地对用户进行了隐藏具体实现。

博主在学习了面向对象的六大原则后，发现了java面向对象的精髓所在，所难之处在于项目中运用，系统的灵活、稳定，遵循面向对象六大原则是我们软件走向灵活软件的第一步，希望大家在写东西之前一定要多思考，这样才能写出高效的软件。

谢谢大家的阅读，希望大家能有所收获。

下一篇 博主带领大家学习应用最广的单例模式。