如何將2個類中的2個方法合併爲1個基類？

Question

我正在創建一個國際象棋遊戲，我已經創建了白嘴鴉和主教，我即將開始創建女王棋子。問題在於女王結合了白嘴鴉和主教的動作，所以我不想寫出重複的代碼，而只是使用2個類作爲白嘴鴉和主教的代碼，而他們的方法進入後者。

這裏的主教類

public class OficerPiece : Figure 
{ 
    public OficerPiece(FigureDefinition definition) : base(definition) 
    { 
    } 

    protected override List<Tuple<int, int>> GetValidTurns() 
    { 
     //here i set the valid moves 
    } 
} 

的車類是基本一致的，但不同的實施GetValidTurns()

在我的項目每一件繼承它包含的信息，每一塊Figure抽象類正在使用的唯一區別是在​​方法中，所以我們讓派生類去實現它。

那是女王級

public class Kralica : Figure 
{ 
    public Kralica(FigureDefinition definition) : base(definition) 
    { 
    } 

    protected override List<Tuple<int, int>> GetValidTurns() 
    { 
     //here i want to combine the 2 methods GetValidTurns from the bishop class and the rook class 
    } 
} 

Answer 1

您可以創建一個新的類或接口來進行有效轉換，以封裝它們並使其易於重用。

public interface ValidTurn 
{ 
    List<Tuple<int, int>> GetValidTurns(); 
} 

public class StraightSlide : ValidTurn 
{ 
    public List<Tuple<int, int>> GetValidTurns() 
    { 
     // ... valid rook turns here 
    } 
} 

public class DiagonalSlide : ValidTurn 
{ 
    public List<Tuple<int, int>> GetValidTurns() 
    { 
     // ... valid bishops turns here 
    } 
} 

public class Kralica : Figure 
{ 
    public Kralica(FigureDefinition definition) : base(definition) 
    { 
    } 

    protected override List<Tuple<int, int>> GetValidTurns() 
    { 
     var straight = new StraightSlide(); 
     var diagonal = new DiagonalSlide(); 

     return straight.Concat(diagonal); 
    } 
} 

此外，原始類中的代碼應由新的ValidTurn類替換。

編輯：

public class StraightSlide : ValidTurn 
{ 
    private Figure figure; 
    public StraightSlide(Figure figure) 
    { 
     this.figure = figure; 
    } 

    public List<Tuple<int, int>> GetValidTurns() 
    { 
     figure.YourMethodToCall(); 
     // ... valid rook turns here 
    } 
} 

也許你可以考慮把所有的驗證邏輯到ValidTurn（TurnValidation）。

Answer 2

也許你可以來得這麼一種不同的方式。

有一個抽象基類，它定義一招：

public abstract class Move 
{ 
    // Whatever 
} 

然後導出不同於移動，例如：

public sealed class Diagonal : Move // Bishop, Queen 
{ 
} 

public sealed class Orthongonal : Move // Rook, Queen 
{ 
} 

public sealed class KnightsMove : Move 
{ 
} 

public sealed class KingsMove : Move 
{ 
} 

然後，可以使用組合物相結合的不同的動作：

public class Kralica : Figure 
{ 
    public Kralica(FigureDefinition definition) : base(definition) 
    { 
    } 

    protected override List<Move> GetValidTurns() 
    { 
     return moves; 
    } 

    readonly List<Move> moves = new List<Move> {new Diagonal(), new Orthongonal()}; 
} 

你Move類可以聲明如下S：

public abstract class Move 
{ 
    public abstract IEnumerable<Position> PossibleMoves(Position start, Board board); 
} 

其中Position是定義來保存關於在基板上的位置（其可以是如剛剛X，Y COORDS簡單）信息的另一類，並且Board是保持約在所有的信息的類棋子在棋盤上。

然後PossibleMoves()的實現將返回枚舉所有可能的移動類型，從給定的位置開始並且處於給定狀態的棋盤。

Answer 3

如果你是初學者，爲什麼不把一些簡單的方法放在你的基類中？

public class Kralica : Figure 
    { 
     protected Tuple<int, int> Position {get; set;} 

     public Kralica(FigureDefinition definition) : base(definition) 
     { 
     } 

     protected override List<Tuple<int, int>> GetValidTurns() 
     { 
      //here i want to combine the 2 methods GetValidTurns from the bishop class and the rook class 
     } 

     protected void AddDiagonalMoves(List<Tuple<int, int>> moves) 
     { 
      diagonalMoves = new List<Tuple<int, int>>(); 

      // calculate diagonal moves from my piece position which should be a member property here 

      moves.AddRange(diagonalMoves); 
     } 
    } 


public class Kralica : Figure 
{ 
    public Kralica(FigureDefinition definition) : base(definition) 
    { 
    } 

    protected override List<Tuple<int, int>> GetValidTurns() 
    { 
     var movesThisTurn = new List<Tuple<int, int>>(); 
     //here i want to combine the 2 methods GetValidTurns from the bishop class and the rook class 
     base.AddDiagonalMoves(movesThisTurn); 
     base.AddLinearMoves(movesThisTurn); 

    } 
} 

然後派生類可以只是重新利用各自GetValidTurns內這些方法構建的移動返回列表。編輯：即使你是初學者，我建議在這裏離開Tuple並創建一個簡單的「點」類或結構。它會使你的代碼更具可讀性，即使對你自己也是如此。