Why does my superclass object call its subclass method?

Question

I have seen so many helpful threads here, but this is my first time posting!

I was working on the infamous Stanford OpenCourse project: Matchismo. While I got everything going just fine, but I don't understand one part of the sample codes.

Basically the code below is used to get a Card object to compare with another card.

- (void) flipCardAtIndex: (NSUInteger)index
{
    Card *card = [self cardAtIndex:index];
    if (card && !card.isUnplayable)
    {
        if (!card.isFaceUp)
        {
            for (Card* otherCard in self.cards)//for-in loop
            {
                if (otherCard.isFaceUp && !otherCard.isUnplayable)
                {
                    int matchScore = [card match:@[otherCard]];
......

And this is how cardAtIndex works:

-(Card *) cardAtIndex:(NSUInteger)index
{
    if (index < [self.cards count])
        //dot notation is used for property
        //[] is used for method
    {
        return self.cards[index];
    }
    return nil;
}

Here are the methods for Match(card*) and Match(playingCard)

Match(card*)

-(int) match:(NSArray *)otherCards
{
    NSLog(@"here");
    int score = 0;

    for (Card *card in otherCards)
    {
        if ([card.content isEqualToString:self.content])
            score = 1;
        {
            NSLog(@"Card Match");
        }

    }
    return score;
}

Match(PlayingCard*)

-(int) match: (NSArray *)otherCards;
{
    int score = 0;
    if ([otherCards count] == 1)
    {
        PlayingCard *otherCard = [otherCards lastObject];//the last object in the array
        if ([otherCard.suit isEqualToString:self.suit])
            score = 1;
        else if (otherCard.rank == self.rank)
            score = 4;
        NSLog(@"PlayingCard Match");
    }
    return score; 
}

It worked just fine, but I don't get why when a Card* object calls a method, its subclass's PlayingCard's method is invoked. Thanks so much for help me!

Answer 1

This concept is called Polymorphism.

It allows you to have a base class which provides some interface, and a set of subclasses that implement these methods in some different ways. The classic example is a Drawable class method draw, and its subclasses Circle and Rectangle, that both override the draw method to render themselves in some specific manner.

So goes for your Card base class, it calls its own interface method match, but as an object is actually not an instance of Card, but of a PlayingCard subclass, subclass method gets called instead to provide specific implementation.