java23设计模式---class10、享元模式(FlyWeight)

文章目录

• 一、基本介绍
• • 1、定义
  • 2、优点
  • 3、缺点
  • 4、角色
  • 5、内部状态和外部状态
• 二、应用情景
• 三、与其他模式的搭配使用
• 四、代码解析

一、基本介绍

1、定义

享元模式(FlyWeight)，又称为蝇量模式，常用于有着大量重复使用的细粒度对象时。实质上是一种共享技术。

2、优点

利用享元池，可以使得用户在调用一个对象时可以不必去new，只需要在享元池中直接获取即可，节约了内存空间。
注:太多的对象不仅会影响性能，更严重的情况下可能会造成内存溢出

3、缺点

1)逻辑会更加的复杂。
2)对于一些享元池中不能直接取出的对象，还是需要去new，这时利用了享元模式获取对象的时间会变得更长。

4、角色

1)抽象享元类

接口/抽象类

2)具体享元类

实现接口或者抽象类的具体子类，这些子类会被大量的重复使用，而且这些子类对象都是细粒度。

3)享元工厂类

工厂其实就是一个享元池

4)组合享元类

组合享元类是依赖基本享元类产生的一个整体类，例如享元池中，如果有字符A、B，我们其实可以利用这两个字符对象构成一个AB字符串，这就是一个组合享元类。

5、内部状态和外部状态

• 内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；
• 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。

二、应用情景

1、线程池

2、String

3、Integer

4、五子棋

三、与其他模式的搭配使用

享元模式通常与单例模式、组合模式、工厂模式搭配使用。

1）单例模式

工厂可以使用单例模式.(前提是工厂不是泛型工厂)

2）组合模式

复合的享元模式是使用了组合模式的

3）工厂模式

工厂其实就是一个享元池

四、代码解析

//抽象享元

package pattern.flyweight;

public abstract class FlyWeight {
//内部状态
String instate;
//外部状态
String outstate;
public FlyWeight(String outstate) {
	this.instate=outstate;
}
//与外部状态相关的逻辑操作
abstract void operation();
//获取或者设置内部状态
public String getInstate() {
	return instate;
}
public void setInstate(String instate) {
	this.instate = instate;
}

}

//具体享元

package pattern.flyweight;
public class A extends FlyWeight{

	public A(String outstate) {
		super(outstate);
		// TODO Auto-generated constructor stub
	}
//根据外部状态进行一系列的逻辑操作
	@Override
	void operation() {
		// TODO Auto-generated method stub
		System.out.println(outstate);
	}


}

//享元工厂

package pattern.flyweight;

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

//泛型时，不能用单例模式，否则泛型将会没有意义
public class FlyWeightFactory {
private FlyWeightFactory() {};
// volatile是避免重排序
private static volatile FlyWeightFactory INSTANCE = null;

public static FlyWeightFactory getINSTANCE() {
	if (INSTANCE == null) {
		synchronized (FlyWeightFactory.class) {
			if (INSTANCE == null)
				INSTANCE = new FlyWeightFactory();
		}
	}
	return INSTANCE;
}
 
static Map<Character,FlyWeight> FlyWeightMap=new HashMap<Character,FlyWeight>();

public  FlyWeight getConcreteFlyWeight(char c) {
	if(!FlyWeightMap.containsKey(c))
		FlyWeightMap.put(c,new A());
	return FlyWeightMap.get(c);
}
}

//测试类

package pattern.flyweight;
public class Main {
	public static void main(String[] args) {
		/*
		 * Integer a=Integer.valueOf(3);//有缓存机制 Integer c=new Integer(3);//没有用到缓存机制
		 * Integer b=new Integer(3); Integer d=3;//有用到缓存机制 Integer e=129; Integer
		 * f=129;//超过了缓存池 System.out.println(a==d); System.out.println(e==d);
		 * System.out.println(c==b);
		 * 
		 * String a0="a"; String a1="b"; String a2="a"+"b"; String b="ab"; String
		 * c="ab"; String a=a0+a1;
		 * System.out.println(a==b);//字符串相加其实是StringBuilder.append()然后toString
		 * System.out.println(a.intern()==b);//intern是找常量池中的引用
		 * System.out.println(b==c);//两个都指向常量池中
		 * System.out.println(a2==b);//如果是定义的时候直接相加，编译器会进行优化，直接看成String a2="ab";
		 */
		FlyWeight a=FlyWeightFactory.getINSTANCE().getConcreteFlyWeight('a',"outstate");
		FlyWeight b=FlyWeightFactory.getINSTANCE().getConcreteFlyWeight('a',"outstate");
		System.out.println(a==b);
	}
}

UML图:

本文地址：https://blog.csdn.net/m0_51801058/article/details/114254746