Replacement and Refinement

There are two general models describing this situation:

Replacement: "American" school of OOP - child method replaces parent method

Refinement: "Scandinavian" school of OOP - behavior of parent and child classes are merged to form new behavior

If replacement used, then some mechanism usually provided for refinement

If refinement default, then replacement not possible

Preserving is-a

• No guarantee that child will do anything similar to parent
• Other methods that depend upon behavior from parent class may fail
• Great havoc  can ensue if programmer is not careful

   Document Replacement or Refinement
 
• Some languages require parent class to indicate replacement is permitted
•  Some languages require child to indicate replacement(e.g., override in Object Pascal)
• Some languages do not automatically document replacement or refinement(e.g., Smalltalk, Java)
       Replacement in C++ - Issues

• If method declared virtual, then polymorphic

• If method is declared virtual, then method not polymorphic

• Constructors use refinement; all other methods use replacement

Class CardPile {
public:
        ...
        virtual int canTake(Card *);
        ...
};

class SuitPile : public CardPile {
public:
        ...
        virtual int canTake(Card *);
        ...
};
 

Replacement in Java
 
• Similar to replacement in C++,but no Virtual keyword

• Can even replace data fields, although these are static and not dynamic

• Keyword final on method prohibits replacement

• Keyword final on class prohibits sub classing altogether

 
 
Replacement in Objective-C and Smalltalk

• Occurs whenever methods in child has same name as in parent

• Square root method in Smalltalk presented earlier
 
Refinement
 
• Method in parent and method in child merged to form new behavior

• Parent class method always executed

• Users guaranteed at least behavior of parent

• Performed automatically on some languages(Simula,Beta)

• Performed by directly invoking parent method from within child method in other languages
 
Refinement in Simula and Beta
 
• Execute code from parent first - when INNER statement encountered, executed child code

• Parent classes wrap around child - almost reverse of American school languages

• Guarantees functionality provided by parent classes
            Refinement in C++

// place a single card into a table pile
void TablePile::addCard(Card * aCard)
{       int tx, ty;

        // pile is empty, just place it normally
        if (top == nilcard)
                CardPile::addCard(aCard);  // note explicit call
        else {  // display it below other cards
                    tx = top->locx( );
                   ty = top->locy( );
                // figure out where to place card
                 if (top->faceUp( ) && top->next( ) != nilcard &&
                        (top->next( ))->faceUp( )) ; // do nothing
                else
                        ty += 30;       // move down a bit
                       CardPile::addCard(aCard);  // note explicit call
                        top->moveTo(tx, ty);
                }
         Constructors Always  do refinement
 
class TablePile : public CardPile {
pubic:
        TablePile(int, int, int);
        ...
private:
        int column;
};

TablePile::TablePile(int c, int x, int y) : CardPile(x, y)
{
        column = c;
}

Refinement in Java

    public void addCard (Card aCard) { cardList.add(aCard); }
   ...
}

class DiscardPile extends CardPile
{   DiscardPile (int x, int y) { super (x, y); }  // parent's constructor

    public void addCard (Card aCard)
    {   if (! aCard.faceUp())
            aCard.flip();
        super.addCard(aCard);  // parent's addCard method
    }
   ...
}