一块儿学设计模式 - 享元模式

享元模式（Flyweight Pattern）属于结构型模式的一种，又称轻量级模式，经过共享技术有效地实现了大量细粒度对象的复用...java

<!-- more -->git

概述

两种结构状态编程

• 内部状态：享元对象内部不随外界环境改变而改变的共享部分。微信

• 外部状态：享元对象内部随环境的改变而改变，不可以共享的状态就是外部状态。ide

结构图测试

存在的角色this

• Flyweight（抽象享元类）：一般是一个接口或抽象类，向外界提供享元对象的内部数据（内部状态）或外部数据（外部状态）。spa

• ConcreteFlyweight（具体享元类）：实现了Flyweight（抽象享元类）也称为享元对象，指定内部状态，为内部状态增长存储空间。一般咱们能够结合单例模式来设计具体享元类，为每个具体享元类提供惟一的享元对象。设计

• UnsharedConcreteFlyweight（非共享具体享元类）：指不须要共享的Flyweight子类。code

• FlyweightFactory（享元工厂类）：用于建立并管理享元对象，针对抽象享元类编程，将各类类型的具体享元对象存储在一个享元池中，享元池通常设计为键值对的集合（也能够是其余类型的集合），同时能够结合工厂模式进行设计。

享元模式的核心在于享元工厂类，享元工厂类的做用在于提供一个用于存储享元对象的享元池，用户须要对象时，首先从享元池中获取，若是享元池中不存在，则建立一个新的享元对象返回给用户，并在享元池中保存该新增对象。

案例

案例UML图以下：

1.建立Flyweight接口/抽象类

interface Flyweight {
    void operation(String name);

    String getType();
}

2.建立ConcreteFlyweight（享元对象），实现了Flyweight接口

class ConcreteFlyweight implements Flyweight {
    private String type;

    public ConcreteFlyweight(String type) {
        this.type = type;
    }

    @Override
    public void operation(String name) {
        System.out.printf("[类型(内在状态)] - [%s] - [名字(外在状态)] - [%s]\n", type, name);
    }

    @Override
    public String getType() {
        return type;
    }
}

3.建立FlyweightFactory（享元工厂类），用来维护享元池

class FlyweightFactory {
    private static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();

    public static Flyweight getFlyweight(String type) {
        if (FLYWEIGHT_MAP.containsKey(type)) {
            return FLYWEIGHT_MAP.get(type);
        } else {
            ConcreteFlyweight flyweight = new ConcreteFlyweight(type);
            FLYWEIGHT_MAP.put(type, flyweight);
            return flyweight;
        }
    }

    public static int total() {
        return FLYWEIGHT_MAP.size();
    }
}

4.建立Client（测试类）

public class Client {

    public static void main(String[] args) {
        Flyweight fw0 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw1 = FlyweightFactory.getFlyweight("战士");
        Flyweight fw2 = FlyweightFactory.getFlyweight("法师");
        Flyweight fw3 = FlyweightFactory.getFlyweight("坦克");
        fw1.operation("瑞文");
        fw1.operation("鳄鱼");
        fw2.operation("光辉");
        fw3.operation("泰坦");
        fw3.operation("盖伦");
        System.out.printf("[结果(对象对比)] - [%s]\n", fw0 == fw1);
        System.out.printf("[结果(内在状态)] - [%s]\n", fw1.getType());
        System.out.printf("一共召唤 %s 种类型英雄\n", FlyweightFactory.total());
    }
}

5.运行结果，从结果中能够发现，只生成了3个不一样的类

[类型(内在状态)] - [战士] - [名字(外在状态)] - [瑞文]
[类型(内在状态)] - [战士] - [名字(外在状态)] - [鳄鱼]
[类型(内在状态)] - [法师] - [名字(外在状态)] - [光辉]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [泰坦]
[类型(内在状态)] - [坦克] - [名字(外在状态)] - [盖伦]
[结果(对象对比)] - [true]
[结果(内在状态)] - [战士]
一共召唤 3 种类型英雄

JDK中使用

在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦建立就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。

public class Client {
    public static void main(String[] args) {
        String a = "盖伦";
        String b = "盖伦";
        System.out.println(a==b);// 返回 true
    }
}

上面的例子中结果为：true，这就说明a和b两个引用都指向了常量池中的同一个字符串常量。这样设计的目的就是：为了不在建立多相同对象时，所产生的没必要要的资源消耗。

总结

若是程序里使用大量相同或者类似的对象，形成内存的大量耗费，且大多都是外部状态，这时候就应该考虑使用享元模式了，好比围棋、五子棋等小游戏

优势

• 可以极大的减小系统中对象的个数。

• 外部状态相对独立，不会影响到内部状态，可以使享元对象在不一样的环境被共享。

缺点

• 因为享元模式须要区分外部状态和内部状态，使得程序在某种程度上来讲更加复杂化了。

• 为了使对象能够共享，享元模式须要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

- 说点什么

全文代码：https://gitee.com/battcn/design-pattern/tree/master/Chapter9/battcn-flyweight

• 我的QQ：1837307557

• battcn开源群（适合新手）：391619659

微信公众号：battcn（欢迎调戏）