The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Polymorphism

Next ►
►

Polymorphism is a core concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types). In Objective-C, polymorphism is achieved through method overriding and the use of protocols.

Key Concepts

  1. Method Overriding: Subclasses can provide a specific implementation of a method that is already defined in its superclass.
  2. Dynamic Typing: Objective-C supports dynamic typing, which allows the type of an object to be determined at runtime.
  3. Protocols: Protocols define a blueprint of methods that can be implemented by any class. They are similar to interfaces in other programming languages.

Method Overriding

Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This is a fundamental aspect of polymorphism.

Example

#import <Foundation/Foundation.h>

// Superclass
@interface Animal : NSObject
- (void)speak;
@end

@implementation Animal
- (void)speak {
    NSLog(@"Animal speaks");
}
@end

// Subclass
@interface Dog : Animal
@end

@implementation Dog
- (void)speak {
    NSLog(@"Dog barks");
}
@end

// Subclass
@interface Cat : Animal
@end

@implementation Cat
- (void)speak {
    NSLog(@"Cat meows");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Animal *myAnimal;
        
        myAnimal = [[Dog alloc] init];
        [myAnimal speak]; // Output: Dog barks
        
        myAnimal = [[Cat alloc] init];
        [myAnimal speak]; // Output: Cat meows
    }
    return 0;
}

Explanation

  • Superclass Animal: Defines a method speak.
  • Subclass Dog: Overrides the speak method to provide its own implementation.
  • Subclass Cat: Also overrides the speak method with its own implementation.
  • Dynamic Typing: The type of myAnimal is determined at runtime, allowing it to call the appropriate speak method based on the actual object type.

Protocols

Protocols in Objective-C define a list of methods that a class can implement. They are used to achieve polymorphism by allowing different classes to implement the same set of methods.

Example

#import <Foundation/Foundation.h>

// Protocol definition
@protocol Speaker <NSObject>
- (void)speak;
@end

// Class conforming to protocol
@interface Dog : NSObject <Speaker>
@end

@implementation Dog
- (void)speak {
    NSLog(@"Dog barks");
}
@end

// Class conforming to protocol
@interface Cat : NSObject <Speaker>
@end

@implementation Cat
- (void)speak {
    NSLog(@"Cat meows");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        id<Speaker> mySpeaker;
        
        mySpeaker = [[Dog alloc] init];
        [mySpeaker speak]; // Output: Dog barks
        
        mySpeaker = [[Cat alloc] init];
        [mySpeaker speak]; // Output: Cat meows
    }
    return 0;
}

Explanation

  • Protocol Speaker: Defines a method speak.
  • Class Dog: Conforms to the Speaker protocol and implements the speak method.
  • Class Cat: Also conforms to the Speaker protocol and implements the speak method.
  • Dynamic Typing: The type of mySpeaker is determined at runtime, allowing it to call the appropriate speak method based on the actual object type.

Practical Exercises

Exercise 1: Method Overriding

Task: Create a superclass Vehicle with a method move. Create two subclasses Car and Bicycle that override the move method.

Solution:

#import <Foundation/Foundation.h>

// Superclass
@interface Vehicle : NSObject
- (void)move;
@end

@implementation Vehicle
- (void)move {
    NSLog(@"Vehicle is moving");
}
@end

// Subclass
@interface Car : Vehicle
@end

@implementation Car
- (void)move {
    NSLog(@"Car is driving");
}
@end

// Subclass
@interface Bicycle : Vehicle
@end

@implementation Bicycle
- (void)move {
    NSLog(@"Bicycle is pedaling");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Vehicle *myVehicle;
        
        myVehicle = [[Car alloc] init];
        [myVehicle move]; // Output: Car is driving
        
        myVehicle = [[Bicycle alloc] init];
        [myVehicle move]; // Output: Bicycle is pedaling
    }
    return 0;
}

Exercise 2: Protocols

Task: Define a protocol Flyable with a method fly. Create two classes Bird and Airplane that conform to the Flyable protocol and implement the fly method.

Solution:

#import <Foundation/Foundation.h>

// Protocol definition
@protocol Flyable <NSObject>
- (void)fly;
@end

// Class conforming to protocol
@interface Bird : NSObject <Flyable>
@end

@implementation Bird
- (void)fly {
    NSLog(@"Bird is flying");
}
@end

// Class conforming to protocol
@interface Airplane : NSObject <Flyable>
@end

@implementation Airplane
- (void)fly {
    NSLog(@"Airplane is flying");
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        id<Flyable> myFlyable;
        
        myFlyable = [[Bird alloc] init];
        [myFlyable fly]; // Output: Bird is flying
        
        myFlyable = [[Airplane alloc] init];
        [myFlyable fly]; // Output: Airplane is flying
    }
    return 0;
}

Common Mistakes and Tips

  • Forgetting to Override Methods: Ensure that the method in the subclass has the exact same signature as in the superclass.
  • Incorrect Protocol Conformance: Make sure that the class conforms to the protocol and implements all required methods.
  • Dynamic Typing Misuse: Be cautious with dynamic typing to avoid runtime errors. Always check the type before calling methods.

Conclusion

Polymorphism in Objective-C allows for flexible and reusable code by enabling objects of different classes to be treated as objects of a common superclass. Through method overriding and protocols, you can create a more dynamic and scalable codebase. Understanding and effectively using polymorphism is crucial for mastering object-oriented programming in Objective-C.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved