java - 对内部类或 "Dependent"类使用抽象或接口(interface)

Question

我发现自己反复制作一个带有二维“Cell”对象数组的“矩阵”类(我标题中的“依赖”类，不确定是否有一个标准术语，一个外部类，但是只能从调用其构造函数和方法的类访问)。因此，我当然希望自己构建一些可重用的类和/或接口(interface)。

矩阵看起来像这样:

public class Matrix {

private Cell matrix[][];
private float spaceWidth, spaceHeight;
private int xCols, yRows;

public Matrix(int xCols, int yRows, float width, float height){
    matrix = populateCells(xCols,yRows);
    spaceWidth = width / xCols;
    spaceHeight = height / yRows;
    this.xCols = xCols;
    this.yRows = yRows;
}

public Cell[][] populateCells(int xCols, int yRows) {
    Cell c[][] = new Cell[xCols][yRows];
    int k = 0;
    for (int i = 0; i < xCols; i++){
        for(int j = 0; j < yRows; j++){
            c[i][j] = new Cell(i,j,k);
            k++;
        }
    }
    return c;
}
...
}

public class Cell {
private int x, y, num;

public Cell(int x, int y, int num, String name){
    this.x = x;
    this.y = y;
    this.num = num;
}

public float getX(){return x;}
public float getY(){return y;}
public int getNum(){return num;}
}

我希望每个 Cell 和每个 Matrix 都具有这些属性。当我想扩展 Cell 以添加属性时，问题就来了。无论我尝试什么接口(interface)和/或抽象的组合，我似乎无法弄清楚如何在不逐字重写 Matrix.populateCells 的情况下扩展 Matrix 和 Cell，只使用新的 Cell 名称。换句话说，我想在不破坏 Matrix 中对它的所有引用的情况下扩展 Cell。

那么基本上，我该如何组织它以便抽象完成它应该做的事情，即限制重复代码、封装等？

---

总结一下我对所选答案的实现:

public interface ICell {

public abstract int getX();
public abstract int getY();
public abstract int getNum();

}

public class Cell implements ICell {
private int x, y, num;

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

    //getters...
}

public class WaveCell extends Cell implements ICell {
private boolean marked;

public WaveCell(int x, int y, int num) {
    super(x, y, num);
    marked = false;
}

public boolean isMarked() {return marked;}
public void setMarked(boolean marked) {this.marked = marked;}

    // More new stuff...    
}

public class WaveMatrix extends Matrix {

public WaveMatrix(int xCols, int yRows, float width, float height) {
    super(xCols, yRows, width, height);
}

@Override
public ICell newCell(int i, int j, int k){
    ICell c = new WaveCell(i,j,k);
    return c;
}
    ...
 }

 public class Matrix {

private ICell matrix[][];
private float spaceWidth, spaceHeight;
int xCols, yRows;

public Matrix(int xCols, int yRows, float width, float height){
    matrix = populateCells(xCols,yRows);
    spaceWidth = width / xCols;
    spaceHeight = height / yRows;
    this.xCols = xCols;
    this.yRows = yRows;
}

public ICell[][] populateCells(int xCols, int yRows) {
    ICell c[][] = new ICell[xCols][yRows];
    int k = 0;
    for (int i = 0; i < xCols; i++){
        for(int j = 0; j < yRows; j++){
            c[i][j] = newCell(i,j,k);
            k++;
        }
    }
    return c;
}

public ICell newCell(int i, int j, int k){
    ICell c = new Cell(i,j,k);
    return c;
}
    ...
}

Answer 1

有很多方法可以处理这个问题。

---

一个矩阵实现，一个单元格实现

在我看来，如果您的 Cell 类只有一个“可定制”属性，那么最不可取的方法就是将该属性简单地传递到 Matrix 类的构造函数中，以便在填充调用期间使用。

public Matrix(String cellName, int xCols, int yRows, float width, float height){
    matrix = populateCells(cellName, xCols,yRows);
    // ...
}

public Cell[][] populateCells(String cellName, int xCols, int yRows) {
    // ...
}

这种方法几乎算不上面向对象的编程，并且变得极其难以维护您为 Cell 类确定的更“可定制”的行为。不推荐。

---

多个矩阵实现

或者，您可以创建 Matrix 类的层次结构，其中包含包含核心行为的抽象父类(super class)，以及能够更适本地填充自己的单元格类型的专用子类。

public abstract class Matrix<T extends Cell> {

    private public T matrix[][];

    public Matrix(int xCols, int yRows, float width, float height){
        matrix = populateCells(xCols,yRows);
        // ...
    }

    public T[][] populateCells(int xCols, int yRows) ;
}

public class RedBloodCellMatrix extends Matrix<RedBloodCell> {

    @Override
    public RedBloodCell[][] populateCells(int xCols, int yRows) {
        // ...
    }
}

这个方法没有错，是经典的多重继承策略。

---

还有一种选择，在我看来更可取，是将细胞群视为可插入的战略行为，您可以将其插入 Matrix 类在运行时。这个方法可以被认为是 composition-over-inheritance 的一个实现。原理:

public class Matrix {

    private public Cell matrix[][];
    private CellPopulationStrategy cellPopulationStrategy;
    // ...

    public Matrix(CellPopulationStrategy strategy, int xCols, int yRows, float width, float height){
        matrix = populateCells(strategy, xCols,yRows);
        // ...
    }

    public Cell[][] populateCells(CellPopulationStrategy strategy, int xCols, int yRows) {
        return strategy.populateCells(xCols, yRows);
    }
}

public interface CellPopulationStrategy {
    public Cell[][] populateCells(int xCols, int yRows);
}

public RedBloodCellPopulationStrategy implements CellPopulationStrategy{

    @Override
    public Cell[][] populateCells(int xCols, int yRows) {
        // ...
    }
}

这是一种很好的使用方法，因为它可以很好地适应对象的复杂性(特别是当您想要覆盖多个封装对象的行为时。