享元模式是对象的结构模式。享元模式以共享的方式高效地支持大量的细粒度对象。享元对象能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态可以共享,外蕴状态不可以共享。内蕴状态和外蕴状态相互独立。
单纯享元模式有以下角色:
/**
* 抽象享元
*/
abstract public class Flyweight {
// 业务方法,参数state是外蕴状态(状态数据类型可以是其他,根据业务传入合适类型)
abstract public void operation(String state);
}
/**
* 具体享元
*/
public class ConcreteFlyweight extends Flyweight {
// 内蕴状态(状态数据类型可以是其他,根据业务传入合适类型)
private Character intrinsicState = null;
// 内蕴状态作为参量传入
public ConcreteFlyweight(Character state) {
this.intrinsicState = state;
}
// 外蕴状态作为参量传入方法中,改变方法的行为,但是并不改变对象的内蕴状态(状态数据类型可以是其他,根据业务传入合适类型)。
@Override
public void operation(String state) {
// 业务方法,根据实际业务编码
System.out.println("Intrinsic State = "
+ intrinsicState
+ ", Extrinsic State = "
+ state);
}
}
/**
* 享元工厂
*/
public class FlyweightFactory {
private final HashMap<Character, Flyweight> pool = new HashMap<>();
public FlyweightFactory() {
}
// 内蕴状态作为参量传入
public Flyweight factory(Character state) {
if (pool.containsKey(state)) {
return pool.get(state);
} else {
Flyweight fly = new ConcreteFlyweight(state);
pool.put(state, fly);
return fly;
}
}
}
/**
* 客户端
*/
public class FlyweightClient {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight fly = null;
fly = factory.factory(new Character('a'));
fly.operation("First Call");
fly = factory.factory(new Character('b'));
fly.operation("Second Call");
fly = factory.factory(new Character('c'));
fly.operation("Third Call");
}
}
单纯享元模式有以下角色:
/**
* 抽象享元
*/
abstract public class Flyweight {
// 业务方法,参数state是外蕴状态(状态数据类型可以是其他,根据业务传入合适类型)
abstract public void operation(String state);
}
/**
* 具体享元
*/
public class ConcreteFlyweight extends Flyweight {
// 内蕴状态(状态数据类型可以是其他,根据业务传入合适类型)
private Character intrinsicState = null;
// 内蕴状态作为参量传入
public ConcreteFlyweight(Character state) {
this.intrinsicState = state;
}
// 外蕴状态作为参量传入方法中,改变方法的行为,但是并不改变对象的内蕴状态(状态数据类型可以是其他,根据业务传入合适类型)。
@Override
public void operation(String state) {
// 业务方法,根据实际业务编码
System.out.println("Intrinsic State = "
+ intrinsicState
+ ", Extrinsic State = "
+ state);
}
}
/**
* 复合享元
*/
public class ConcreteCompositeFlyweight extends Flyweight {
private final HashMap<Character, Flyweight> flies = new HashMap<>();
public ConcreteCompositeFlyweight() {
}
public void add(Character key, Flyweight fly) {
flies.put(key, fly);
}
@Override
public void operation(String state) {
Flyweight flyweight = null;
Iterator<Map.Entry<Character, Flyweight>> iterator = flies.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Character, Flyweight> e = iterator.next();
flyweight = e.getValue();
flyweight.operation(state);
}
}
}
/**
1. 享元工厂
*/
public class FlyweightFactory {
private final HashMap<Character, Flyweight> flies = new HashMap<>();
public FlyweightFactory() {
}
// 单纯享元工厂方法,内蕴状态作为参量传入
public Flyweight factory(Character state) {
if (flies.containsKey(state)) {
return flies.get(state);
} else {
Flyweight fly = new ConcreteFlyweight(state);
flies.put(state, fly);
return fly;
}
}
// 复合享元工厂方法
public Flyweight factory(List<Character> compositeStates) {
ConcreteCompositeFlyweight compositeFlyweight = new ConcreteCompositeFlyweight();
for (int i = 0; i < compositeStates.size(); i++) {
Character state = compositeStates.get(i);
compositeFlyweight.add(state, factory(state));
}
return compositeFlyweight;
}
}
参考:
https://blog.csdn.net/justloveyou_/article/details/55045638
https://www.cnblogs.com/bastard/archive/2012/02/06/2340544.html
http://c.biancheng.net/view/1371.html