设计模式：结构型-享元模式

约定不等于承诺〃 2022-11-17 13:39 153阅读 0赞

### 目录 ###

*  第一章 享元模式介绍
 *  第二章 享元模式实现
 *   *  2.1、非享元对象
     *  2.2、抽象享元对象
     *  2.3、具体享元对象
     *  2.4、享原工厂对象
     *  2.5、最终测试类
 *  第三章 享元模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 享元模式介绍 #

享元模式的介绍：

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。例如，围棋和五子棋中的黑白棋子，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式（Flyweight Pattern）也叫蝇量模式，主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

*  内部状态指对象共享出来的信息，存储在享元信息内部，并且不会随环境的改变而改变。例如围棋的棋子颜色：黑色、白色。
 *  外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。例如围棋的棋子位置：x横坐标、y纵坐标。

享元模式的优点：

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

享元模式的缺点：

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

享元模式的场景：

*  系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
 *  大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
 *  由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

享元模式的角色：

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

![0fbdcd087d40c1162feea11a813542fa.png][]

# 第二章 享元模式实现 #

## 2.1、非享元对象 ##

Point

public class Point { 
        private int x;  //外部状态：代表棋子横坐标
        private int y;  //外部状态：代表棋子纵坐标
    
        public Point(int x, int y) { 
            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;
        }
    }

## 2.2、抽象享元对象 ##

ChessPieces

public interface ChessPieces { 
        void downPieces(Point p); //落子方法
    }

## 2.3、具体享元对象 ##

WhiteChessPieces

public class WhiteChessPieces implements ChessPieces { 
        private String color;   //内部状态：代表棋子颜色
    
        public WhiteChessPieces() { 
            this.color = "白";
        }
    
        @Override
        public void downPieces(Point p) { 
            System.out.println(color + "子落入横坐标" + p.getX() + "，纵坐标" + p.getY());
        }
    }

BlackChessPieces

public class BlackChessPieces implements ChessPieces { 
        private String color;   //内部状态：代表棋子颜色
    
        public BlackChessPieces() { 
            this.color = "黑";
        }
    
        @Override
        public void downPieces(Point p) { 
            System.out.println(color + "子落入横坐标" + p.getX() + "，纵坐标" + p.getY());
        }
    }

## 2.4、享原工厂对象 ##

ChessPiecesFactory

public class ChessPiecesFactory { 
        private HashMap<String, ChessPieces> pools = new HashMap<>();
    
        public ChessPieces getChessPieces(String color) { 
            if (!pools.containsKey(color)) { 
                if ("白".equals(color)) { 
                    pools.put(color, new WhiteChessPieces());
                }
                if ("黑".equals(color)) { 
                    pools.put(color, new BlackChessPieces());
                }
            }
            return pools.get(color);
        }
    }

## 2.5、最终测试类 ##

Client

public class Client { 
        public static void main(String[] args) { 
            ChessPiecesFactory chessPiecesFactory = new ChessPiecesFactory();
    
            ChessPieces cp1 = chessPiecesFactory.getChessPieces("白");
            ChessPieces cp2 = chessPiecesFactory.getChessPieces("白");
            ChessPieces cp3 = chessPiecesFactory.getChessPieces("黑");
            ChessPieces cp4 = chessPiecesFactory.getChessPieces("黑");
    
            Point p1 = new Point(1, 1);
            Point p2 = new Point(2, 2);
            Point p3 = new Point(3, 3);
            Point p4 = new Point(4, 4);
    
            cp1.downPieces(p1);
            cp2.downPieces(p2);
            cp3.downPieces(p3);
            cp4.downPieces(p4);
    
            System.out.println("====================");
    
            System.out.println(cp1 == cp2);
            System.out.println(cp3 == cp4);
        }
    }

白子落入横坐标1，纵坐标1
    白子落入横坐标2，纵坐标2
    黑子落入横坐标3，纵坐标3
    黑子落入横坐标4，纵坐标4
    ====================
    true
    true

# 第三章 享元模式应用 #

如果 Integer.valueOf(x) 中的x在 `-128 ~ 127` 之间，就是使用享元模式返回，如果不在该范围，则仍然 new。

![d68c20244a945e29896df8402d17b4ca.png][]

我们可以单独使用一个测试类来进行测试：

Integer a1 = Integer.valueOf(12);
    Integer a2 = Integer.valueOf(12);
    System.out.println(a1 == a2);
    
    Integer b1 = Integer.valueOf(128);
    Integer b2 = Integer.valueOf(128);
    System.out.println(b1 == b2);

true
    false

[0fbdcd087d40c1162feea11a813542fa.png]: /images/20221022/a19b704f6ae74a42bd1a0e0e8532812b.png
[d68c20244a945e29896df8402d17b4ca.png]: /images/20221022/281389d471a9405ba272d1d8dd608d8a.png