享元模式是一种有效地支持大量细粒度对象的设计模式，通过共享技术减少内存开销。文章介绍了FlyweightFactory（享元工厂）如何创建和管理享元对象，以及如何区分内部状态（不随环境变化）和外部状态（可变）。在Java中，字符串常量池是一个享元模式的例子，它优化了内存使用，确保相同字符串只需存储一次。
享元模式
享元模式（Flyweight），运用共享技术有效的支持大量细粒度的对象。
FlyweightFactory，享元工厂，负责创建管理享元对象。
Flyweight，所有具体享元类的超类或接口。
ConcreteFlyweight，需要共享的具体享元类。
UnsharedConcreteFlyweight，不需要共享的具体享元类。
Flyweight
abstract class Flyweight {
public abstract void operation(int extrinsicstate);
}
需要共享的具体Flyweight子类
class ConcreteFlyweight extends Flyweight {
public void operation(int extrinsicstate){
System.out.println("具体Flyweight:"+extrinsicstate);
}
}
不需要共享的Flyweight子类
class UnsharedConcreteFlyweight extends Flyweight {
public void operation(int extrinsicstate){
System.out.println("不共享的具体Flyweight:"+extrinsicstate);
}
}
享元工厂
class FlyweightFactory {
private Hashtable<String,Flyweight> flyweights = new Hashtable<String,Flyweight>();
public FlyweightFactory(){
flyweights.put("X", new ConcreteFlyweight());
flyweights.put("Y", new ConcreteFlyweight());
flyweights.put("Z", new ConcreteFlyweight());
}
public Flyweight getFlyweight(String key) {
return (Flyweight)flyweights.get(key);
}
}
客户端
public class Test {
public static void main(String[] args) {
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
int extrinsicstate = 22;
FlyweightFactory f = new FlyweightFactory();
// 需要共享的类，从工厂得到。
Flyweight fx = f.getFlyweight("X");
fx.operation(--extrinsicstate);
Flyweight fy = f.getFlyweight("Y");
fy.operation(--extrinsicstate);
Flyweight fz = f.getFlyweight("Z");
fz.operation(--extrinsicstate);
// 不需要共享的类，直接实例化。
Flyweight uf = new UnsharedConcreteFlyweight();
uf.operation(--extrinsicstate);
System.out.println();
System.out.println("**********************************************");
}
}
在享元模式中，利用工厂得来实现对象的共享，在使用中，需要通过工厂得到享元对象。在工厂中初始化的时候实例化出对象，也可以什么都不做，在需要的时候进行实例化。
享元模式应用
网站共享代码，对于同一分类下的网站，可以使用同一套代码。
抽象的网站类
abstract class WebSite{
public abstract void use();
}
具体网站类
class ConcreteWebSite extends WebSite {
private String name = "";
public ConcreteWebSite(String name) {
this.name = name;
}
public void use() {
System.out.println("网站分类：" + name);
}
}
网站工厂
class WebSiteFactory {
private Hashtable<String,WebSite> flyweights = new Hashtable<String,WebSite>();
//获得网站分类
public WebSite getWebSiteCategory(String key)
{
if (!flyweights.contains(key))
flyweights.put(key, new ConcreteWebSite(key));
return (WebSite)flyweights.get(key);
}
//获得网站分类总数
public int getWebSiteCount()
{
return flyweights.size();
}
}
客户端
public class Test {
public static void main(String[] args) {
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
WebSiteFactory f = new WebSiteFactory();
WebSite fx = f.getWebSiteCategory("产品展示");
fx.use();
WebSite fy = f.getWebSiteCategory("产品展示");
fy.use();
WebSite fz = f.getWebSiteCategory("产品展示");
fz.use();
WebSite fl = f.getWebSiteCategory("博客");
fl.use();
WebSite fm = f.getWebSiteCategory("博客");
fm.use();
WebSite fn = f.getWebSiteCategory("博客");
fn.use();
System.out.println("网站分类总数为:"+f.getWebSiteCount()); //统计实例化个数，结果应该为2
System.out.println();
System.out.println("**********************************************");
}
}
在网站工厂中，如果已经有了相同类型的网站，则会直接返回已有的对象，如果没有该类型的网站，则会创建出来对象，放入哈希表中。
通过工厂实现了相同类别网站共享相同的对象。
内部状态和外部状态
在享元对象内部并且不会随环境改变而改变的共享部分，可以称为享元对象的内部状态，而随环境改变而改变的，不可以共享的状态就是外部状态。
将外部状态放在外部进行存储，当调用享元对象进行操作时，将外部状态传递给享元对象。
在网站中，客户的账号就是外部状态，应该放在外部，由专门的对象来处理。
用户类（存储享元对象的外部状态）
class User{
private String name;
public User(String value){
this.name=value;
}
public String getName(){
return this.name;
}
}
抽象的网站类
abstract class WebSite{
public abstract void use(User user);
}
具体网站类
class ConcreteWebSite extends WebSite {
private String name = "";
public ConcreteWebSite(String name) {
this.name = name;
}
// 调用的时候，将外部状态传递过来
public void use(User user) {
System.out.println("网站分类：" + name+" 用户："+user.getName());
}
}
网站工厂
class WebSiteFactory {
private Hashtable<String,WebSite> flyweights = new Hashtable<String,WebSite>();
//获得网站分类
public WebSite getWebSiteCategory(String key)
{
if (!flyweights.contains(key))
flyweights.put(key, new ConcreteWebSite(key));
return (WebSite)flyweights.get(key);
}
//获得网站分类总数
public int getWebSiteCount()
{
return flyweights.size();
}
}
客户端
public class Test {
public static void main(String[] args) {
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
WebSiteFactory f = new WebSiteFactory();
WebSite fx = f.getWebSiteCategory("产品展示");
// 调用的时候，将外部状态传递过来
fx.use(new User("小菜"));
WebSite fy = f.getWebSiteCategory("产品展示");
fy.use(new User("大鸟"));
WebSite fz = f.getWebSiteCategory("产品展示");
fz.use(new User("娇娇"));
WebSite fl = f.getWebSiteCategory("博客");
fl.use(new User("老顽童"));
WebSite fm = f.getWebSiteCategory("博客");
fm.use(new User("桃谷六仙"));
WebSite fn = f.getWebSiteCategory("博客");
fn.use(new User("南海鳄神"));
System.out.println("网站分类总数为:"+f.getWebSiteCount());
System.out.println();
System.out.println("**********************************************");
}
}
在调用享元对象的时候，将外部状态传递给享元对象。
享元模式总结
何时应用享元模式？
如果一个应用程序使用了大量的对象，而大量的这样对象造成了很大的存储开销时，就应该考虑使用。还有就是对象的大多数状态可以是外部状态，如果删除了外部状态，就可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。
享元模式，共享了对象，可以减少实例，可以节约存储空间。
享元模式的应用，在Java中，字符串常量池就是运用了享元模式。
String titleA = new String("大话设计模式");
String titleB = new String("大话设计模式");
System.out.println(" titleA==titleB: " + (titleA == titleB)); // 输出 false
System.out.println(" titleA.equals(titleB): " + (titleA.equals(titleB))); // 输出 true
String titleC = "大话设计模式";
String titleD = "大话设计模式";
System.out.println(" titleC==titleD: " + (titleC == titleD)); // 输出 true
System.out.println(" titleC.equals(titleD): " + (titleC.equals(titleD))); // 输出 true
对于相同的字符串，只创建了一份，下次再创建已有的字符串，只是将引用指向同一个地址。（new 是显示创建新的对象，所以创建了两个对象。）
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
