If you're looking for IOS Development Interview Questions for Experienced or Freshers, you are at the right place. There are a lot of opportunities from many reputed companies in the world. According to research IOS Development has a market share of about 12.1%. So, You still have the opportunity to move ahead in your career in IOS Development. Mindmajix offers Advanced IOS Development Interview Questions 2024 that helps you in cracking your interview & acquire your dream career as IOS Developer.
Ans: iOS Simulator can be used to test mobile applications. Xcode tool that comes along with iOS SDK includes Xcode IDE as well as the iOS Simulator. Xcode also includes all required tools and frameworks for building iOS apps. However, it is strongly recommended to test the app on a real device before publishing it.
Are you interested in taking up for IOS Development Certification Training? Enroll in Free Demo on IOS Development Online Training! |
Ans: iOS 4 and above supports multi-tasking and allows apps to remain in the background until they are launched again or until they are terminated.
Ans: SBJson framework is supported by iOS. It is a JSON parser and generator for Objective-C. SBJson provides flexible APIs and additional control that makes JSON handling easier.
Ans: iOS development requires an Intel-based Macintosh computer and iOS SDK.
Ans: The UIKit framework is used to develop the application’s user interface for iOS. UIKit framework provides event handling, drawing model, windows, views, and controls specifically designed for a touch screen interface.
Ans: UIKit classes should be used only from an application’s main thread. Note: The derived classes of UIResponder and the classes which manipulate the application’s user interface should be used from the application’s main thread.
Ans: UI Automation API is used to automate test procedures. Tests scripts are written in JavaScript to the UI Automation API. This in turn simulates user interaction with the application and returns log information to the host computer.
Ans: An application behaves differently when running in the foreground than in the background because of the limitation of resources on iOS devices.
Ans: An app is notified whenever the operating system moves the apps between foreground and background. The operating system improves battery life while it bounds what your app can do in the background. This also improves the user experience with the foreground app.
Ans: The UIKit infrastructure takes care of delivering events to custom objects. As an app developer, you have to override methods in the appropriate objects to process those events.
Ans: An app is said to be in a ‘not running’ state when:
Ans: An app will be in an InActive state if it is running in the foreground but is currently not receiving events. An app stays in InActive state only briefly as it transitions to a different state.
Ans: An app can get into an InActive state when the user locks the screen or the system prompts the user to respond to some event e.g. SMS message, incoming call etc.
Ans: An app is said to be in the inactive state when it is running in the foreground and is receiving events.
Ans: An app enters the background state briefly on its way to being suspended.
Ans: Background state.
Ans: An app is said to be in a suspended state when it is still in memory but is not executing any code.
Ans: In case the system is running low on memory, the system may purge suspended apps without notice.
Ans: On-state transitions can be responded to state changes in an appropriate way by calling corresponding methods on the app’s delegate object.
For example:
applicationDidBecomeActive method can be used to prepare to run as the foreground app.
The applicationDidEnterBackground method can be used to execute some code when the app is running in the background and may be suspended at any time.
applicationWillEnterForeground method can be used to execute some code when your app is moving out of the background
application will terminate method is called when your app is being terminated.
Ans: Before the launch of an app, it is said to be in not running state.
When an app is launched, it moves to the active or background state, after transitioning briefly through the inactive state.
Ans: During app launching, the system creates a main thread for the app and calls the app’s main function on that main thread. The Xcode project’s default main function hands over control to the UIKit framework, which takes care of initializing the app before it is run.
Ans: Controller object UIApplication is used without subclassing to manage the application event loop.
It coordinates other high-level app behaviors.
It works along with the app delegate object which contains app-level logic.
Ans: The app delegate object is created by the UIApplicationMain function at app launch time. The app delegate object’s main job is to handle state transitions within the app.
Ans: App delegate is declared as a subclass of UIResponder by Xcode project templates.
Ans: In such a case, the event will be dispatched to your app delegate for processing.
Ans: Data model objects are app-specific objects and store the app’s content. Apps can also use document objects to manage some or all of their data model objects.
Ans: Document objects are not required but are very useful in grouping data that belongs in a single file or file package.
Ans: View controller objects take care of the presentation of the app’s content on the screen. A view controller is used to manage a single view along with the collection of subviews. It makes its views visible by installing them in the app’s window.
Ans: UIViewController class. The functionality for loading views, presenting them, rotating them in response to device rotations, and several other standard system behaviors are provided by UIViewController class.
Ans: The presentation of one or more views on a screen is coordinated by the UIWindow object.
Ans: To change the content of your app, you use a view controller to change the views displayed in the corresponding window. Remember, the window itself is never replaced.
Ans: Views along with controls are used to provide a visual representation of the app content. A view is an object that draws content in a designated rectangular area and it responds to events within that area.
Ans: Custom views can be defined by subclassing UIView.
Ans: Apart from incorporating views and controls, an app can also incorporate Core Animation layers into its view and control hierarchies.
Ans: Layer objects are data objects which represent visual content. Layer objects are used by views to render their content. Custom layer objects can also be added to the interface to implement complex animations and other types of sophisticated visual effects.
Ans: By Subclassing the UIView class.
Ans: When you build your iOS app, Xcode packages it as a bundle. A bundle is a directory in the file system that groups related resources together in one place. An iOS app bundle contains the app executable file and supporting resource files such as app icons, image files, and localized content.
Ans: Fast enumeration is a language feature that allows you to enumerate the contents of a collection. (Your code will also run faster because the internal implementation reduces message send overhead and increases pipelining potential.)
Related Article: iPhone Tutorials for Beginners |
Ans: A struct is a special C data type that encapsulates other pieces of data into a single cohesive unit. Like an object, but built into C.
Ans: NSArray's contents can not be modified once it?s been created whereas an NSMutableArray can be modified as needed, i.e items can be added/removed from it.
Ans: The frame of a view is the rectangle, expressed as a location (x,y) and size (width, height) relative to the superview it is contained within. The bounds of a view is the rectangle, expressed as a location (x,y) and size (width, height) relative to its own coordinate system (0,0).
Ans: No, the delegate is never retained! Ever!
Ans: UIButton inherits from UIControl, UIControl inherits from UIView, UIView inherits from UIResponder, UIResponder inherits from the root class NSObject.
Ans:
Ans: We can use generated code like nonatomic, atomic, retain without writing any lines of code. We also have getter and setter methods. To use this, you have 2 other ways: @synthesize or @dynamic: @synthesize, the compiler will generate the getter and setter automatically for you, @dynamic: you have to write them yourself.@property is really good for memory management, for example: retain.How can you do retain without @property?
if (_variable != object)
{
[_variable release];
_variable = nil;
_variable = [object retain];
}
How can you use it with @property?self. variable = object; When we are calling the above line, we actually call the setter like [self setVariable:object] and then the generated setter will do its job.
Ans: iOS 4.0.
Ans: 256bytes.
Ans: Yes, the object is retained. It creates a timer that calls a selector on the current threads' run loop. It may not be 100% precise time-wise as it attempts to dequeue the message from the run loop and perform the selector.
Ans: When you send an object an autorelease message, its retain count is decremented by 1 at some stage in the future. The object is added to an autorelease pool on the current thread. The main thread loop creates an autorelease pool at the beginning of the function and releases it at the end.
This establishes a pool for the lifetime of the task. However, this also means that any autorelease objects created during the lifetime of the task are not disposed of until the task completes. This may lead to the task's memory footprint increasing unnecessarily. You can also consider creating pools with a narrower scope or use NSOperationQueue with it's own autorelease pool. (Also important – You only release or autorelease objects you own.)
Ans: NSCoder is an abstractClass that represents a stream of data that is used in Archiving and Unarchiving objects. NSCoder objects are usually used in a method that is being implemented so that the class conforms to the protocol. (which has something like encodeObject and decode objects methods in them).
Ans: The NSOperationQueue class regulates the execution of a set of NSOperation objects. An operation queue is generally used to perform some asynchronous operations on a background thread so as not to block the main thread.
Ans: Create them as properties in the header that are retained. In the viewDidUnload set the outlets to nil(i.e self.outlet = nil). Finally, in dealloc make sure to release the outlet.
Ans: For security reasons, iOS places each app (including its preferences and data) in a sandbox at install time. A sandbox is a set of fine-grained controls that limit the app’s access to files, preferences, network resources, hardware, and so on.
As part of the sandboxing process, the system installs each app in its own sandbox directory, which acts as the home for the app and its data.
To help apps organize their data, each sandbox directory contains several well-known subdirectories for placing files. The above Figure shows the basic layout of a sandbox directory.
Ans: Yes, it is!! This is one of the rare exceptions to memory management rules.
Ans: You use the @dynamic keyword to tell the compiler that you will fulfill the API contract implied by a property either by providing method implementations directly or at runtime using other mechanisms such as dynamic loading of code or dynamic method resolution.
It suppresses the warnings that the compiler would otherwise generate if it can’t find suitable implementations. You should use it only if you know that the methods will be available at runtime.
Ans: Ball *ball = [[[[Ball alloc] init] autorelease] autorelease];
It will crash because it's added twice to the autorelease pool and when it is dequeued the autorelease pool calls release more than once.
Ans: In the context of an NSOperation object, which runs in an NSOperationQueue, the terms concurrent and non-concurrent do not necessarily refer to the side-by-side execution of threads. Instead, a non-concurrent operation is one that executes using the environment that is provided for it while a concurrent operation is responsible for setting up its own execution environment.
Ans: Well, you would want to implement the getter and setter for the title object. Something like this: view source print?
– (NSString*) title // Getter method
{
return title;
}
– (void) setTitle: (NSString*) newTitle //Setter method
{
if (newTitle != title)
{
[title release];
title = [newTitle retain]; // Or copy, depending on your needs.
}
}
Ans:
-(id)retain
{
NSIncrementExtraRefCount(self);
return self;
}
-(void)release
{
if(NSDecrementExtraRefCountWasZero(self))
{NSDeallocateObject(self);
}
}
-(id)autorelease
{ // Add the object to the autorelease pool
[NSAutoreleasePool addObject:self];
return self;
}
Ans:
Ans: ARC is a compiler-level feature that simplifies the process of managing the lifetimes of Objective-C objects. Instead of you having to remember when to retain or release an object, ARC evaluates the lifetime requirements of your objects and automatically inserts the appropriate method calls at compile time.
Ans: Assign creates a reference from one object to another without increasing the source’s retain count.
if (_variable != object)
{
[_variable release];
_variable = nil;
_variable = object;
}
Retain creates a reference from one object to another and increases the retain count of the source object.
if (_variable != object)
{
[_variable release];
_variable = nil;
_variable = [object retain];
}
Name | Dates | |
---|---|---|
IOS Development Training | Nov 02 to Nov 17 | View Details |
IOS Development Training | Nov 05 to Nov 20 | View Details |
IOS Development Training | Nov 09 to Nov 24 | View Details |
IOS Development Training | Nov 12 to Nov 27 | View Details |
Ravindra Savaram is a Technical Lead at Mindmajix.com. His passion lies in writing articles on the most popular IT platforms including Machine learning, DevOps, Data Science, Artificial Intelligence, RPA, Deep Learning, and so on. You can stay up to date on all these technologies by following him on LinkedIn and Twitter.