享元模式（FlyWeight）

最新推荐文章于 2025-08-19 14:03:46 发布

转载最新推荐文章于 2025-08-19 14:03:46 发布 · 104 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/zhaojianhua/p/8257497.html

文章标签：

#数据库 #java

本文详细介绍了享元模式的原理及应用场景，通过棋子实例代码展示了如何通过享元模式节省内存，同时讨论了其优缺点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

享元模式使用场景：

　　内存属于稀缺资源，不要随便浪费。如果有很多个完全相同或相似的对象，我们可以用通过享元模式，节省内存。

享元模式的核心：

　　享元模式以共享的方式高效的支持大量细粒度对象的重用。

　　享元对象能做到共享的关键是区分了内部状态和外部状态。内部状态：可以共享，不会随环境变化而改变；外部状态：不可以共享，会随环境变化而改变。

享元模式的实现：

　　FlyWeight享元工厂类：创建并管理享元对象，享元池一般设计成键值对；

　　FlyWeight抽象享元类：通常是一个接口或者抽象类，声明公共方法，这些方法可以向外界提供对象的内部状态，设置外部状态；

　　ConcreteFlyWeight具体享元类：为内部状态提供成员变量进行存储；

　　UnsharedConcreteFlyWeight非共享享元类：不能被共享的子类可以设计为非共享享元类。

　　下面通过棋子的例子代码来解释：

　　首先，创建棋子的坐标类，由于不同棋子坐标不同，是不能共享的，所以该类是UnSharedConcreteFlyWeight：

package com.note.pattern.flyweight;

public class Coordinate {
	
	private int x,y;

	public Coordinate(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}
	
}

　　创建抽象享元类FlyWeight和具体享元类ConcreteFlyWeight

package com.note.pattern.flyweight;

public interface ChessFlyWeight {

	String getColor();

	void display(Coordinate c);

}

class ConcreteChess implements ChessFlyWeight {

	private String color;

	public ConcreteChess(String color) {
		super();
		this.color = color;
	}

	@Override
	public String getColor() {
		return color;
	}

	@Override
	public void display(Coordinate c) {
		System.out.println("棋子颜色：" + color);
		System.out.println("棋子位置：" + c.getX() + "----" + c.getY());
	}

}

　　创建享元工厂类：

package com.note.pattern.flyweight;

import java.util.HashMap;
import java.util.Map;

public class ChessFlyWeightFactory {
	
	private static Map<String, ChessFlyWeight> map = new HashMap<>();
	
	public static ChessFlyWeight getChess(String color) {
		if(map.get(color) != null) {
			return map.get(color);
		}else {
			ChessFlyWeight chess = new ConcreteChess(color);
			map.put(color, chess);
			return chess;
		}
	}
	

}

　　客户端测试：

package com.note.pattern.flyweight;

public class Client {

	public static void main(String[] args) {
		
		ChessFlyWeight chess1 = ChessFlyWeightFactory.getChess("黑色");
        ChessFlyWeight chess2 = ChessFlyWeightFactory.getChess("黑色");
        System.out.println(chess1);
        System.out.println(chess2);
        
        System.out.println("增加外部状态的处理===========");
        
        chess1.display(new Coordinate(10, 10));
        chess2.display(new Coordinate(20, 20));
		
	}

}

　　运行结果

com.note.pattern.flyweight.ConcreteChess@7852e922
com.note.pattern.flyweight.ConcreteChess@7852e922
增加外部状态的处理===========
棋子颜色：黑色
棋子位置：10----10
棋子颜色：黑色
棋子位置：20----20

　　可以发现，chess1和chess2两个棋子属于同一个对象，它们的颜色属性属于内部状态，实现了共享，但是它们的坐标属性属于外部状态，没有实现共享，并不相同。这样节省了内存空间。

享元模式在开发中应用场景：

　　享元模式由于其共享的特性，可以在任何“池”中操作，比如线程池，数据库连接池；
　　String类的设计也是享元模式

享元模式的优缺点：

　　优点：
　　　　极大地减少了内存中对象的数量；
　　　　相同或相似对象内存中只存一份，极大地节约了资源，提高系统性能；
　　　　外部状态相对独立，不影响内部状态；
缺点：
　　　　模式较为复杂，使程序逻辑复杂化；
　　　　为了节省内存，共享了内部状态，分离出外部状态，而读取外部状态使运行时间变长，用时间换取了空间。

转载于:https://www.cnblogs.com/zhaojianhua/p/8257497.html