Objective C Functions


Objective-C Methods and Messages: Understanding the Core Concepts

Objective-C is a powerful and versatile programming language, primarily used for developing applications on Apple’s iOS and macOS platforms. At the heart of Objective-C lie its methods and messages, which are fundamental concepts that every Objective-C developer must grasp. In this comprehensive guide, we’ll delve into the world of Objective-C methods and messages, breaking down their syntax, types, and usage, and providing you with practical code examples to solidify your understanding.

Objective-C Methods and Messages: Understanding the Core Concepts

1. What are Objective-C Methods and Messages?

Before we dive into the nitty-gritty details, let’s clarify what we mean by Objective-C methods and messages.

  • Objective-C Methods are blocks of code that encapsulate a specific task or behavior. You can think of them as functions in other programming languages, but in Objective-C, they are always associated with a class.
  • Messages, on the other hand, are a means of invoking methods on objects. In Objective-C, you send messages to objects to instruct them to perform certain actions or return specific values. This is a fundamental departure from the syntax used in languages like C++ or Java, which employ method calls instead.

2. Defining Objective-C Methods


In Objective-C, methods are defined within a class. Here’s the basic syntax for declaring a method:

- (returnType)methodName:(parameterType1)parameterName1 withSecondParameter:(parameterType2)parameterName2 {
    // Method implementation goes here

Let’s break this down:

  • The – or + symbol at the beginning indicates whether the method is an instance method (-) or a class method (+). Instance methods are called on an instance of a class, while class methods are called on the class itself.
  • returnType specifies the type of data the method will return. It can be void if the method doesn’t return anything.
  • methodName is the name of the method.
  • parameterType1 and parameterType2 are the types of parameters the method accepts.
  • parameterName1 and parameterName2 are the names of the parameters.


Let’s create a simple class named Calculator with a method that adds two numbers.

@interface Calculator : NSObject

- (int)addNumber:(int)num1 withSecondNumber:(int)num2;


@implementation Calculator

- (int)addNumber:(int)num1 withSecondNumber:(int)num2 {
    return num1 + num2;


In this example, we’ve defined an instance method addNumber:withSecondNumber: that takes two integer parameters and returns their sum.

3. Sending Messages in Objective-C

Now that we know how to define methods, let’s learn how to send messages to objects in Objective-C.


Sending a message to an object in Objective-C is straightforward. Here’s the syntax:

[objectName methodNameWithParameter1:parameterValue1 withParameter2:parameterValue2];

objectName is the name of the object to which you’re sending the message.

methodNameWithParameter1:parameterValue1 withParameter2:parameterValue2 is the name of the method you want to call, along with the parameter values.


Using our Calculator class from earlier, let’s create an instance and send it a message to add two numbers.

Calculator *myCalculator = [[Calculator alloc] init];
int sum = [myCalculator addNumber:5 withSecondNumber:3];
NSLog(@"The sum is %d", sum); // Output: The sum is 8

In this code snippet, we:

  1. Create an instance of the Calculator class called myCalculator.
  2. Send the addNumber:withSecondNumber: message to myCalculator with the values 5 and 3 as parameters.
  3. Store the result in the sum variable.
  4. Print the result using NSLog.

4. Understanding Method Signatures

Method signatures, also known as method selectors, play a crucial role in message dispatch in Objective-C. A method signature is a unique identifier for a method, consisting of the method’s name and parameter types.

In Objective-C, you can retrieve a method’s signature using the @selector directive. Let’s see how it works:


SEL methodSignature = @selector(methodNameWithParameter1:withParameter2:);


SEL addMethodSignature = @selector(addNumber:withSecondNumber:);

The addMethodSignature now holds the method signature for the addNumber:withSecondNumber: method of our Calculator class.

5. Types of Objective-C Methods

Objective-C supports various types of methods, each serving a different purpose. Let’s explore some of the most common types:

5.1. Instance Methods

Instance methods are associated with instances of a class. They operate on the data within those instances and can be invoked only on instances of the class. We’ve already seen examples of instance methods in the previous sections.

5.2. Class Methods

Class methods are associated with the class itself rather than with instances of the class. They are prefixed with a + symbol. Class methods are often used for tasks that don’t require access to instance-specific data.

5.3. Factory Methods

Factory methods are a type of class method that create and return instances of the class. They are commonly used for object creation and initialization. A common naming convention for factory methods is to start the method name with + and use keywords like new or alloc to indicate their purpose.

+ (instancetype)newCalculator;

5.4. Getter and Setter Methods

Getter and setter methods are used to access and modify an object’s properties, respectively. These methods are typically used for encapsulation and data access control.

- (NSString *)name; // Getter
- (void)setName:(NSString *)newName; // Setter

5.5. Convenience Methods

Convenience methods are designed to simplify common tasks and improve code readability. They often combine multiple operations into a single method call.

- (NSString *)fullName;

6. Message Dispatch in Objective-C

Understanding how messages are dispatched is essential in Objective-C, as it determines which method is executed when a message is sent to an object. The process can be summarized in the following steps:

  1. The Objective-C runtime searches for the method with the given selector (method name) in the object’s class.
  2. If the method is found, it is executed.
  3. If the method is not found in the object’s class, the runtime searches the class’s superclass.
  4. This process continues up the class hierarchy until the method is found or the root class (NSObject) is reached.

7. Overriding Methods

In Objective-C, you can override (replace) a superclass’s method with a specialized implementation in a subclass. This is a powerful feature that allows you to customize the behavior of your objects.

To override a method, you must declare a method with the same name and signature in the subclass. Here’s an example:

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

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

// Subclass
@interface Dog : Animal

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

In this example, we have a superclass Animal with a speak method. The Dog subclass overrides the speak method to provide its own implementation.

8. Dynamic Method Resolution

Objective-C provides a mechanism for dynamically resolving methods at runtime. This can be useful when you want to handle messages that are not initially implemented in a class.

To dynamically resolve a method, you can implement the resolveInstanceMethod: or resolveClassMethod: class method in your class. These methods are called before the runtime throws an error for an unrecognized selector.

+ (BOOL)resolveInstanceMethod:(SEL)selector {
    if (selector == @selector(dynamicMethod)) {
        class_addMethod([self class], selector, (IMP)dynamicMethodImplementation, "v@:");
        return YES;
    return [super resolveInstanceMethod:selector];

void dynamicMethodImplementation(id self, SEL _cmd) {
    NSLog(@"Dynamic method called");

In this example, when the runtime encounters a message for the dynamicMethod selector, it dynamically adds the method to the class and associates it with the dynamicMethodImplementation function.


Objective-C methods and messages are at the core of iOS and macOS development. They enable communication between objects and define the behavior of classes. Understanding how to define and send messages is essential for building robust and functional applications on Apple’s platforms.

In this guide, we’ve covered the syntax and types of Objective-C methods, as well as how to send messages to objects. We’ve explored different method types and discussed the process of message dispatch. Additionally, we touched on method overriding and dynamic method resolution, demonstrating the flexibility and power of Objective-C.

As you continue your journey in Objective-C development, mastering these fundamental concepts will pave the way for creating elegant and efficient code that interacts seamlessly with the vast array of Apple frameworks and libraries. So, dive in, practice, and unlock the full potential of Objective-C methods and messages in your iOS and macOS projects.

Previously at
Flag Argentina
time icon
Senior Mobile Engineer with extensive experience in Objective-C. Led complex projects for top clients. Over 6 years. Passionate about crafting efficient and innovative solutions.