桥接模式
定义：将抽象和实现解耦，使得两者可以独立地变化。
角色：
Implementor——实现化角色：它是接口或者抽象类，定义角色必需的行为和属性。
ConcreteImplementor——具体实现化角色：它实现接口或抽象类定义的方法和属性。
Abstraction——抽象化角色：它的主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。
RefinedAbstraction——修正角色：它引用实现化角色对抽象化角色进行修正。
public interface Implementor {
//基本方法
public void doSomething();
public void doAnything();
}
public class ConcreteImplementor1 implements Implementor{
public void doSomething(){
//业务逻辑处理
}
public void doAnything(){
//业务逻辑处理
}
}
public class ConcreteImplementor2 implements Implementor{
public void doSomething(){
//业务逻辑处理
}
public void doAnything(){
//业务逻辑处理
}
}
public abstract class Abstraction {
//定义对实现化角色的引用
private Implementor imp;
//约束子类必须实现该构造函数
public Abstraction(Implementor _imp){
this.imp = _imp;
}
//自身的行为和属性
public void request(){
this.imp.doSomething();
}
//获得实现化角色
public Implementor getImp(){
return imp;
}
}
public class RefinedAbstraction1 extends Abstraction {
//覆写构造函数
public RefinedAbstraction1(Implementor _imp){
super(_imp);
}
@Override
public void request(){
super.request();
}
}
public class RefinedAbstraction2 extends Abstraction {
//覆写构造函数
public RefinedAbstraction2(Implementor _imp){
super(_imp);
}
//修正父类的行为
@Override
public void request(){
super.request();
super.getImp().doAnything();
}
}
public class Client {
public static void main(String[] args) {
//定义一个实现化角色
Implementor imp = new ConcreteImplementor1();
//定义一个抽象化角色
Abstraction abs = new RefinedAbstraction1(imp);
//执行行文
abs.request();
}
}
优点：
抽象和实现分离，优秀的扩充能力，客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。
享元模式
定义：使用共享对象可有效地支持大量的细粒度的对象。
Flyweight——抽象享元角色: 它简单地说就是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。
ConcreteFlyweight——具体享元角色: 具体的一个产品类，实现抽象角色定义的业务。
FlyweightFactory——享元工厂: 职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。
//抽象享元角色
public abstract class Flyweight {
//内部状态
private String intrinsic;
//外部状态
protected final String Extrinsic;
//要求享元角色必须接受外部状态
public Flyweight(String _Extrinsic){
this.Extrinsic = _Extrinsic;
}
//定义业务操作
public abstract void operate();
//内部状态的getter/setter
public String getIntrinsic() {
return intrinsic;
}
public void setIntrinsic(String intrinsic) {
this.intrinsic = intrinsic;
}
}
//具体享元角色
public class ConcreteFlyweight1 extends Flyweight{
//接受外部状态
public ConcreteFlyweight1(String _Extrinsic){
super(_Extrinsic);
}
//根据外部状态进行逻辑处理
public void operate(){
//业务逻辑
}
}
//享元工厂
public class FlyweightFactory {
//定义一个池容器
private static HashMap<String,Flyweight> pool= new HashMap<String,Flyweight>();
//享元工厂
public static Flyweight getFlyweight(String Extrinsic){
//需要返回的对象
Flyweight flyweight = null;
//在池中没有该对象
if(pool.containsKey(Extrinsic)){
flyweight = pool.get(Extrinsic);
}else{
//根据外部状态创建享元对象
flyweight = new ConcreteFlyweight1(Extrinsic);
//放置到池中
pool.put(Extrinsic, flyweight);
}
return flyweight;
}
}
使用场景：
系统中存在大量的相似对象。
需要缓冲池的场景。
