The Essential Guide to Acing Your Objective-C Interview

Use our engineer-created questions to interview and hire the most qualified Objective-C developers for your organization.

Objective-C is still popular even though Swift has become the language of choice for macOS and iOS apps. This is because it works with both C and C, has a dynamic runtime, and has a mature ecosystem.

Our team has made functional programming tasks and discussion questions that are specifically designed to test developers’ Objective-C skills during coding tests. We have also put together a list of the best ways to make sure that your interview questions are accurate when testing candidates’ Objective-C knowledge.

Intermediate Objective-C interview questions

Question:Explain the concept of categories in Objective-C and their usage. Provide an example demonstrating the usage of categories.

Answer:Categories in Objective-C allow developers to extend existing classes by adding methods without modifying their original implementation. They provide a way to organize and modularize code by grouping related methods into separate files.

Here’s an example of creating a category and implementing it in a class:

In this example, a category named Utilities is created for the NSString class. The category adds two utility methods, reversedString and stringByRemovingWhitespace, which can be called on any NSString instance. The category is implemented in separate header and implementation files.

You can use categories to add utility methods, extend existing classes from frameworks, or separate functions that do similar things into different files.

Question:Explain the concept of Key-Value Observing (KVO) in Objective-C and its usage. Provide an example demonstrating the usage of KVO.

Key-Value Observing (KVO) is a feature in Objective-C that lets objects see when certain properties of other objects change. It provides a way to receive notifications when the observed properties change, enabling loosely coupled communication between objects.

Here’s an example demonstrating the usage of KVO:

In this example, the Observer class observes changes to the name property of the Person class using NSNotificationCenter. When the name property is set, a notification is posted with the updated value. The Observer signs up to be an observer for the PersonNameDidChangeNotification and calls the propertyDidChange: method when something changes.

You can set up relationships between objects and get alerts when properties change with KVO. This lets objects talk to each other without being connected and allows for dynamic behavior.

Which of the following is not the same as assign, weak, or unsafe_unretained in Objective-C? When would you use each one?

To answer your question, in Objective-C, the assign, weak, and unsafe_unretained property attributes tell you what kind of reference to use for a certain property.

• assign: The assign attribute is used for primitive types (e. g. , int, float) and weakly-typed objects. It assigns the value directly without retaining or releasing it. For Manual Reference Counting (MRC), this attribute is used. This is also how object properties normally work.
• weak is an attribute used for object references that makes a weak link to the object. Not only does it not hold on to or release the object, but if the object is deallocated, the reference is set to nil automatically. There are strong reference cycles that this attribute is used to stop in Automatic Reference Counting (ARC).
• When an object is freed, the unsafe_unretained attribute is like weak, but it doesn’t set the reference to nil automatically. The reference turns into a dangling pointer if the object it points to is freed up. In MRC or when working with old code, this attribute is used.

When to use each attribute:

• For primitive types or weakly typed objects that don’t need memory management, use assign.
• Don’t use strong references or retain cycles for object references; instead, use weak references.
• Only use unsafe_unretained when you have to, like in MRC or with old code that doesn’t need the reference to be set to nil automatically.

For safety reasons, it is better to use weak instead of unsafe_unretained whenever possible. This is because weak sets the reference to nil when the object is freed.

Question:Explain the concept of singletons in Objective-C. How do you implement a singleton class? What are the potential issues with singletons?.

Answer:Singletons in Objective-C are classes that can have only one instance throughout the application’s lifecycle. As a result, they give everyone access to a shared instance, so data or features can be used consistently in different parts of the application.

Here’s an example of implementing a singleton class in Objective-C:

In this example, the sharedInstance method is used to access the singleton instance. It uses the Grand Central Dispatch (GCD) function dispatch_once to make sure that the shared instance is only set up once, even when multiple threads are running at the same time.

Potential issues with singletons include:

• Global State: Singletons add global state, which can make it harder to understand how data moves and cause different parts of the codebase to depend on each other.
• Dependency Injection: Because singleton classes often use a global point of access, it’s hard to add dependencies or switch implementations while testing.
• Testing: Because singletons are global and share a state, they can be hard to test. Unit testing can be harder when there are dependencies on the singleton instance.
• When you use singletons, they can make it hard to separate different parts of an application, which can make code maintenance and refactoring harder.

Singletons can be useful in some situations, but it’s important to think about the possible problems and carefully consider whether they should be used in a certain situation. Alternatives such as dependency injection or using instance-based objects may be more flexible and maintainable in many cases.

Question:Explain the concept of delegates in Objective-C. How do delegates enable communication between objects? Provide an example demonstrating the usage of delegates.

Answer:Delegates in Objective-C enable communication and interaction between objects. They let one object give another object certain tasks or responsibilities, which lets you separate behaviors and change how they work.

Here’s an example demonstrating the usage of delegates:

In this example, the MyProtocol protocol defines a method didFinishTask. The MyObject class has a delegate property conforming to MyProtocol. When performTask is called on MyObject, it does the job and lets the delegate know by calling the didFinishTask method, if it responds.

The ViewController class adopts the MyProtocol protocol and becomes the delegate of MyObject. It implements the didFinishTask method to handle the task completion.

Delegates enable objects to communicate and provide a way to customize behavior without tightly coupling the objects together. They are commonly used in frameworks, UI controls, and asynchronous operations.

Question:Explain the concept of blocks in Objective-C. How do blocks let you capture and use variables from the surrounding scope? Give an example of how blocks are used.

Answer:Blocks in Objective-C are self-contained, anonymous segments of code that can be passed around and executed later. They are similar to closures in other programming languages. Blocks hold variables and constants from the scope around them, enclosing both the code and the environment in which it was written.

Here’s an example demonstrating the usage of blocks:

In this example, a block type CompletionBlock is defined using the typedef keyword. The performTaskWithCompletion: method takes a block as a parameter and executes it after performing a task. The block takes a BOOL parameter indicating the success status of the task.

Blocks are commonly used for asynchronous operations, callback mechanisms, and implementing higher-order functions. They let variables from the surrounding scope be captured, so the block can access and change them even after the surrounding scope has ended.

Blocks can capture variables from the surrounding scope by automatically creating a copy of them. The captured variables keep their values even if they leave the scope. This is a powerful way to keep data and behavior together.

Question:Explain the concept of NSNotificationCenter in Objective-C. How does it enable communication between objects? Provide an example demonstrating the usage of NSNotificationCenter.

Answer:NSNotificationCenter in Objective-C is a publish-subscribe mechanism that enables communication between objects using a notification-based system. It allows objects to post notifications and other objects to observe and respond to those notifications.

Here’s an example demonstrating the usage of NSNotificationCenter:

In this example, the MyObject class posts a notification using NSNotificationCenter when doSomething is called. The MyObserver class signs up to be an observer for the “MyNotification” and calls the handleNotification: method in response to the notification.

NSNotificationCenter enables decoupled communication between objects by allowing them to broadcast and receive notifications. Multiple objects can observe the same notification, and notifications can carry additional data through the userInfo dictionary.

Question:Explain the concept of property attributes in Objective-C. What are some common property attributes, and what do they indicate?.

Answer:Property attributes in Objective-C provide additional information about properties, allowing developers to specify behavior and characteristics. They are placed inside parentheses before the property declaration.

Common property attributes include:

• This value means that the property can be read but not changed. The compiler generates a getter method but no setter method.
• This value means that the property can be read and written to. This is the default attribute if none is specified.
• nonatomic: This means that the property is not thread-safe and can be accessed by multiple threads at the same time without synchronization. It speeds things up, but in a multithreaded environment, it can damage data.
• atomic: Makes sure that access is synchronized and that the property is safe for multiple threads. It keeps data safe in a multithreaded setting, but it can slow things down.
• weak: Specifies a weak reference to the property. When the object being referenced is freed up, the reference is set to nil automatically. It helps to avoid strong reference cycles.
• strong/retain: Sets a strong reference to the property, which means the object being referenced stays. The reference count of the object is increased.
• copy: Tells the property to make a copy of the value that was assigned when it is set. It is often used for NSString and block properties to make sure they can’t be changed and to avoid problems with changing them.
• getter=/setter=: Lets you change the names of the property’s getter and setter methods

These attributes provide control over memory management, thread-safety, and customization of property behavior. They allow developers to fine-tune the behavior of properties based on specific requirements.

Question:What is the purpose of using the @autoreleasepool block in Objective-C memory management? When should you use it?

Answer:In Objective-C, the @autoreleasepool block is used to control the autorelease pool, which is in charge of controlling objects that have been automatically released. Things that are autoreleased will have their memory freed automatically when the current run loop iteration ends.

The @autoreleasepool block sets up a local autorelease pool that lets you manage how long autoreleased objects in the block last. When the block is exited, the autorelease pool releases the autoreleased objects, freeing up memory.

When you need to make a lot of temporary objects, like in a loop or an operation that takes a long time, you should use the @autoreleasepool block. By making a local autorelease pool, you can make sure that the memory used by autoreleased objects is freed up more often, which lowers the amount of memory that is used at peak times.

It’s important to remember that after Automatic Reference Counting (ARC) was introduced, managing autorelease pools by hand became a lot easier. In most cases, ARC handles autorelease pools automatically, and explicit use of @autoreleasepool blocks is not necessary. However, using @autoreleasepool blocks can still be helpful in situations where you have clear control over memory management, like in non-ARC code or performance-critical parts.

Question:Explain the concept of method swizzling in Objective-C. How does it work, and what are the potential use cases?.

Answer:Method swizzling in Objective-C is a technique that allows developers to exchange the implementations of methods at runtime. It involves swapping the implementations of two methods, typically belonging to the same class or different classes.

Method swizzling works by manipulating the Objective-C runtime and is primarily accomplished using two functions: class_getInstanceMethod and method_exchangeImplementations. These functions retrieve the method implementations and then swap them.

Potential use cases of method swizzling include:

• Adding Features: Method swizzling lets you add new features to existing methods without changing how they were originally implemented. This can be useful for logging, profiling, or debugging purposes.
• Method Overriding: You can use method swizzling to replace existing methods with a different way to do things than the original method. This can be used to change how third-party libraries or system frameworks work or fix bugs in them.
• A/B Testing: Method swizzling lets you switch between different versions of a method on the fly, so you can do A/B testing or feature toggling without having to change the codebase.
• Fixing Bugs: You can use method swizzling to fix bugs or change how system classes or frameworks work that you don’t control.

It’s important to use method swizzling judiciously and with caution. It can add complexity, make code harder to read and fix, and cause strange behavior or problems when used with other swizzled methods. Care should be taken to ensure that swizzled methods are properly documented, tested, and comply with Apple’s guidelines.

These answers provide an overview of the concepts and explanations for each question. For further understanding, it is recommended to refer to the Objective-C documentation and additional resources.

Objective-C skills to assess

Question:Explain the concept of properties in Objective-C. What are the advantages of using properties over instance variables?

In Objective-C, properties make it easy to hide an object’s state and define the getter and setter methods that can be used to access and change that state. They are declared using the @property syntax and can have attributes like nonatomic, strong, weak, etc.

Advantages of using properties over instance variables include:

• Data encapsulation is possible with properties because they limit who can change an object’s state.
• Automatic Getter and Setter Methods: Properties generate getter and setter methods automatically, which cuts down on repetitive code and makes code easier to read.
• Memory Management: Properties with appropriate memory management attributes (e. g. , strong, weak, copy) automatically manage memory, making tasks related to memory management easier.
• Key-Value Observing (KVO): KVO lets you watch properties and let other objects know when the value of a property changes.
• Dot Notation Syntax: The dot notation syntax lets you access properties, which makes the code shorter and easier to read.

Which of the following is not the same as retain, strong, weak, or copy in Objective-C? When would you use each one?

Answer:

• The words “retain” and “strong” both mean to keep the object and make a strong connection to it. The difference lies in the context:
• In manual reference counting (MRC), retain is used to keep track of who owns an object by hand.
• In automatic reference counting (ARC), “strong” means a strong reference that doesn’t need to be managed by hand. In ARC, this is the default attribute that is often used for instance variables and properties.
• weak means that the reference is weak and doesn’t keep the object alive. It is often used to stop strong reference cycles between objects and break retain cycles.
• When you assign an object to a property, copy makes a copy of it. It’s useful when you want to make sure the value of the object doesn’t change.

The choice between retain/strong and weak depends on the ownership and lifetime requirements of the object. copy is used when you want to ensure the immutability of the object.

Question:Explain the concept of protocols in Objective-C and their usage. Provide an example of creating a protocol and implementing it in a class.

Answer:Protocols in Objective-C define a set of methods that a class can implement. They let you set a contract or interface that many classes can follow, which allows for polymorphism and code reuse.

Here’s an example of creating a protocol and implementing it in a class:

In this example, the Printable protocol is defined using the @protocol directive. It declares a single method, print. The MyClass class adopts the Printable protocol using the syntax. It must implement the required method print defined in the protocol.

Protocols allow polymorphism, which means that different classes can follow the same protocol and be used in place of each other based on the protocol contract.

What are Objective-C blocks, and how are they different from regular methods or functions? Give an example of how blocks can be used.

Answer:Blocks in Objective-C are self-contained, anonymous segments of code that can be passed around and executed later. They are similar to closures in other programming languages. Blocks hold variables and constants from the scope around them, enclosing both the code and the environment in which it was written.

Blocks are different from regular functions or methods because they can be treated as first-class objects. This means they can be stored in variables, passed as arguments, and returned from functions. They provide a way to create and pass behavior as data.

Here’s an example demonstrating the usage of blocks:

In this example, a block type CompletionBlock is defined using the typedef keyword. The performTaskWithCompletion: method takes a block as a parameter and executes it after performing a task. The block takes a BOOL parameter indicating the success status of the task.

Blocks are commonly used for asynchronous operations, callback mechanisms, and implementing higher-order functions.

What’s the point of using the @synthesize directive in Objective-C? When do you need it and when do you not?

Answer:The @synthesize directive in Objective-C is used to automatically generate the getter and setter methods for properties. Prior to Objective-C 2. 0, properties had to be explicitly synthesized in the implementation file using @synthesize propertyName = _propertyName;. However, since Objective-C 2. 0, the @synthesize directive is no longer required in most cases.

When a property is declared, the compiler automatically creates the right accessor methods and an instance variable with the same name as the property, but with an underscore (_) in front of it.

However, there are cases when explicit @synthesize is still useful:

• If you want to change the name of the instance variable that supports the property, you can synthesize it with @synthesize propertyName = _customName;
• You can explicitly synthesize one method and implement the other method by hand if you want to provide custom getter or setter implementations.

With modern Objective-C and automatic synthesis, the @synthesize directive is not needed and can be left out most of the time.

Question:Explain the concept of exceptions in Objective-C. How are exceptions different from error handling using NSError?

Answer:Exceptions in Objective-C provide a mechanism to handle exceptional conditions and unexpected runtime errors. They are thrown with the @throw statement, and @try, @catch, and @finally blocks can catch them and do something with them.

Exceptions differ from error handling using NSError in the following ways:

• Exceptions are used for rare events and runtime errors that were not expected, while NSErrors are usually used for expected errors or conditions that can be fixed.
• Similar to how exceptions are handled in other programming languages, @throw, @try, @catch, and @finally are used to throw and catch exceptions. NSError is usually sent as an error message through return values or as an argument.
• Exceptions can be caught at different levels of the call stack, which lets them be handled centrally. Usually, NSError is handled at the caller level, which gives clear error handling and recovery options.

It is important to remember that Objective-C exceptions should only be used very rarely and only for rare errors that can’t be fixed, like programming mistakes or invalid conditions. For expected errors and recoverable conditions, error handling using NSError is the preferred approach.

Question:What are the differences between NSMutableArray and NSArray in Objective-C? When would you use one over the other?

Answer:

• In Objective-C, NSArray is an immutable array, which means that once it is created, its contents cannot be changed. You can’t add, remove, or change objects in an NSArray after it has been initialized.
• On the other hand, NSMutableArray is a mutable array that lets you add, remove, and change objects on the fly.

You would use NSArray when you have a collection of objects that does not need to be modified. It provides better performance and memory efficiency since it does not need to support mutation operations.

NSMutableArray is used when you need to dynamically modify the array’s contents. It provides methods to add, remove, and replace objects at specific indexes.

To make sure that NSArray is immutable by default and to avoid unintended side effects, it is best to use it whenever possible and only switch to NSMutableArray when mutability is needed.

Question:Explain the concept of key-value coding (KVC) in Objective-C. How does it simplify accessing and manipulating object properties?

Answer: Key-Value Coding (KVC) is a feature in Objective-C that lets you access and change an object’s properties by using strings of keys. Instead of calling the getter and setter methods for properties directly, KVC gives you a single way to read and change property values on the fly.

KVC simplifies accessing and manipulating object properties by providing the following benefits:

• Dynamic Access: KVC lets you read and write properties even if you don’t know their names at compile time. This enables generic code and reduces coupling between classes.
• Collection Operators: KVC has collection operators like @sum, @avg, @max, @min, and @distinctUnionOfObjects that make working with groups of objects easier.
• Key-Value Observing (KVO): KVO is built on KVC, which lets objects see when certain properties of other objects change.
• Introspection and reflection: KVC allows introspection and reflection, which lets you look at an object’s properties as they change over time.

To use KVC, you can use the methods provided by NSObject such as valueForKey: and setValue:forKey: Additionally, KVC-compliant properties can be accessed using dot notation or subscripting.

Question:What is the role of the @autoreleasepool block in Objective-C memory management? When should you use it?

Answer:In Objective-C, the @autoreleasepool block is used to control the autorelease pool, which is in charge of controlling objects that have been automatically released. Things that are autoreleased will have their memory freed automatically when the current run loop iteration ends.

The @autoreleasepool block sets up a local autorelease pool that lets you manage how long autoreleased objects in the block last. When the block is exited, the autorelease pool releases the autoreleased objects, freeing up memory.

When you need to make a lot of temporary objects, like in a loop or an operation that takes a long time, you should use the @autoreleasepool block. By making a local autorelease pool, you can make sure that the memory used by autoreleased objects is freed up more often, which lowers the amount of memory that is used at peak times.

It’s important to remember that after Automatic Reference Counting (ARC) was introduced, managing autorelease pools by hand became a lot easier. In most cases, ARC handles autorelease pools automatically, and explicit use of @autoreleasepool blocks is not necessary. However, using @autoreleasepool blocks can still be helpful in situations where you have clear control over memory management, like in non-ARC code or performance-critical parts.

What is the difference between using dot notation and square bracket syntax to get to object properties and methods in Objective-C?

Answer: In Objective-C, you can access object properties and call methods using either dot notation or square bracket syntax. However, they are not the same and should not be used in the same situations.

Dot Notation:

• Dot notation is a shorthand syntax introduced in Objective-C 2. 0 that lets you get to properties directly by using the dot ( ) operator.
• It makes it easier to read and understand how to get or set property values, which makes the code more expressive.
• You can only use dot notation for properties that are set or retrieved with getter and setter methods.
• It is a feature that is added at compile time and doesn’t affect how the program runs.

Example:

Square Bracket Syntax:

• In Objective-C, square bracket syntax is the standard way to call methods and get to properties.
• It lets you call any method, even ones that don’t have getter or setter semantics, and send messages to objects.
• It’s more adaptable and can be used in more situations, like when passing multiple arguments, calling methods with selectors, or getting to elements in arrays.
• Using square brackets has effects on runtime, since the message dispatch takes place at runtime.

Example:

In general, dot notation is preferred for accessing properties when available since it enhances code readability. When you call a general method, pass arguments, or interact with objects dynamically at runtime, you use square bracket syntax.

Interview questions. Test for Objective-C knowledge. 50% programmers fail it.

FAQ

What is C language basic interview questions?

What is difference between Swift and Objective-C?

What is Objective-C used for?

What can you build with Objective-C?

Do you need Objective-C to work in iOS?

There is still some Objective-C development going on so if you want to work in the iOS dev area, then you will need to know both Swift and Objective-C. Follow along and check 27 most common Objective-C interview questions and answers every experienced iOS and macOS developer should know. Implement Auth0 in any app in just 5 minutes.

What are the C++ interview questions?

Below listed are a few C++ interview questions and answers that can be expected in C++ course in a job interview. Q1) Tell me about yourself? A. (Interviewer might have already gone through your resume, but still he/she wants to know more about you.)

What are the collections of objective questions on C programming?

Here are the collections of objective questions on C programming includes multiple choice questions on fundamental of C programming language. It includes objective questions on the statement terminator and arrays in C, passing an array as an argument to a function, loop structure used on C and the conditional operators used in C programming. 1.

What is the difference between Objective C and Objective C?

objective c is fast like c because there is no Objective C Compiler and all objective C code is resolved to C using structures and function pointers. Objective C is the way in which we can write object oriented programming in C. All the features of an object oriented programming language (Small Talk in objective C) are made using C.