Question

I have had several situations when i would like to do that. This could be an example:

Consider a possible implementation for the chess game. We define the abstract class ‘Piece’ and classes inheriting from it: ‘bishop’ ‘peon’ ‘tower’ ‘horse’ ‘queen’ etc

We may have our peon about to reach the end of the board, and it may be required for a method called onto that peon object to change the class of that object to ‘Queen’, ‘horse’ or whatever.

So my question is, is there any way to do that in C++ or Java? If not, in any other language?
Also, are there other approaches for this situations in general?

Answer 1

You might be able to use the decorator pattern or the strategy pattern.

With decorator:

interface ChessPiece {
    Set<Move> getPossibleMoves();
    Image getAppearance();
}

class Pawn implements ChessPiece {
    ...
}

class Decorator implements ChessPiece {
    ChessPiece decorated;

    public Decorator(ChessPiece decorated_) {
        this.decorated = decorated_;
    }

    @override
    Set<Move> getPossibleMoves() {
        Set<Move> result = decorated.getPossibleMoves();
        // alter result
        return result;
    }
}

When needed you replace the Pawn instance with the Decorated instance. So it still involves replacing one instance with an other as mentioned in OpenSause’s answer.

ChessPiece pawn = new Pawn;
...
pawn = new Decorated(pawn);

When you plan ahead you can use strategy it is still not really changing classes:

interface PossibleMovesStrategy {
    Set<Move> getPossibleMoves();
}

interface AppearanceStrategy {
    Image getAppearance();
}

class ChangingChessPiece extends ChessPiece {
    PossibleMovesStrategy posMoves;
    AppearanceStrategy appearance;

    @override
    Set<Move> getPossibleMoves() {
        return posMoves.getPossibleMoves();
    }

    @override
    Image getAppearance() {
        return appearance.getAppearance();
    }
}