Objective-C Interview Questions and Answers(2025)

Question: What is method swizzling in Objective-C?

Answer:

Method swizzling is an advanced feature in Objective-C that allows you to dynamically change the implementation of a method at runtime. It is a powerful tool that is primarily used for modifying or extending the behavior of existing methods in classes, including system classes or classes for which you don’t have the source code.

In method swizzling, the implementation of a method is exchanged with another method, typically using Objective-C runtime functions, allowing the new method to take over the behavior of the original method.

---

How Method Swizzling Works:

Objective-C uses a dynamic runtime, meaning that methods and their implementations can be swapped at runtime. You can use method swizzling to replace the implementation of an existing method with a custom implementation.

The two key runtime functions involved in method swizzling are:

• class_getInstanceMethod: Retrieves the method from the class.
• method_exchangeImplementations: Swaps the implementations of two methods.

1. Basic Steps of Method Swizzling:

• Identify the methods: Identify the methods you want to swap (the original and the replacement).
• Retrieve method selectors: Use SEL (selectors) to refer to the methods.
• Get the method implementations: Using class_getInstanceMethod, get the method implementations for both methods.
• Swap the implementations: Use method_exchangeImplementations to swap the implementations.

2. Common Use Cases for Method Swizzling:

• Add Custom Behavior to Existing Methods: For example, logging, debugging, or adding analytics tracking to existing methods in classes (like adding logging to viewDidLoad in a view controller).
• Modify or Extend System Classes: Since Objective-C is dynamic, you can modify the behavior of system classes, like UIViewController or UIButton, without subclassing.
• Monkey Patching: Swizzling can be used to “patch” methods of third-party libraries or system classes without modifying the original source code.

However, method swizzling should be used with caution as it modifies the behavior of existing code and can lead to unintended side effects, especially if the original behavior is important for other parts of the application.

---

3. Example of Method Swizzling:

Suppose you want to swizzle the viewDidLoad method in a UIViewController to add custom logging.

Step-by-step Example:

#import <objc/runtime.h>

@implementation UIViewController (Swizzle)

+ (void)load {
    // Ensure swizzling occurs once
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // Get the original method (viewDidLoad)
        Method originalMethod = class_getInstanceMethod(self, @selector(viewDidLoad));
        
        // Get the new method (swizzled_viewDidLoad)
        Method swizzledMethod = class_getInstanceMethod(self, @selector(swizzled_viewDidLoad));
        
        // Exchange the implementations
        method_exchangeImplementations(originalMethod, swizzledMethod);
    });
}

// The new method that adds custom behavior
- (void)swizzled_viewDidLoad {
    // Custom code (e.g., logging)
    NSLog(@"viewDidLoad has been swizzled.");
    
    // Call the original viewDidLoad method (since the methods have been swapped)
    [self swizzled_viewDidLoad];  // Note that this calls the original viewDidLoad implementation
}

@end

In this example:

• The load method is used to ensure the swizzling happens only once, when the class is first loaded.
• The method_exchangeImplementations function swaps the implementation of viewDidLoad with swizzled_viewDidLoad.
• The swizzled_viewDidLoad method performs some custom code (logging) and then calls the original viewDidLoad method via the swapped method.

---

4. Key Concepts of Method Swizzling:

• Selectors (SEL): A selector represents the name of a method. You use selectors to reference methods in Objective-C.

  SEL originalSelector = @selector(viewDidLoad);
  SEL swizzledSelector = @selector(swizzled_viewDidLoad);

• Methods: Methods are retrieved using the class_getInstanceMethod function, which returns a Method object.

  Method originalMethod = class_getInstanceMethod(self, originalSelector);
  Method swizzledMethod = class_getInstanceMethod(self, swizzledSelector);

• Swapping Implementations: The method_exchangeImplementations function swaps the implementations of the two methods.

  method_exchangeImplementations(originalMethod, swizzledMethod);

• Avoid Infinite Recursion: In the example above, calling swizzled_viewDidLoad inside the swizzled method will lead to infinite recursion because it will call itself indefinitely. To avoid this, you call the original implementation by invoking swizzled_viewDidLoad (which actually points to the original viewDidLoad method).

---

5. Cautions and Considerations:

• Method Swizzling Breaks Encapsulation: It directly modifies method behavior at runtime, which could lead to unintended side effects, especially if other parts of the code expect the original method behavior.

• Compatibility Issues: Swizzling may lead to conflicts if multiple parts of your application or third-party libraries swizzle the same method. This could cause unpredictable behavior.

• Hard to Debug: Since the code behavior changes at runtime, it can be difficult to trace issues, especially if method swizzling is done in many places.

• Overriding the Same Method: If multiple swizzling operations target the same method, the order of swizzling matters. The last swizzle operation will take precedence.

---

6. When to Use Method Swizzling:

• Logging and Analytics: Method swizzling is often used for adding logging or analytics code to existing methods without modifying their source code.

• Debugging and Instrumentation: Swizzling can help instrument method calls, useful for debugging or adding performance monitoring.

• Customizing Framework Behavior: If you’re working with an existing framework or third-party code and can’t modify its source, you can use method swizzling to modify or extend its functionality.

---

Conclusion:

Method swizzling is a powerful technique in Objective-C that allows you to change the implementation of methods at runtime. While it provides great flexibility, it should be used with caution as it can lead to unintended side effects, compatibility issues, and difficulties with debugging. It is most commonly used for logging, instrumentation, and modifying system or third-party class behavior.

Question: How does the delegation pattern work in Objective-C?

Answer:

The delegation pattern is a design pattern in Objective-C used to allow one object to delegate responsibility to another object. It is often used to achieve loose coupling between components and to allow for more flexible, reusable code. In delegation, an object (the delegate) acts on behalf of another object (the delegator) by implementing a set of methods that the delegator can call when needed.

Key Concepts:

• Delegator: The object that delegates some of its responsibilities to another object. It holds a reference to the delegate.
• Delegate: The object that performs the delegated responsibilities. It implements a protocol (interface) that defines the methods to be called by the delegator.
• Protocol: A set of methods that the delegate is required to implement, which defines the actions the delegator can call.

The delegation pattern is widely used in Cocoa and Cocoa Touch frameworks. Common examples include delegation in UITableView, UICollectionView, UIViewController, and other UIKit components where events or interactions need to be passed from a view to a controller or from a controller to another object.

---

How Delegation Works:

1. Define a Protocol: The protocol specifies the methods that the delegate must implement. It acts as a contract between the delegator and the delegate.

2. Declare a Delegate Property: The delegator declares a reference to the delegate, usually as a weak property to avoid retain cycles.

3. Set the Delegate: The delegator sets the delegate (usually in a view controller or another object) so that the delegator can call methods on the delegate when necessary.

4. Implement Delegate Methods: The delegate object implements the methods defined in the protocol, allowing the delegator to call these methods when required.

---

Example:

Let’s walk through a simple example of the delegation pattern in Objective-C.

Step 1: Define the Protocol

First, you define a protocol that declares the methods the delegate will implement. This protocol typically starts with “Delegate” in its name to clarify the relationship.

// MyDelegateProtocol.h
#import <Foundation/Foundation.h>

@protocol MyDelegateProtocol <NSObject>
- (void)didPerformAction:(NSString *)action;
@end

In this example, the protocol MyDelegateProtocol has one method didPerformAction: that the delegate must implement.

Step 2: Declare a Delegate Property

Next, declare a property of type id to hold a reference to the delegate. The property is typically declared as weak to avoid strong reference cycles.

// ActionPerformer.h
#import <Foundation/Foundation.h>
#import "MyDelegateProtocol.h"

@interface ActionPerformer : NSObject
@property (nonatomic, weak) id<MyDelegateProtocol> delegate;
- (void)performAction;
@end

In this example, ActionPerformer is the delegator, and it has a delegate property that references an object conforming to the MyDelegateProtocol.

Step 3: Implement the Method to Notify Delegate

The delegator (in this case, ActionPerformer) has a method performAction that performs some task and then calls a method on the delegate.

// ActionPerformer.m
#import "ActionPerformer.h"

@implementation ActionPerformer

- (void)performAction {
    // Perform some action (e.g., a calculation, task completion)
    NSString *action = @"Action Completed";

    // Notify the delegate that the action is complete
    if ([self.delegate respondsToSelector:@selector(didPerformAction:)]) {
        [self.delegate didPerformAction:action];
    }
}

@end

Here, after performing the action, the ActionPerformer object checks if the delegate implements the didPerformAction: method and calls it.

Step 4: Implement the Delegate Methods

Now, a class that will act as the delegate needs to implement the required protocol methods. Typically, this would be in a view controller or another controller object.

// ViewController.h
#import <UIKit/UIKit.h>
#import "MyDelegateProtocol.h"

@interface ViewController : UIViewController <MyDelegateProtocol>

@end

In the ViewController, the class conforms to MyDelegateProtocol, and the didPerformAction: method is implemented.

// ViewController.m
#import "ViewController.h"
#import "ActionPerformer.h"

@interface ViewController ()
@property (nonatomic, strong) ActionPerformer *actionPerformer;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // Create the ActionPerformer object
    self.actionPerformer = [[ActionPerformer alloc] init];
    
    // Set self as the delegate of ActionPerformer
    self.actionPerformer.delegate = self;
    
    // Perform the action
    [self.actionPerformer performAction];
}

#pragma mark - MyDelegateProtocol

- (void)didPerformAction:(NSString *)action {
    NSLog(@"Delegate received: %@", action);
}

@end

In this example, ViewController implements the didPerformAction: method from the MyDelegateProtocol. When ActionPerformer calls this method, it is handled in the ViewController, where we can update the UI or handle the result as needed.

---

Benefits of the Delegation Pattern:

• Loose Coupling: The delegator does not need to know anything about the delegate’s internal details. It only relies on the protocol to communicate, making the two components loosely coupled.
• Flexibility: The delegation pattern allows objects to be extended with new behavior without modifying the original class.
• Reusability: The delegator can be reused across different contexts, and different delegates can be used to handle various tasks.

---

Common Use Cases:

• UITableView and UICollectionView: These classes use delegation to notify their delegate (often a view controller) of various events like selecting a row, editing, or refreshing data.

  For example:

  • UITableViewDelegate handles row selection.
  • UITableViewDataSource provides data for the table.

• UI Components: Many UI components (e.g., UIAlertView, UIActionSheet, UITextField) use delegation to pass events like user interaction back to the owning controller.

• Networking: Some network libraries use delegation to handle network responses and errors asynchronously.

---

Summary:

• Delegation is a design pattern used in Objective-C where one object (the delegator) delegates some responsibilities to another object (the delegate).
• The delegator declares a reference to the delegate and calls methods on it when certain events occur, and the delegate implements the required methods to handle those events.
• The pattern promotes loose coupling, reusability, and flexibility, making it an essential tool in Cocoa and Cocoa Touch development.
• Commonly, delegation is used in UIKit, such as with UITableView, UIViewController, and custom UI components, for handling events or passing data.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as Objective-C interview questions, Objective-C interview experiences, and details about various Objective-C job positions. Click here to check it out.