面向对象设计6大原则之六（迪米特原则）－更好的扩展性

  迪米特原则也被称为最少知识原则。含义是：一个对象应该对其他对象有最少的了解。通俗的讲，一个类应该对自己需要耦合或调用的类知道得最少，类的内部如何实现与调用者或者依赖者没有关系，调用者或者依赖者只需要知道它需要的方法即可，其他的可一概不管。类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。它还有另外一种解释，与直接的朋友通信。

下面以租房为例，讲解迪米特原则的应用.

我们设定的需求为：我只要求房间的面积和租金，其他的一概不管，中介将符合我要求的房间提供给我。

示例代码如下：

 /**
     * 房间
     */
    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 k = 0;k < 5;k++){
                mRooms.add(new Room(14 + k,(14 + k) * 150));
            }
        }
        public List<Room> 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<Room> 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 - roomPrice) < diffArea && Math.abs(room.area - roomArea) < diffArea;
        }
    }

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

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

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

        public Mediator(){

            for (int k = 0;k < 5;k++){
                mRooms.add(new Room(14 + k,(14 + k) * 150));
            }
        }

        public Room rentOut(float area,float price){
            for (Room room :mRooms){
                if (isSuitable(price,area,room)){
                    return room;
                }

            }
            return null;
        }

        private boolean isSuitable(float roomPrice,float roomArea,Room room){
            return Math.abs(room.price - roomPrice) < Tenant.diffArea && Math.abs(room.area - roomArea) < Tenant.diffArea;
        }
    }
    /**
     * 租户
     */
    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){
            System.out.println("租到房啦" + mediator.rentOut(roomArea,roomPrice));
        }

    }

重构之后，Room类只跟Mediatory关系，是直接的朋友。而Mediator类跟Tenant类发生关系，是直接的朋友。我们只是将Room的判断操作移到啦Mediator中，这本是Mediator类的职责，根据租户设定的条件查找符合要求的房子，并且将结果交给租户就可以了。租户并补需要知道太多关于Room的细节，比如与房东签合同，房东的房产证是不是真的等。我们直接与中介沟通就好了，房东并不是我们直接的朋友。“ 只与直接的朋友通信”这简单几个字就能够将我们从复杂的关系网中抽离出来，使程序耦合度更低，稳定性更好。