Top 43 Objective-C Interview Questions And Answers

Question 1

Name four important data types found in Objective-C

Accepted Answer

Four data types that you’ll definitely want your developer to be aware of are as follows:

- `NSString`: Represents a string.
- `CGfloat`: Represents a floating point value.
- `NSInteger`: Represents an integer.
- `BOOL`: Represents a boolean.

Question 2

What is a _protocol_, and how do you define your own and when is it used?

Accepted Answer

A protocol is similar to an interface from Java. It defines a list of required and optional methods that a class must/can implement if it adopts the protocol. Any class can implement a protocol and other classes can then send messages to that class based on the protocol methods without it knowing the type of the class.

```objectivec
@protocol MyCustomDataSource
- (NSUInteger)numberOfRecords;
- (NSDictionary *)recordAtIndex:(NSUInteger)index;
@optional
- (NSString *)titleForRecordAtIndex:(NSUInteger)index;
@end
```

A common use case is providing a DataSource for `UITableView` or `UICollectionView`.

Question 3

What is the difference between `copy` and `retain`?

Accepted Answer

In a general setting, retaining an object will increase its retain count by one. This will help keep the object in memory and prevent it from being blown away. What this means is that if you only hold a **retained** version of it, you **share** that copy with whomever passed it to you.

Copying an object, however you do it, should create another object with **duplicate** values. Think of this as a clone. You do NOT share the clone with whomever passed it to you.

Question 4

What is the `reuseIdentifier` used for?

Accepted Answer

The `reuseIdentifier` is used to indicate that a cell can be re-used in a `UITableView`. For example when the cell looks the same, but has different content. The `UITableView` will maintain an internal cache of `UITableViewCell`’s with the `reuseIdentifier` and allow them to be re-used when `dequeueReusableCellWithIdentifier:` is called. By re-using table cell’s the scroll performance of the tableview is better because new views do not need to be created.

Question 5

How to convert an `NSArray` to a string in Objective-C?

Accepted Answer

```objectivec
NSString * result = [[array valueForKey:@"description"] componentsJoinedByString:@""];
```

Question 6

Explain types of protocol in Objective-C

Accepted Answer

* A **formal protocol** declares a list of methods that client classes are expected to implement. Formal protocols have their own declaration, adoption, and type-checking syntax. You can designate methods whose implementation is required or optional with the `@required` and `@optional` keywords. Subclasses inherit formal protocols adopted by their ancestors. A formal protocol can also adopt other protocols. Formal protocols are an extension to the Objective-C language.

* An **informal protocol** is a category on `NSObject`, which implicitly makes almost all objects adopters of the protocol. (A category is a language feature that enables you to add methods to a class without subclassing it.) Implementation of the methods in an informal protocol is optional. Before invoking a method, the calling object checks to see whether the target object implements it. Until optional protocol methods were introduced in Objective-C 2.0, informal protocols were essential to the way Foundation and AppKit classes implemented delegation.

Question 7

What are _blocks_ and how are they used?

Accepted Answer

**Blocks** are a way of defining a single task or unit of behavior without having to write an entire Objective-C class. Under the covers Blocks are still Objective C objects. They are a language level feature that allow programming techniques like lambdas and closures to be supported in Objective-C. Creating a block is done using the `^ { }` syntax:

```objectivec
 myBlock = ^{
    NSLog(@"This is a block");
 }
```

It can be invoked like so:

```objectivec
myBlock();
```

It is essentially a function pointer which also has a signature that can be used to enforce type safety at compile and runtime. For example you can pass a block with a specific signature to a method like so:

```objectivec
- (void)callMyBlock:(void (^)(void))callbackBlock;
```

If you wanted the block to be given some data you can change the signature to include them:

```objectivec
- (void)callMyBlock:(void (^)(double, double))block {
    ...
    block(3.0, 2.0);
}
```

Question 8

What are Objective-C _Categories_?

Accepted Answer

**Categories** provide the ability to add functionality to an object without subclassing or changing the actual object. A handy tool, they are often used to add methods to existing classes, such as NSString or your own custom objects.

- A category can be declared for any class, even if you don't have the original implementation source code.
- Any methods that you declare in a category will be available to all instances of the original class, as well as any subclasses of the original class.
- At runtime, there's no difference between a method added by a category and one that is implemented by the original class.

Consider a category to the Cocoa class `NSString`:
```objectivec
#import <Foundation/Foundation.h>

@interface NSString(MyAdditions)
+(NSString *)getCopyRightString;
@end

@implementation NSString(MyAdditions)

+(NSString *)getCopyRightString {
   return @"Copyright TutorialsPoint.com 2013";
}

@end

int main(int argc, const char * argv[]) {
   NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
   NSString *copyrightString = [NSString getCopyRightString];
   NSLog(@"Accessing Category: %@",copyrightString);
   
   [pool drain];
   return 0;
}
```

Question 9

What is the purpose of managed object context `NSManagedObjectContext` in Objective-C and how does it work?

Accepted Answer

You can think of a `managed object context` as an intelligent scratch pad. When you fetch objects from a persistent store, you bring temporary copies onto the scratch pad where they form an object graph (or a collection of object graphs). You can then modify those objects however you like. **Unless you actually save those changes, however, the persistent store remains unaltered.**

Question 10

What's the difference between the `atomic` and `nonatomic` attributes?

Accepted Answer

**Atomic**

- is the _default_ behavior
- will ensure the present process is completed by the CPU, before another process accesses the variable
- is not fast, as it ensures the process is completed entirely
- thread safe
- ues if the instance variable is gonna be accessed in a multithreaded environment.

**Non-Atomic**

- is NOT the default behavior
- faster (for synthesized code, that is, for variables created using @property and @synthesize)
- not thread-safe
- may result in unexpected behavior, when two different process access the same variable at the same time
- use if the instance variable is not gonna be changed by multiple threads you can use it. It improves the performance.

Suppose there is an atomic string property called "name", and if you call `[self setName:@"A"]` from thread A, call `[self setName:@"B"]` from thread B, and call `[self name]` from thread C, then all operations on different threads will be performed serially which means if one thread is executing a setter or getter, then other threads will wait.

If the property "name" was nonatomic, then all threads in above example - A,B, C and D will execute simultaneously producing any unpredictable result. In case of atomic, either one of A, B or C will execute first, but D can still execute in parallel.

Top 43 Objective-C Interview Questions

Name four important data types found in Objective-C

What is the difference between copy and retain?

What is a protocol, and how do you define your own and when is it used?

What is the reuseIdentifier used for?

What are Objective-C Categories?

Explain types of protocol in Objective-C

What are blocks and how are they used?

A grandparent, parent and child problem

What's the difference between the atomic and nonatomic attributes?

What are some limitations and problems you can face with categories?

What is Key-Value-Coding and Key-Value-Observing in Objective-C?

What is the difference between inheritance and Categories in Objective-C?

When would you use Categories over Inheritance and vice versa?

What mechanisms does iOS provide to support multi-threading?

What is difference between these three classes [NSManagedObject, NSManagedObjectContext, NSManagedObjectModel] of CoreData?

What is the purpose of managed object context NSManagedObjectContext in Objective-C and how does it work?

When to use NSArray vs NSSet?

What is the difference between NSDictionary and NSMutableDictionary?

What is the difference between ARC (automatic reference counting) and GC (garbage collection)?

Explain the difference between interfaces, delegates, and protocols in Objective-C

What's the difference between using a delegate and notification?

Why delegate is never retained?

What are the differences between implementing a @property with @dynamic or @synthesize?

What are the reasons for using NSOperationQueue over GCD and vice versa?

What is the difference between NSMapTable vs NSDictionary?

What is @autoreleasepool?

How to create an abstract class in Objective-C?

What happens when you invoke a method on a nil pointer?

Which is the best of GCD, NSThread or NSOperationQueue?

What are limitations of NSDictionary?

What was wrong with the NSEnumerator technique and why NSFastEnumeration was introduced?

Explain method swizzling. When you would use it?

Why and in which conditions should we use @autoreleasepool?

Explain the use case when ARC won't help you to release memory (but GC will)?

What is Dynamic Dispatch and how does it work in Objective-C?

What's the difference between marking a method as @objc vs dynamic, when would you do one vs the other?

What sending a message to nil means and how is it actually useful?

How to convert an NSArray to a string in Objective-C?

Find the bug in the Objective-C code below. Explain your answer.

What is the bug in this code and what is its consequence?

How can I reverse a NSArray in Objective-C?

What happens when the following code executes?

Will the code below log areEqual or areNotEqual. Explain why?

What is the difference between `copy` and `retain`?

What is the `reuseIdentifier` used for?

What's the difference between the `atomic` and `nonatomic` attributes?

What is difference between these three classes `[NSManagedObject, NSManagedObjectContext, NSManagedObjectModel]` of CoreData?

What is the purpose of managed object context `NSManagedObjectContext` in Objective-C and how does it work?

When to use `NSArray` vs `NSSet`?

What is the difference between `NSDictionary` and `NSMutableDictionary`?

**What's the difference between using a delegate and notification?**

What are the differences between implementing a `@property` with `@dynamic` or `@synthesize`?

What are the reasons for using `NSOperationQueue` over GCD and vice versa?

What is the difference between `NSMapTable` vs `NSDictionary`?

What is `@autoreleasepool`?

What happens when you invoke a method on a `nil` pointer?

Which is the best of GCD, `NSThread` or `NSOperationQueue`?

What are limitations of `NSDictionary`?

What was wrong with the `NSEnumerator` technique and why `NSFastEnumeration` was introduced?

Why and in which conditions should we use `@autoreleasepool`?

What's the difference between marking a method as `@objc` vs `dynamic`, when would you do one vs the other?

What sending a message to `nil` means and how is it actually useful?

How to convert an `NSArray` to a string in Objective-C?

How can I reverse a `NSArray` in Objective-C?

Will the code below log `areEqual` or `areNotEqual`. Explain why?