OK，我们先来看一个找对象的例子：
简单说下，Person类的每个实例之间，要发生关系（好猥琐~~~）… 其中，Person类中的抽象方法getPartner()在Man和Woman子类中都有自己的实现，当Man找到Woman且他们的property值相等时，才算配对成功，反之……..
首先，有一个Person抽象类：
//Person.java
package com.wj.ex1;
public abstract class Person {
private String name;//名字
private int property;//财产
public Person(String name, int property) {
this.name = name;
this.property = property;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getProperty() {
return property;
}
public void setProperty(int property) {
this.property = property;
}
//找另一半
public abstract void getPartner(Person person);
}然后，诞生了一个男孩和一个女孩：
//Man.java
package com.wj.ex1;
public class Man extends Person{
public Man(String name, int property) {
super(name, property);
}
@Override
public void getPartner(Person person) {
if(person instanceof Man){
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"sorry,我觉得单身挺好...");
}else if(person instanceof Woman){
if(this.getProperty() == person.getProperty()){
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"ok,咱们在一起吧...");
}else{
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"穷逼，咱们不合适...");
}
}else{
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"sorry,我不是辣么随便的男孩...");
}
}
}//Woman.java
package com.wj.ex1;
public class Woman extends Person{
public Woman(String name, int property) {
super(name, property);
}
@Override
public void getPartner(Person person) {
if(person instanceof Woman){
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"sorry,我觉得单身挺好...");
}else if(person instanceof Man){
if(this.getProperty() == person.getProperty()){
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"ok,咱们在一起吧...");
}else{
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"穷逼，咱们不合适...");
}
}else{
System.out.println("【"+person.getName()+"】对【"+this.getName()+"】说："+"sorry,我不是辣么随便的女孩...");
}
}
}
然后，这是一个测试类：
//MainClass.java
package com.wj.ex1;
public class MainClass {
public static void main(String[] args) {
Person zhangsan = new Man("张三",1000);
Person lisi = new Man("李四", 2000);
Person xiaofang = new Woman("小芳", 2000);
zhangsan.getPartner(xiaofang);
lisi.getPartner(xiaofang);
}
}
//结果
【小芳】对【张三】说：穷逼，咱们不合适...
【小芳】对【李四】说：ok,咱们在一起吧...
这个狠简单吧~~~
但是，有一天，女孩发现，虽然男孩有钱，但是特么丑啊，生下的小孩也丑啊，虽然有些人是穷逼吧，但是长得帅啊。。。
所以，女孩的择偶标准发生了变化~~~
但是程序员不乐意了，这得要改多少代码啊~~女孩的择偶标准的改变，势必会引起男孩的婚姻状况…归根结底，Man类中的getPartner方法中调用了Woman类，同样Woman类中也调用了Man类。。。这就有点纠缠不清了。。。
要不说程序员是世界上最聪明的一类生物了呢，现在不管你择偶标准怎么变，我给你找一媒婆，有啥要求给媒婆提，，，
所以，这就有了 中介者模式。（你们该不会真的以为中介者模式就是这么来的吧~）
一、什么是中介者模式
Mediator模式也叫中介者模式，是由GoF提出的23种软件设计模式的一种。Mediator模式是行为模式之一，在Mediator模式中，类之间的交互行为被统一放在Mediator的对象中，对象通过Mediator对象同其他对象交互，Mediator对象起着控制器的作用。
二、中介者模式的结构
三、中介者模式的角色和职责
mediator
中介者类的抽象父类。
concreteMediator
具体的中介者类。
colleague
关联类的抽象父类。
concreteColleague
具体的关联类。
四、中介者模式的优点
1，将系统按功能分割成更小的对象，符合类的最小设计原则
2，对关联对象的集中控制
3，减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中任何一个类的修改都会影响到其他类，不符合类的设计的开闭原则 ，而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，当其中一个类修改时，可以对其他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4，有利于提高类的重用性
好，现在重写上面的案例：
根据前面的中介者的结构：
//Mediator.java
//中介者接口
package com.wj.ex2;
public abstract class Mediator {
private Man man;
private Woman woman;
public Man getMan() {
return man;
}
public void setMan(Man man) {
this.man = man;
}
public Woman getWoman() {
return woman;
}
public void setWoman(Woman woman) {
this.woman = woman;
}
public abstract void getPartner(Person person);
}
//MeIPoNo1.java
package com.wj.ex2;
/**
* 天下第一媒
*/
public class MeIPoNo1 extends Mediator{
@Override
public void getPartner(Person person) {
//媒婆先确定介绍的一对的情侣
if(person instanceof Man){
this.setMan((Man)person);
}else if(person instanceof Woman){
this.setWoman((Woman)person);
}
//这里要判断一下，要是设置了同性，即如果设置了俩男孩纸，而没有设置女孩纸的话，那么，在媒婆看来，这是不合法的，因为媒婆只介绍一男一女的~~~像撮合俩男生这种好事，她一般是不会干的~~~
if(getMan()==null || getWoman() ==null){
System.out.println("媒婆：Sorry，你们的结合不合法~~~");
}else{
if(getMan().getProperty()== getWoman().getProperty()){
System.out.println("【"+getWoman().getName()+"】对【"+getMan().getName()+"】说："+"ok,咱们在一起吧...");
}else{
System.out.println("【"+getWoman().getName()+"】对【"+getMan().getName()+"】说："+"丑逼，我们不合适...");
}
}
};
}
//Person.java
package com.wj.ex2;
public abstract class Person {
private String name;//名字
private int property;//财产
private Mediator meditor;//媒婆（中介）
public Person(String name, int property,Mediator meditor) {
this.name = name;
this.property = property;
this.meditor = meditor;
}
public Mediator getMeditor() {
return meditor;
}
public void setMeditor(Mediator meditor) {
this.meditor = meditor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getProperty() {
return property;
}
public void setProperty(int property) {
this.property = property;
}
//找另一半
public abstract void getPartner(Person person);
}
//Man.java
package com.wj.ex2;
public class Man extends Person{
public Man(String name, int property,Mediator meditor) {
super(name, property,meditor);
}
@Override
public void getPartner(Person person) {
this.getMeditor().setMan(this);
this.getMeditor().getPartner(person);
}
}
//Woman.java
package com.wj.ex2;
public class Woman extends Person{
public Woman(String name, int property,Mediator meditor) {
super(name, property,meditor);
}
@Override
public void getPartner(Person person) {
this.getMeditor().setWoman(this);
this.getMeditor().getPartner(person);
}
}
最后是测试类：
//MainClass.java
package com.wj.ex2;
public class MainClass {
public static void main(String[] args) {
Mediator mediator = new MeIPoNo1();//天下第一媒
Person zhangsan = new Man("张三",7,mediator);//有钱(property=7)但是丑
Person lisi = new Man("李四",1,mediator);//穷逼(property=1)但是帅
Person xiaofang = new Woman("小芳",7,mediator);
zhangsan.getPartner(lisi);//zhangsan + lisi = gay ，媒婆认为不合法 ， 落实到代码处，woman == null
zhangsan.getPartner(xiaofang);
lisi.getPartner(xiaofang);
}
}
//运行结果：
媒婆：Sorry，你们的结合不合法~~~
【小芳】对【张三】说：ok,咱们在一起吧...
【小芳】对【李四】说：丑逼，我们不合适...
代码也是不难理解的啦~~只要你能理解 中介者的结构，就是上面那张图，代码是很容易理解的啦！！！