如何在这里使用多态来改进代码？

Question

I've read around that instead of using instanceof and getClass methods to implement polymorphism, as it's better object-oriented practice.

If my program looks like the following:

Piece
SlowPiece extends Piece,
FastPiece extends Piece,
SlowFlexible extends SlowPiece,
FastFlexible extends FastPiece

And I have the following rule: SlowPiece's can only move one space, and FastPiece's as many as they'd like.

How would I use polymorphism to ensure that if I'm moving a Piece like Piece piece1 = new SlowPiece(); that it is not moved more than one?

I've got a class for the game-board, and it should be able to move the piece, but I'm not sure how to stop it from moving a SlowPiece more than 1 without code-sniffing.

Basically, I get how polymorphism is fantastic for say, listing things, but with actually interacting with them I don't get how to use it properly.

Answer 1

Make Piece abstract and add an abstract method move() to Piece (you could also user an interface). Implement move() differently (a SlowPiece only moves 1 spot, etc).

public abstract class Piece {
    public abstract void move();
}

public class SlowPiece extends Piece {
    public void move() {
        System.out.println("moving a slow piece");
    }
}

public class FastPiece extends Piece {
    public void move() {
        System.out.println("moving a fast piece");
    }
}

Piece f = new FastPiece();
f.move();       

Piece s = new SlowPiece();
s.move();

Here, move() has all the moving logic; you could even use some overloads to allow for movement variety (like take N/S/W/E as arguments, etc).

Answer 2

As another consideration to this problem, let's understand the basic overall concept.

• A Piece can move() .
• Certain types of Piece move() in a different manner than others.

One can declare Piece as an interface, and have all other Piece s implement this. This way, you're guaranteeing that every Piece has a move() , and also forcing you to ensure that every move() is distinct, depending on the Piece .

Answer 3

More than polymorphism you should probably think about responsabilities.

You "board" class should do just something like

piece.move();

and the piece should know how to move. So if you have like a dice you can pass to the move method the number and act consequently as

piece.move(moves);

---

EDIT:

the board should manage the movements, so let the move method return an int of the steps made by the piece. The movement should be managed from another class, like board, not from the piece itself.

I suggest you a very interesting book about OO Analysis: "Applying uml and patterns" by Craig Larman. It contains also a step-by-step example of a board game as Monopoly!