# 七大软件规划原则
# 规划形式-工厂形式
# 规划形式-单例形式
# 规划形式-原型形式
# 规划形式-策略形式
# 规划形式-职责链形式
# 规划形式-建造者形式
# 规划形式-深度分析代理形式
# 规划形式-门面形式
# 规划形式-装修器形式
它运用物件用来尽或许减少内存运用量；于相似物件中分享尽或许多的资讯。当很多物件近乎重复方式存在，因此运用很多内存时，此法适用。通常物件中的部分状况(state)能够同享。常见做法是把它们放在数据结构外部，当需求运用时再将它们传递给享元。
享元形式又称为轻量级形式，是目标池的一种完成。类似于线程池能够避免不停的创立和销毁多个目标，耗费功能。
它的本质是经过同享目标（将多个同一目标的拜访会集起来）来降低内存耗费，是结构型形式。
这儿需求留意的是享元形式把一个目标的状况分为内部状况和外部状况，内部状况是不变的能够同享的相同内容，外部状况是变化的是需求外部环境来设置的不能同享的内容，需求留意内部状况和外部状况的区别
形式的动机
首要是为了处理当目标数量太多时，将导致运转代价过高，带来功能下降等问题,通常境况下底层或许会用的更多些，比方咱们的源码底层，String、Integer、Long等下文会提到
形式的结构
享元形式的通用UML类图
public interface Flyweight {
void operation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight{
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState){
this.intrinsicState = intrinsicState;
}
@Override
public void operation(String extrinsicState) {
System.out.println("extrinsicState = " + extrinsicState);
System.out.println("intrinsicState = " + this.intrinsicState);
}
}
这儿需求留意的点事或许有的人会觉得intrinsicState这个特点是外部传过来的所以他便是外部目标，其实不然，工厂便是经过intrinsicState来区别实例的，而且也只要结构办法会用到其他是没有办法能够改动这个特点的，所以把这个特点界说为内部特点也便是能够同享的
下面的operation办法就会接受一个外部特点，这个是不同享的所以界说为外部特点
必定必定要区别外部特点和内部特点
public class FlyweightFactory {
private static Map<String,Flyweight> pool = new HashMap<>();
// 由于内部状况具备不变性，因此作为缓存的键
public static Flyweight getFlyweight(String intrinsicState) {
if (!pool.containsKey(intrinsicState)) {
Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
pool.put(intrinsicState, flyweight);
}
return pool.get(intrinsicState);
}
}
public class Test {
public static void main(String[] args) {
Flyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
Flyweight flyweight2 = FlyweightFactory.getFlyweight("bb");
flyweight1.operation("a");
flyweight2.operation("b");
}
}
代码示例
经过上文的解说或许有些人对内部状况和外部状况还是很含糊，也不知道究竟什么时分去运用享元形式,这儿咱们再举一个比方，比方咱们下五子棋，一切棋大小形状必定都是相同的，咱们能够作为内部状况同享，其实咱们还能够把色彩作为内部状况同享，有的人或许角色色彩有两种怎么同享。这儿咱们能够将色彩经过结构办法传入赋值给色彩特点，在工厂创立实例的时分就把白色和黑色区分成了两种目标，每一种目标的色彩就统一了。外部状况便是棋的坐标。
详细完成如下：
public abstract class BaseChess {
//这两个特点是一切棋子共有的特点所以咱们一颗直接放到抽象类中
protected final String shape = "原型";
protected final Integer radius = 5;
protected String color;
public BaseChess(String color){
this.color = color;
}
//移动棋子
public abstract void moveChess(int x, int y);
}
public class Chess extends BaseChess {
public Chess(String color) {
super(color);
}
@Override
public void moveChess(int x, int y) {
String string = "棋子形状：" +
super.shape +
"棋子半径：" +
super.shape +
"----" +
super.color +
"棋子移动位置" +
"x:" +
x +
"y:" +
y;
System.out.println(string);
}
}
public class ChessFactory {
private static Map<String,BaseChess> pool = new HashMap<>();
public static BaseChess getChess(String color){
//这儿以棋子色彩作为键值来区别示例
if(pool.containsKey(color)){
return pool.get(color);
}else{
Chess chess = new Chess(color);
pool.put(color,chess);
return chess;
}
}
}
public class Test {
public static void main(String[] args) {
BaseChess chess = ChessFactory.getChess("白色");
BaseChess chess1 = ChessFactory.getChess("黑色");
BaseChess chess2 = ChessFactory.getChess("白色");
BaseChess chess3 = ChessFactory.getChess("黑色");
System.out.println(chess);
chess.moveChess(100,102);
System.out.println(chess1);
chess1.moveChess(101,102);
System.out.println(chess2);
chess2.moveChess(102,102);
System.out.println(chess3);
chess3.moveChess(103,102);
}
}
这儿有一点是假如有人觉得这个内部目标还要经过结构办法传递很不爽，能够创立两个目标分别是白色棋子目标和黑色棋子目标，在工厂办法中就界说号白色对应的是哪个目标黑色是哪个，这样就能够将色彩这个内部特点写死在目标内部了
源码中的提现
String
Java 中将 String 类界说为 final（不可改动的），JVM 中字符串一般保存在字符串常量池中，java
会确保一个宁符串在常量池中只要一个拷贝，这个宁符串常量池在JDK6.0 以前是坐落常量池中，坐落
永久代，而在JDK7.0中，JVM将其从永久代拿出来放置于堆中。
能够看一下下面代码：
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = s3.intern();
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s2 == s3);
System.out.println(s4 == s3);
System.out.println(s4 == s2);
运转结果如下：
- s1和s2相同是应为”hello”这个字面量已经存到常量池中
- s2再赋值的时分会到常量池中找找到了直接赋值不会再新创立目标s2和s3不相同便是s3自己new了一个目标所以必定是不相同的
- s4和s3不相同又和s2相同的原因是
intern办法会去查常量池查假如查到了直接回来常量池的目标，假如没查到会将s3放到常量池（经过在创立一个新目标）再回来对应常量池的引用
Integer
能够先看一下 valueOf办法源码:
再看这个IntegeCache是个什么东西:
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer[] cache;
static Integer[] archivedCache;
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
h = Math.max(parseInt(integerCacheHighPropValue), 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
// Load IntegerCache.archivedCache from archive, if possible
CDS.initializeFromArchive(IntegerCache.class);
int size = (high - low) + 1;
// Use the archived cache if it exists and is large enough
if (archivedCache == null || size > archivedCache.length) {
Integer[] c = new Integer[size];
int j = low;
for(int i = 0; i < c.length; i++) {
c[i] = new Integer(j++);
}
archivedCache = c;
}
cache = archivedCache;
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
发现是Integer的一个内部类,在第一次调用它的时分就会创立值为-128~127的目标。
享元形式优缺陷
长处：
- 假如有很多相同目标要创立该形式能够提高功能节约内存
缺陷
- 享元形式使得体系愈加杂乱，需求分离出内部状况和外部状况，这使得程序的逻辑杂乱化。
- 为了使目标能够同享，享元形式需求将享元目标的状况外部化，而读取外部状况使得运转时间变长。
