2021-08-16享元模式笔记

享元模式的定义与特点

享元（Flyweight）模式的定义：

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

享元模式的主要优点是：

相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

其主要缺点是：

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

模式的结构

抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

模式的实现

public class FlyweightPattern {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight f01 = factory.getFlyweight("a");
        Flyweight f02 = factory.getFlyweight("a");
        Flyweight f03 = factory.getFlyweight("a");
        Flyweight f11 = factory.getFlyweight("b");
        Flyweight f12 = factory.getFlyweight("b");
        f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
        f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
        f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
        f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
        f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
    }
}
//非享元角色
class UnsharedConcreteFlyweight {
    private String info;
    UnsharedConcreteFlyweight(String info) {
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}
//抽象享元角色
interface Flyweight {
    public void operation(UnsharedConcreteFlyweight state);
}
//具体享元角色
class ConcreteFlyweight implements Flyweight {
    private String key;
    ConcreteFlyweight(String key) {
        this.key = key;
        System.out.println("具体享元" + key + "被创建！");
    }
    public void operation(UnsharedConcreteFlyweight outState) {
        System.out.print("具体享元" + key + "被调用，");
        System.out.println("非享元信息是:" + outState.getInfo());
    }
}
//享元工厂角色
class FlyweightFactory {
    private HashMap<String, Flyweight> flyweights = new HashMap<String, Flyweight>();
    public Flyweight getFlyweight(String key) {
        Flyweight flyweight = (Flyweight) flyweights.get(key);
        if (flyweight != null) {
            System.out.println("具体享元" + key + "已经存在，被成功获取！");
        } else {
            flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
        }
        return flyweight;
    }
}

实例

public interface ChessPieces {//抽象享元角色

	public void operation(Type type);
}


public class Type {//非享元角色
private String info;

public Type(String info) {
	
	this.info = info;
}

public String getInfo() {
	return info;
}

public void setInfo(String info) {
	this.info = info;
}
}
public class WhitePieces implements ChessPieces {//具体享元角色

	@Override
	public void operation(Type type) {
		System.out.print("共享元信息：这是白子");
		System.out.println("非共享元信息："+type.getInfo());
		
	}


public class BlackPieces implements ChessPieces {//具体享元角色

	@Override
	public void operation(Type type) {
		// TODO Auto-generated method stub
		System.out.print("共享元信息：这是黑子");
		System.out.println("非共享元信息："+type.getInfo());
	}

}
public class WeiqiFactory {//享元角色工厂
	  private ArrayList<ChessPieces> qz;
public WeiqiFactory() {
	 qz = new ArrayList<ChessPieces>();
     ChessPieces w = new WhitePieces();
     qz.add(w);
     ChessPieces b = new BlackPieces();
     qz.add(b);
}
public ChessPieces getChessPieces(String ty) {
    if (ty.equalsIgnoreCase("w")) {
        return (ChessPieces) qz.get(0);
    } else if (ty.equalsIgnoreCase("b")) {
        return (ChessPieces) qz.get(1);
    } else {
        return null;
    }
}
}
public class Chessboard {//测试类

	public static void main(String[] args) {
		WeiqiFactory w1=new WeiqiFactory();
		ChessPieces ches=w1.getChessPieces("w");
				ches.operation(new Type("白玉"));
	}

}