我的java设计模式 总结【12】构建器 builder & 转换器 wrapper & 桥接 Bridge

构建器

构建器builder 是用于构建复杂的对象的，也没什么好解释的，这个很简单；
举例来说我要创建一个机器人对象，这个机器人对象非常的复杂。可能有好几十种属性，我可以再创建他的时候一次把这几十种属性都通过构造函数传进去，这种方法不是不可以。但是我可以分开创建 头，身子，胳膊，腿，脚等等，对于复杂的对象进行结构化的创建。
常见采用链式编程进行编程。最常见的一般带build语句的都是采用了构建器模式进行的。
再使用过程中与模板方法相同的，只是这里的语义针对对象的构建，而模板方法针对的是方法过程。

转换器

转换器也比较简单，也如他的意思，当一个数据类型无法直接请求另外一个方法，再中间对这个数据进行一次数据转换或者说数据操作可以让其访问那个方法。这中间这个转换或者操作的过程就是转换器。
比如常用的电源接口转换器，就是这意思。
最常见的比如jdk中的inputstream 与reader 是没有办法直接进行使用的，但是通过inputstreamReader进行转换那么inputstream的数据源就可以通过reader来使用了。

	FileInputStream fis = new FileInputStream(new File("aa.txt"));
		InputStreamReader isr = new InputStreamReader(fis);
		BufferedReader reader = new BufferedReader(isr);
		while (true) {
			String s = reader.readLine();
			if (s == null)
				break;
		}

桥接模式

对于桥接模式其核心就是用聚合代替继承
假设一个对象有不同的类型组合比如 M 是类型，N是实现。那么总共会有MN种的类型实现。如果类型增多或者是实现增多会带来无穷无尽的类对象。桥接模式就是为了解决这种无穷无尽的类型对象而构成的。
这个模式其实也很简单。看一下原始代码对于MN的概念先有个了解
这里举例了两个类型与三种实现。

//实现的抽象类
public abstract class Thing {
	abstract String getThing();
}
// 类型的抽象类
public abstract class Type {
	abstract String getType();
}
//具体的三种实现与两种类型
class gun extends Thing {
	@Override
	String getThing() {
		return "gun";
	}
}

class flower extends Thing {
	@Override
	String getThing() {
		return "flower";
	}
}

class pen extends Thing {
	@Override
	String getThing() {
		return "pen";
	}
}

class toy extends Type {
	@Override
	String getType() {
		return "toy";
	}
}

class picture extends Type {
	@Override
	String getType() {
		return "picture";
	}
}

//下面是关键。对于类型与实现的组合 简单例举几种
//
class toyGun{
	toy t;
	gun g;
	public String toString() {
		return t.getType()+" "+g.getThing();
	}
}

class toyPen{
	toy t;
	pen g;
	public String toString() {
		return t.getType()+" "+g.getThing();
	}
}
class picturePen{
	picture t;
	pen g;
	public String toString() {
		return t.getType()+" "+g.getThing();
	}
}

玩具枪，玩具笔，图片笔，那么其实这里的简单例举了三种，那么实际组合可能会有6种，这只是简单的。再实际中类型可能会有很多很多种，实现也会有很多很多种，难道都要去写一个组合类进行抽象描述吗？这肯定不能这么搞啊。所以用聚合的方式代替了这种继承的方式来做。
参考一下类图：

具体代码
这里修改了Type类，当然也可以修改Thing类，都是一样的。谁聚合谁都可以的。

public abstract class Type {
	abstract String getType();
	Thing t;
	public Type () {}
	public Type (Thing t) {
		this.t=t;
	}
	public Thing getThing()
	{
		return t;
	}
	public String toString() {
		return getType()+" "+t.getThing();
	}
}

//关于Type的具体实现
class toy extends Type {
	toy() {}
	toy(Thing t) {
		super(t);
	}
	@Override
	String getType() {
		return "toy";
	}
}

class picutre extends Type {
	picutre(Thing t) {
		super(t);
	}
	@Override
	String getType() {
		return "picture";
	}
}
// 聚合的具体使用
	public static void main(String[] args) {
		System.out.println( new toy(new gun()));
		System.out.println( new toy(new flower()));
		System.out.println( new picutre(new pen()));
		System.out.println( new picutre(new gun()));
	}

通过这样就可以构造不同类型的不同实现了。