java - 人生游戏:-在实现人生游戏中的SOLID原则方面需要帮助

Question

嗨，我正在尝试通过应用诸如开放和封闭，单一责任原则，liskov替换原则，接口隔离原则和依赖关系反转原则来执行人生游戏程序。但是我被困住了，无法思考应该将原则确切地应用到哪里。如果有人知道有人可以请我帮助我了解如何进行或如何应用它，我将不胜感激。在此先感谢您。
我将代码的某些部分作为示例应用该原理。

抽象游戏策略

public abstract class AbstractGameStratedgy implements GameStratedy {

    private Rule [] rules; 

    @Override
    public void setRules(Rule[] rules) {
        this.rules = rules;
    }

    @Override
    public Rule[] getRules() {
        return rules;
    }

    @Override
    public Set<Cell> findNeighbours(Cell cell,Set<Cell> liveCells)
    {
        HashSet<Cell> neighbours=new HashSet<Cell>(); 

        int x=cell.getX();
        int y=cell.getY();
        Cell tempCell;
        for(int i=x-1;i<=x+1;i++)
        {
            if(i<0) continue;

            for(int j=y-1;j<=y+1;j++)
            {
                if(j<0) continue;

                tempCell=new Cell(i, j);
                if(liveCells.contains(tempCell))
                {
                    tempCell.setState(State.LIVE);
                }
                neighbours.add(tempCell);
            }
        }

        return neighbours;
    }
}

细胞

public class Cell {

    private final int x,y;
    private State state;

    public Cell(int x,int y)
    {
        this(x,y,State.DEAD);
    }

    public Cell(int x,int y,State state)
    {
        this.x=x;
        this.y=y;
        this.state = state;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cell other = (Cell) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }

    public Cell createCopy() {
        return new Cell(x,y,state);
    }

}

统治者

public class RuleRunner {

    private GameStratedy gameStratedy;

    public RuleRunner(GameStratedy gameStratedy)
    {
        this.gameStratedy = gameStratedy;
    }


    public Set<Cell> applyRules(Set<Cell> liveCells) {
        HashSet<Cell> nextGeneration=new HashSet<Cell>(); 

        Set<Cell> neighbouringCells;
        for(Cell cellFromCurrentGeneration: liveCells)
        {
            processCell(cellFromCurrentGeneration,liveCells,nextGeneration);

            neighbouringCells=gameStratedy.findNeighbours(cellFromCurrentGeneration, liveCells);

            for(Cell neighbouringCell:neighbouringCells)
            {
                processCell(neighbouringCell,liveCells,nextGeneration);
            }
        }

        return filterDead(nextGeneration);
    }

    private Set<Cell> filterDead(HashSet<Cell> nextGeneration) {
        Iterator<Cell> iterator = nextGeneration.iterator();

        while(iterator.hasNext())
        {
            if(State.DEAD.equals(iterator.next().getState()))
            {
                iterator.remove();
            }
        }

        return nextGeneration;
    }


    private void processCell(Cell cell,Set<Cell> currentGeneration,Set<Cell> nextGeneration)
    {
        if(nextGeneration.contains(cell)) return; // already processed

        cell=cell.createCopy();

        State nextState=cell.getState();
        for(Rule rule:gameStratedy.getRules())
        {
            nextState=rule.nextState(cell.getState(), findLiveNeighbourCount(cell, currentGeneration));

            if(!cell.getState().equals(nextState))
            {
                break;
            }
        }

        cell.setState(nextState);
        nextGeneration.add(cell);
    }



    private int findLiveNeighbourCount(Cell cell,Set<Cell> liveCells)
    {
        int count=0;
        for(Cell c:gameStratedy.findNeighbours(cell, liveCells))
        {
            if(State.LIVE.equals(c.getState())) count++;
        }
        return count;
    }

}

Answer 1

之前，我仅共享实现的Github存储库中README.md文件的链接，主持人向我表达了真正的担忧，如果删除链接后面的页面怎么办？我正在提供一个答案，希望对理解解决方案有所帮助，而不必参考我的README.md文件或代码。

这个问题来自一年前。您可能已经了解了SOLID原则。自从我最近在PHP OOP中解决了Conway的“人生游戏”并应用SOLID设计原则，目的是与工作中的同事分享我对原则的理解之后，我在这里分享了我在stackoverflow上解决此问题的方法，作为答案这个问题，到目前为止还没有答案。我希望这对所有希望围绕SOLID原则专心思考的人有所帮助，特别是通过在Conway的“人生游戏”问题上进行实践来解决。

以下是我对需要上什么课的看法：

步骤1：我从问题陈述的明显类开始，分别是Board和Cell，Board由许多单元组成。

步骤2：在采用“单一责任原则”的情况下，班级对董事会和部门I负有单一责任，并且只有一个变更理由，因此我将这两个班级分解为以下两个班级：


开发板（用于维护开发板尺寸和活动单元位置以及getNeighbourCount（）方法）
BoardRenderer（用于在介质上绘制板）
BoardPersister（用于持久化，即在步骤之间将电路板布局从内存中保存到MySQL之类的持久性存储中）
BoardInitializer（用于在游戏开始时对活动单元进行初始布置）
对于单元格，我只需要CellRenderer，因为此时我开始
意识到我的Cell类没有其他工作要做，只能渲染
（活动单元一种方式，非活动单元另一种方式）。是板
它将了解其尺寸和位置
活动细胞（因此也包含非活动细胞的位置）。一世
不需要Cell类。


步骤3：根据我对什么是开放/关闭和依赖倒置原则的理解，分别说明，软件实体应该开放以进行扩展，而封闭以进行修改，并且应该依赖抽象而不是具体化（来源Wikipedia），我进行了转换从类到接口的BoardInitializer，BoardRenderer，BoardPersister，CellRenderer，这样我就可以构建新类并通过简单地替换现有类来使用它们。这些新类仅需要实现其各自的接口。

在这个阶段，我意识到并且我还需要一个游戏控制器。因此，我添加了一个具有newGame（）和advanceGame（）方法以及GameRenderer接口的GameController抽象类，以主要呈现游戏控件。我还将Board转换为抽象类，以便能够拥有两种类型的Board：EdgesWrappedBoard和BoundedBoard。 GameRenderer将调用BoardRenderer，后者将利用CellRenderer绘制活动和不活动的单元。

所以，现在我们有了这些课程，

抽象类：


板
游戏控制器


扩展抽象类的类：


EdgesWrappedBoard（扩展板）
有界板（扩展板）
HTMLGameController（扩展GameController）
ConsoleGameController（扩展GameController）


接口：


游戏渲染器
BoardRenderer
单元渲染器
BoardInitializer
董事会委员


实现接口的类：


HTMLGameRenderer（实现GameRenderer）
ConsoleGameRenderer（实现GameRenderer）
HTMLBoardRenderer（实现BoardRenderer）
ConsoleBoardRenderer（实现BoardRenderer）
HTMLCellRenderer（实现CellRenderer）
ConsoleCellRenderer（实现CellRenderer）
RandomBoardInitializer（实现BoardInitializer）
Test1BoardInitializer（实现BoardInitializer）
Test2BoardInitializer（实现BoardInitializer）
FileBoardPersister（实现BoardPersister）
MySQLBoardPersister（实现BoardPersister）


步骤4：最后，我检查是否违反了Liskov的替代原理或界面隔离原理。没有。这些原则分别是：
程序中的对象应该可以用其子类型的实例替换，而不会改变该程序的正确性。
许多特定于客户端的接口比一个通用接口要好。

注意：从一开始，为了展示出依赖性反转和打开/关闭原则，我着手同时具有Web（HTML）和控制台界面，并且能够持久存储到文件或数据库中。

如果您有兴趣将我的思想进步看作是类图，则可以参考我的implementation of Game of Life在GitHub上共享的README.md文件。也将有其他解决方案。我的目标是与我的同事最好地交流我对SOLID原理的理解，以便我们共同在OOP PHP代码中实现更好的可维护性。

希望对您有帮助。请告诉我。