单例注册表模式探索

MazeFactory

单例工厂，维护一个单例注册表，每种迷宫子类维护一个单例，这种方式不用破坏原来的代码结构，将单例实现搬到外面，如果维持全局的单例，无论属于何种迷宫均算作一种，，那么就需要提供迷宫的销毁方法，并在getInstance方法中控制单例的交替。
还有一种方式是将每个子类设计为单例模式，并将每个子类设计为单例模式，这么做代码可能越来越复杂，并且实现全局共同单例也有些困难。

public class MazeFactory {

    private static final Map<MazeStyle, Maze> sSingletonMap = new ConcurrentHashMap<>();

    public enum MazeStyle {
        BOMBED,
        ENCHANTED,
    }

    private MazeFactory() {
    }

    public static Maze getInstance(MazeStyle style) {
        if (sSingletonMap.get(style) == null) {
            Maze maze;
            switch (style) {
                case BOMBED:
                    maze = new BombedMaze();
                    break;
                case ENCHANTED:
                    maze = new EnchantedMaze();
                    break;
                default:
                    throw new NoSuchElementException();
            }
            sSingletonMap.put(style, maze);
        }
        return sSingletonMap.get(style);
    }
}

Maze

// interface Maze
public interface Maze {
    void print();
}

// BombedMaze
public class BombedMaze implements Maze {

    @Override
    public void print() {
        System.out.println("BombedMaze print");
    }
}

// EnchantedMaze
public class EnchantedMaze implements Maze {

    @Override
    public void print() {
        System.out.println("EnchantedMaze print");
    }
}

使用

public class Test {
    public static void main(String[] args) {
        Maze maze = MazeFactory.getInstance(MazeFactory.MazeStyle.BOMBED);
        Maze maze2 = MazeFactory.getInstance(MazeFactory.MazeStyle.BOMBED);
        Maze maze3 = MazeFactory.getInstance(MazeFactory.MazeStyle.ENCHANTED);

        System.out.println("-------------");
        System.out.println(maze.equals(maze2));
        System.out.println(maze.equals(maze3));
        System.out.println("-------------");
        maze.print();
        System.out.println("-------------");
    }
}

// out:
// -------------
// true
// false
// -------------
// BombedMaze print
// -------------