中介模式的java实现

应该所有人都接触过中介。我刚毕业的时候刚开始没想找中介，因为中介贵呀。可是到最后还是找了中介。。为啥？因为我觉得貌似我的时间更值钱一点，而且确实，在北京找房子不用中介太难了，更重要的一点是，我顺着58上的个人出租信息找过去，都是那种小中介，甚至还见过一个中介把3居隔出7个小房间的。。。

后来想了想，还是找个大点的中介吧，虽然贵点，至少放心，还能空出时间做点自己的事。

扯远了，为啥找中介？因为我对租房不了解，中介是专业的，这在程序上的表现就是我不需要知道租房的逻辑，交给中介就行了，我有我自己的事，我也不用跟房主打交道，不用中介的时候确实很麻烦，因为我一个人对着很多房主，所以万一我修改计划了，我得挨个通知每个房主（这就是程序里面的一个类跟多个类耦合，所以一个类的修改可能要导致多个类的修改，这就是耦合程度过高，是大忌）。用了中介以后，我只用跟中介打交道就行了，不管多少房子，只有一个中介，很大程度上把我和房主的联系松散掉了（解耦，设计模式最重要的功能）。

找中介的坏处是什么？万一中介坑你（表现在程序上就是中介类挂了），那可能坑的就是很多人了，因为所有的房主跟所有找房子的人都跟中介联系，所以中介太重要了。。。还有一点就是如果很多人找中介，可能导致中介很臃肿（想想现在的链家多大就知道了）。。这在程序上的表现就是很难维护了（天知道链家是干嘛的，据说今年招了很多程序员，一卖房子的招那么多程序员，还怎么维护。。。）

扯得多了，还是上代码吧：

抽象中介类：

/**  
* AbMediator: 抽象中介类
* @author xuejupo  [email protected] 
* create in 2015-12-26 下午11:42:13  
*    
*/
abstract class AbMediator {
	// 中介名字
	protected String name = "隔壁有老王房产中介";
	// 定义中介房源
	protected HashSet<String> hourse = new HashSet<String>();
	//初始化一定的房源信息
	{
		hourse.add("1平方的房子");
		hourse.add("2平方的房子");
		hourse.add("3平方的房子");
		hourse.add("4平方的房子");
	}

	// 定义同事类:
	protected Buyer buyer;
	protected Seller sell;

	// 一个中介，同时只接待一个买房者或卖房者
	public final Buyer getBuyer() {
		return buyer;
	}

	public final void setBuyer(Buyer buyer) {
		System.out.println("哎呦喂，是" + buyer.name + "您老人家，您可好久不来了，这次您要买什么样子的房子!");
		this.buyer = buyer;
	}

	public final Seller getSell() {
		return sell;
	}

	public final void setSell(Seller sell) {
		System.out.println("哎呦喂，是" + sell.name + "您老人家，您可好久不来了，这次您要卖什么样子的房子!");
		this.sell = sell;
	}

	/**
	 * getMessage: 中介查询房源数据库中是否有具体的房子
	 * 
	 * @param hourseInfo
	 *            void 返回类型
	 */
	public abstract void getMessage(String hourseInfo);

	/**
	 * addMessage: 中介将房子放入到房源数据库中
	 * 
	 * @param hourseInfo
	 *            void 返回类型
	 */
	public abstract void addMessage(String hourseInfo);

	/**
	 * getAllMessage: 中介将所有房源展现 void 返回类型
	 */
	public void getAllMessage() {
		int i = 1;
		for (String hourseName : this.hourse) {
			System.out.println("房源" + i++ +":"+ hourseName);
		}
	}
}

具体中介类：

/**  
* ConMediator: 具体中介类
* @author xuejupo  [email protected] 
* create in 2015-12-26 下午11:42:37  
*    
*/
class ConMediator extends AbMediator {

	@Override
	public void getMessage(String hourseInfo) {
		// TODO Auto-generated method stub
		if (this.hourse.contains(hourseInfo)) {
			System.out.println("巧了，您来的真是时候，正好有个房源，大家都在抢，您要是想要我给您留着");
		} else {
			System.out.println("真不巧，您说的这套房子太抢手，已经被人抢了，您来晚一步，不过我们还有别的房源，您要不要看下");
		}
	}

	@Override
	public void addMessage(String hourseInfo) {
		// TODO Auto-generated method stub
		System.out.println("好，帮您放到我们的数据库里面了，您放下，一定给您卖个好价钱");
		this.hourse.add(hourseInfo);
	}
}

抽象的买房者：

/**
 * Buyer: 买房者抽象类
 * 
 * @author xuejupo [email protected] create in 2015-12-25 下午3:48:14
 * 
 */
abstract class Buyer {
	protected String name;
	protected AbMediator mediator;

	/**
	 * 
	 * askMediator: 买房者询问房产信息
	 * 
	 * @param hourseInfo
	 *            void 返回类型
	 */
	abstract void askMediator(String hourseInfo);

	/**
	 * 买房者询问所有房产信息 askAllMessage: void 返回类型
	 */
	abstract void askAllMessage();
}

具体的买房人：

/**
 * ConBuyer: 具体买房类
 * 
 * @author xuejupo [email protected] create in 2015-12-25 下午4:32:02
 * 
 */
class ConBuyer extends Buyer {

	public ConBuyer(String name, AbMediator mediator) {
		this.name = name;
		this.mediator = mediator;
	}

	@Override
	void askMediator(String hourseInfo) {
		// TODO Auto-generated method stub
		System.out.println("问一下，你们  " + this.mediator.name + "  有没有这样的房子:"
				+ hourseInfo);
		this.mediator.getMessage(hourseInfo);
	}

	@Override
	void askAllMessage() {
		// TODO Auto-generated method stub
		System.out.println("给我看一下你们所有房源吧");
		this.mediator.getAllMessage();
	}

}

抽象的卖房者：

/**
 * Seller: 卖房者抽象类
 * 
 * @author xuejupo [email protected] create in 2015-12-25 下午3:48:23
 * 
 */
abstract class Seller {
	protected String name;
	protected AbMediator mediator;

	// 卖房的告诉中介，我要卖房
	abstract void askMediator(String houseInfo);
}

具体的卖房类：

/**  
* ConSell: 具体卖房类
* @author xuejupo  [email protected] 
* create in 2015-12-26 下午11:44:25  
*    
*/
class ConSell extends Seller {
	public ConSell(String name, AbMediator mediator) {
		this.name = name;
		this.mediator = mediator;
	}

	@Override
	void askMediator(String houseInfo) {
		// TODO Auto-generated method stub
		this.mediator.addMessage(houseInfo);
	}

}

测试类：

public class Mediator {

	/**
	 * main:
	 * 
	 * @param args
	 *            void 返回类型
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义一个房产中介
		AbMediator mediator = new ConMediator();
		//定义一个买房的和一个卖房的，买房者和卖房者跟对方都不发生关系，只跟中介发生关系
		Buyer buyer = new ConBuyer("张三", mediator);
		Seller sell = new ConSell("李四", mediator);
		//买房者和卖房者都来找中介，都跟中介发生关系
		System.out.println("---------买房的来找中介：----------");
		mediator.setBuyer(buyer);
		System.out.println("---------买房的问中介：----------");
		buyer.askMediator("100平的房子");
		System.out.println("---------买房的问中介要所有房源：----------");
		buyer.askAllMessage();
		System.out.println("---------卖房的来找中介：----------");
		mediator.setSell(sell);
		System.out.println("---------卖房的把房子交给中介：----------");
		sell.askMediator("100平的房子");
		System.out.println("---------买房的再问中介：----------");
		buyer.askMediator("100平的房子");
	}
}

可以看到，买房者和卖房者都不知道对方存在，只跟中介打交道就可以了，表现在程序上就是如果买房类或者卖房类有什么变化，只用修改他们自己和中介即可，最大程度上实现了类间的解耦。

测试结果：

---------买房的来找中介：----------
哎呦喂，是张三您老人家，您可好久不来了，这次您要买什么样子的房子!
---------买房的问中介：----------
问一下，你们  隔壁有老王房产中介  有没有这样的房子:100平的房子
真不巧，您说的这套房子太抢手，已经被人抢了，您来晚一步，不过我们还有别的房源，您要不要看下
---------买房的问中介要所有房源：----------
给我看一下你们所有房源吧
房源1:4平方的房子
房源2:1平方的房子
房源3:2平方的房子
房源4:3平方的房子
---------卖房的来找中介：----------
哎呦喂，是李四您老人家，您可好久不来了，这次您要卖什么样子的房子!
---------卖房的把房子交给中介：----------
好，帮您放到我们的数据库里面了，您放下，一定给您卖个好价钱
---------买房的再问中介：----------
问一下，你们  隔壁有老王房产中介  有没有这样的房子:100平的房子
巧了，您来的真是时候，正好有个房源，大家都在抢，您要是想要我给您留着

中介模式的java实现

猜你喜欢