1

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

矩阵如下所示：

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 以添加属性时，问题就来了。无论我尝试什么接口和/或抽象的组合，我似乎都无法弄清楚如何在不逐字重写 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;
}
    ...
}
4

3 回答 3

2

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

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

在我看来，如果您的 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 类的层次结构，其中包含核心行为的抽象超类和能够更适当地填充其自己的单元格类型的专门子类。

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 类中。这种方法可以被认为是组合优于继承原则的一种实现：

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) {
        // ...
    }
}

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

于 2012-11-19T17:43:15.033 回答
1

不是我不想改变populateCells，而是我不想调用super并循环遍历数组，然后在child中再做一遍。

如果您希望能够以Matrix一种可以执行额外步骤的方式进行扩展，populateCells您可以简单地将其中的一部分移动到您可以覆盖的方法中。就像下面的代码

public class Matrix {

    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] = getCell(i,j,k);
                k++;
            }
        }
        return c;
    }

    public Cell getCell(int i, int j, int k) {
        return new Cell(i, j, k);
    }

}


class SuperMatrix extends Matrix {
    @Override
    public Cell getCell(int i, int j, int k) {
        Cell c = super.getCell(i, j, k);
        modify(c);
        return c;
    }
}

您也可以使用上述与@Perception 建议的相同策略模式。不同之处在于，在下面的代码中只ICell生成了一个，而在另一个示例中，完整的单元格数组将是产品。

public class Matrix {
    /** a common cell interface */
    public interface ICell {
        public int getX();
        public int getY();
    }

    /** somthing that knows how to produce a cell */
    public interface CellProducerStrategy {
        public ICell getCell(int i, int j, int k);
    }

    /** method of Matrix that is always the same for all Cells and Strategies */
    public ICell[][] populateCells(int xCols, int yRows, CellProducerStrategy strategy) {
        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] = strategy.getCell(i,j,k);
                k++;
            }
        }
        return c;
    }

    // ---------- some implementation --------------------

    static class DefaultCell implements ICell {
        public DefaultCell(int i, int j, int k) {
            // something
        }
        @Override
        public int getX() {
            return 0;
        }
        @Override
        public int getY() {
            return 0;
        }
    }

    public static class DefaultCellProducer implements CellProducerStrategy {
        @Override
        public ICell getCell(int i, int j, int k) {
            return new DefaultCell(i, j, k);
        }
    }

    // ---------- alternative implementation --------------------

    static class NamedCell implements ICell {
        private String name;
        public NamedCell(int i, int j, int k, String name) {
            // something
            this.name = name;
        }
        @Override
        public int getX() {
            return 0;
        }
        @Override
        public int getY() {
            return 0;
        }
        public String getName() {
            return this.name;
        }
    }

    public static class NamedCellProducer implements CellProducerStrategy {
        @Override
        public ICell getCell(int i, int j, int k) {
            return new NamedCell(i, j, k, "John-" + i*j*k);
        }
    }
}

上面的代码没有使用泛型，它的缺点是如果你想使用基类中没有定义的方法，你需要将项目转换为它们的实际类型。

Matrix m = new Matrix(5, 5, new Matrix.NamedCellProducer());
ICell cell = m.get(0,0);
if (cell instanceof NamedCell) {
    String name = ((NamedCell)cell).getName();
}
于 2012-11-19T17:33:46.617 回答
0

据我了解，您需要使构造函数 public Cell(int x, int y, int num) 在所有派生类中工作。请看下面的例子——它基于受保护的 init 方法。

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

public Cell() {
}

public Cell(int x, int y, int num) {
    init(x, y, num);
}

protected void init(int x, int y, int num) {
    this.x = x;
    this.y = y;
    this.num = num;
}

public float getX() {
    return x;
}

public float getY() {
    return y;
}

public int getNum() {
    return num;
}
}

public class CellWithName extends Cell {
protected String name;

public CellWithName(int x, int y, int num, String name) {
    init(x, y, num);
    this.name = name;
}
}
于 2012-11-19T17:49:33.607 回答