Cocoa Objective-C Interview Questions-Answers

This include only entry level(0-3 years) Cocoa / Objective-C topics, which I and few of my friends were asked in interviews. This does not include iOS, logical and any other aspect of development.
I compiled this from apple documentation, stackoverflow and many other helping websites, you can find better and more suitable description on any of the topics from other available sources.
Few topics are without description, I will try to add asap, please suggest if you find any description /notes incorrect.

http://in.linkedin.com/pub/anoop-kumar-vaidya/23/140/513
1.    Cocoa.
Cocoa is an application environment for both the Mac OS X operating system and iOS. It consists of a suite of object-oriented software libraries, a runtime system, and an integrated development environment. Carbon is an alternative environment in Mac OS X, but it is a compatibility framework with procedural programmatic interfaces intended to support existing Mac OS X code bases.

2.     Frameworks that make Cocoa.
·       Appkit (Application Kit)
·       Foundation

3.     Objective-C.
Objective-C is a very dynamic language. Its dynamism frees a program from compile-time and link-time constraints and shifts much of the responsibility for symbol resolution to runtime, when the user is in control. Objective-C is more dynamic than other programming languages because its dynamism springs from three sources:
·         Dynamic typing—determining the class of an object at runtime
·         Dynamic binding—determining the method to invoke at runtime
·         Dynamic loading—adding new modules to a program at runtime

4.     Objective-C vs C/C++.

·       The Objective-C class allows a method and a variable with the exact same name. In C++, they must be different.
·       Objective-C does not have a constructor or destructor. Instead it has init and dealloc methods, which must be called explicitly.(Note:Constructors and Destructors are special member functions of classes that are used to construct and destroy class objects. Construction may involve memory allocation and initialization for objects. Destruction may involve cleanup and deallocation of memory for objects.
Constructor function gets invoked when an object of a class is constructed (declared) and destructor function gets invoked when the object is destructed (goes out of scope).)
·       Objective-C uses + and - to differentiate between factory and instance methods, C++ uses static to specify a factory method.

Example:
   @interface MyClass : NSObject
       + (void)aClassMethod;
       - (void)anInstanceMethod;
   @end

   [MyClass aClassMethod];
   MyClass *object = [[MyClass alloc] init];
   [object anInstanceMethod];

Note:
An instance method applies to an instance of the class (i.e. an object) whereas a class method applies to the class itself.

Class methods

    Operate on Class variables (they can not access instance variables)
    Do not require an object to be instantiated to be applied
    Sometimes can be a code smell (some people who are new to OOP use as a crutch to do Structured Programming in an OO enviroment)

Instance methods

    Operate on instances variables and class variables
    Must have an instanciated object to operate on

·       Multiple inheritance is not allowed in Obj-C, however we can use protocol to some extent. (a class can inherit characteristics and features from more than one superclass. )
·       Obj-C has runtime binding leading to dynamic linking.
·       Obj-C has got categories.
·       Objective-C has a work-around for method overloading, but none for operator overloading.
Note:
   Function overloading or method overloading is a feature found in various programming languages such as Ada, C++, C#, D, and Java, that allows creating several methods with the same name which differ from each other in the type of the input and the output of the function.

·       Objective-C also does not allow stack based objects. Each object must be a pointer to a block of memory.

Note:

    Static → whole program lifetime
    Automatic (stack) → until the end of the current function
    Dynamic (heap) → until it gets explicitly ended (via delete)

·       In Objective-C the message overloading is faked by naming the parameters. C++ actually does the same thing but the compiler does the name mangling for us. In Objective-C, we have to mangle the names manually.
·       One of C++'s advantages and disadvantages is automatic type coercion.
·       Another feature C++ has that is missing in Objective-C is references. Because pointers can be used wherever a reference is used, there isn't much need for references in general.
·       Templates are another feature that C++ has that Objective-C doesn't. Templates are needed because C++ has strong typing and static binding that prevent generic classes, such as List and Array.

5.     Appilcation Kit/App kit.
The Application Kit is a framework containing all the objects you need to implement your graphical, event-driven user interface: windows, panels, buttons, menus, scrollers, and text fields. The Application Kit handles all the details for you as it efficiently draws on the screen, communicates with hardware devices and screen buffers, clears areas of the screen before drawing, and clips views.
You also have the choice at which level you use the Application Kit:
·         Use Interface Builder to create connections from user interface objects to your application objects.
Note:
   Interface Builder is a software development application for Apple's Mac OS X operating system. It is part of Xcode (formerly Project Builder), the Apple Developer Connection developer's toolset. Interface Builder allows Cocoa and Carbon developers to create interfaces for applications using a graphical user interface. The resulting interface is stored as a .nib file, short for NeXT Interface Builder, or more recently, as a .xib file.

·         Control the user interface programmatically, which requires more familiarity with AppKit classes and protocols.
·         Implement your own objects by subclassing NSView or other classes.

Note:
   "NSView" is a class that defines the basic drawing, event-handling, and printing architecture of an application. You typically don’t interact with the NSView API directly; rather, your custom view classes inherit from NSView and override many of its methods, which are invoked automatically by the Application Kit.

6.   Foundation Kit.
The Foundation framework defines a base layer of Objective-C classes. In addition to providing a set of useful primitive object classes, it introduces several paradigms that define functionality not covered by the Objective-C language. The Foundation framework is designed with these goals in mind:
·         Provide a small set of basic utility classes.
·         Make software development easier by introducing consistent conventions for things such as deallocation.
·         Support Unicode strings, object persistence, and object distribution.
·         Provide a level of OS independence, to enhance portability.

7.     Dynamic and Static Typing.
Static typed languages are those in which type checking is done at compile-time, whereas dynamic typed languages are those in which type checking is done at run-time.
Objective-C is a dynamically-typed language, meaning that you don't have to tell the compiler what type of object you're working with at compile time. Declaring a type for a varible is merely a promise which can be broken at runtime if the code leaves room for such a thing. You can declare your variables as type id, which is suitable for any Objective-C object.

Note:
   A variable is dynamically typed when the type of the object it points to is not checked at compile time. Objective-C uses the id data type to represent a variable that is an object without specifying what sort of object it is. This is referred to as dynamic typing.

Dynamic typing contrasts with static typing, in which the system explicitly identifies the class to which an object belongs at compile time. Static type checking at compile time may ensure stricter data integrity, but in exchange for that integrity, dynamic typing gives your program much greater flexibility. And through object introspection (for example, asking a dynamically typed, anonymous object what its class is), you can still verify the type of an object at runtime and thus validate its suitability for a particular operation.

The following example illustrates dynamic typing using a heterogeneous collection of objects:

NSArray *anArray = [NSArray arrayWithObjects:@"A string", [NSDecimalNumber zero], [NSDate date], nil];

NSInteger index;

for (index = 0; index < 3; index++) {

    id anObject = [anArray objectAtIndex:index];

    NSLog(@"Object at index %d is %@", index, [anObject description]);

}

The object pointed to by the variable at runtime must be able to respond to whatever messages you send to it; otherwise, your program throws an exception. The actual implementation of the method invoked is determined using dynamic binding.

8.     Selectors
In Objective-C, selector has two meanings. It can be used to refer simply to the name of a method when it’s used in a source-code message to an object. It also, though, refers to the unique identifier that replaces the name when the source code is compiled. Compiled selectors are of type SEL. All methods with the same name have the same selector. You can use a selector to invoke a method on an object—this provides the basis for the implementation of the target-action design pattern in Cocoa.
[friend performSelector:@selector(gossipAbout:) withObject:aNeighbor];
is equivalent to:
[friend gossipAbout:aNeighbor];

9.     Class Introspection
·         Determine whether an objective-C object is an instance of a class
        [obj isMemberOfClass:someClass];
·         Determine whether an objective-C object is an instance of a class or its descendants(child)
        [obj isKindOfClass:someClass];
·         The version of a class
        [MyString version]
·         Find the class of an Objective-C object
        Class c = [obj1 class]; Class c = [NSString class];
·         Verify 2 Objective-C objects are of the same class
[obj1 class] == [obj2 class]

10. Immutable vs Mutable
Immutable objects cant be changed. However they are just pointing to some location where stored values are made constant. You can change that reference to other location. Mutable objects can change the value.

11. Category
In Objective-C, new functionality can be added to existing classes by adding a new category. Shared libraries that depend on a base class that has been extended will continue to work, and new classes created can call the additional methods. Category on NSString will become available on NSMutableArray.
We can add new ivar to a category using these: (It is required when we have APIs of some other, don’t have code)
@interface NSFruit (Liking)
@property ( nonatomic ) BOOL liked ;
@end

@implementation NSFruit (Liking)
-(BOOL)liked{
    return [ objc_getAssociatedObject( self, "_abliked" ) boolValue ] ;
}
-(void)setLiked:(BOOL)b{
objc_setAssociatedObject(self, "_abliked", [ NSNumber numberWithBool:b ], OBJC_ASSOCIATION_RETAIN_NONATOMIC ) ;
}
@end

12. Proxy
As long as there aren't any extra instance variables, any subclass can proxy itself as its superclass with a single call. Each class that inherits from the superclass, no matter where it comes from, will now inherit from the proxied subclass. Calling a method in the superclass will actually call the method in the subclass. For libraries where many objects inherit from a base class, proxying the superclass can be all that is needed.

13. Category vs Inheritance
Category allows adding methods only; no data members can be added as in Inheritance both data and methods can be added. Category’s scope is full application whereas inheritance’s scope that particular file.

14. Why category is better than inheritance?
       If category is used, you can use same class, no need to remember a new class-name. Category created on a base class is available on sub classes.

15. Fast enumeration
Fast enumeration is a language feature that allows you to enumerate over the contents of a collection. (Your code will also run faster because the internal implementation reduces message send overhead and increases pipelining potential.)
Enum is preferred over loop for the same reason.

16. Protocol
· A Protocol in Objective-C is identical in functionality to an interface in Java, or a purely virtual class in C++.
· A protocol is means to define a list of required and/or optional methods that a class implements. If a class adopts a protocol, it must implement all required methods in the protocols it adopts.
· Cocoa uses protocols to support interprocess communication through Objective-C messages. In addition, since Objective-C does not support multiple inheritance, you can achieve similar functionality with protocols, as a class can adopt more than one protocol.
· A good example of a protocol is NSCoding, which has two required methods that a class must implement. This protocol is used to enable classes to be encoded and decoded, that is, archiving of objects by writing to permanent storage.

17. Formal Protocols
Formal Protocols allow us to define the interface for a set of methods, but implementation is not done. Formal Protocols are useful when you are using DistributedObjects, because they allow you to define a protocol for communication between objects, so that the DO system doesn't have to constantly check whether or not a certain method is implemented by the distant object.

18. Formal vs informal protocol.
In addition to formal protocols, you can also define an informal protocol by grouping the methods in a category declaration:
@interface NSObject (MyProtocol)
        //someMethod();
@end
Informal protocols are typically declared as categories of the NSObject class, because that broadly associates the method names with any class that inherits from NSObject. Because all classes inherit from the root class, the methods aren’t restricted to any part of the inheritance hierarchy. (It is also possible to declare an informal protocol as a category of another class to limit it to a certain branch of the inheritance hierarchy, but there is little reason to do so.)
When used to declare a protocol, a category interface doesn’t have a corresponding implementation. Instead, classes that implement the protocol declare the methods again in their own interface files and define them along with other methods in their implementation files.
An informal protocol bends the rules of category declarations to list a group of methods but not associate them with any particular class or implementation.
Being informal, protocols declared in categories don’t receive much language support. There’s no type checking at compile time nor a check at runtime to see whether an object conforms to the protocol. To get these benefits, you must use a formal protocol. An informal protocol may be useful when all the methods are optional, such as for a delegate, but (in Mac OS X v10.5 and later) it is typically better to use a formal protocol with optional methods.

19. Optional vs required
Protocol methods can be marked as optional using the @optional keyword. Corresponding to the @optional modal keyword, there is a @required keyword to formally denote the semantics of the default behavior. You can use @optional and @required to partition your protocol into sections as you see fit. If you do not specify any keyword, the default is @required.
                @protocol MyProtocol
                                @optional
                                                -(void) optionalMethod;
                                @required
                                                -(void) requiredMethod;
                @end

20. Memory Management
If you alloc, retain, or copy/mutablecopy it, it's your job to release it. Otherwise it isn't.

21. Retain Counting
Every object has a RetainCount that goes up by one when the object gets a retain message. It goes down by one when the object gets a release message. When the RetainCount reaches 0, the object will call [self dealloc], thereby releasing the object's memory.

22. Copy vs assign vs retain
·         Assign is for primitive values like BOOL, NSInteger or double. For objects use retain or copy, depending on if you want to keep a reference to the original object or make a copy of it.
·         assign: In your setter method for the property, there is a simple assignment of your instance variable to the new value, eg:
(void)setString:(NSString*)newString{ 
        string = newString;
 }
This can cause problems since Objective-C objects use reference counting, and therefore by not retaining the object, there is a chance that the string could be deallocated whilst you are still using it.
·         retain: this retains the new value in your setter method. For example:
This is safer, since you explicitly state that you want to maintain a reference of the object, and you must release it before it will be deallocated.
(void)setString:(NSString*)newString{ 
        [newString retain]; 
          [string release]; 
string = newString; 
}
·         copy: this makes a copy of the string in your setter method:
This is often used with strings, since making a copy of the original object ensures that it is not changed whilst you are using it.
(void)setString:(NSString*)newString{ 
         if(string!=newString){ 
                        [string release]; 
                        string = [newString copy]; 
         }
 }

23. alloc vs new
“alloc” creates a new memory location but doesn’t initializes it as compared to “new”.

24. release vs pool drain
“release” frees a memory. “drain” releases the NSAutoreleasePool itself.

25. NSAutoReleasePool : release vs drain

Strictly speaking, from the big picture perspective drain is not equivalent to release:

In a reference-counted environment, drain does perform the same operations as release, so the two are in that sense equivalent. To emphasise, this means you do not leak a pool if you use drain rather than release.

In a garbage-collected environment, release is a no-op. Thus it has no effect. drain, on the other hand, contains a hint to the collector that it should "collect if needed". Thus in a garbage-collected environment, using drain helps the system balance collection sweeps.

26. autorelease vs release

Autorelase: By sending an object an autorelease message, it is added to the local AutoReleasePool, and you no longer have to worry about it, because when the AutoReleasePool is destroyed (as happens in the course of event processing by the system) the object will receive a release message, its RetainCount will be decremented, and the GarbageCollection system will destroy the object if the RetainCount is zero.

Release: retain count is decremented at this point.

27. Autorelease Pool

Autorelease pools provide a mechanism whereby you can send an object a “deferred” release message. This is useful in situations where you want to relinquish ownership of an object, but want to avoid the possibility of it being deallocated immediately (such as when you return an object from a method). Typically, you don’t need to create your own autorelease pools, but there are some situations in which either you must or it is beneficial to do so.

28. How autorelease pool is managed.

Every time -autorelease is sent to an object, it is added to the inner-most autorelease pool. When the pool is drained, it simply sends -release to all the objects in the pool.

Autorelease pools are simply a convenience that allows you to defer sending -release until "later". That "later" can happen in several places, but the most common in Cocoa GUI apps is at the end of the current run loop cycle.

29. Memory Leak

If RetainingAndReleasing are not properly used then RetainCount for AnObject doesn’t reach 0. It doesn’t crash the application.

30. Event Loop

In a Cocoa application, user activities result in events. These might be mouse clicks or drags, typing on the keyboard, choosing a menu item, and so on. Other events can be generated automatically, for example a timer firing periodically, or something coming in over the network. For each event, Cocoa expects there to be an object or group of objects ready to handle that event appropriately. The event loop is where such events are detected and routed off to the appropriate place. Whenever Cocoa is not doing anything else, it is sitting in the event loop waiting for an event to arrive. (In fact, Cocoa doesn't poll for events as suggested, but instead its main thread goes to sleep. When an event arrives, the OS wakes up the thread and event processing resumes. This is much more efficient than polling and allows other applications to run more smoothly).

Each event is handled as an individual thing, then the event loop gets the next event, and so on. If an event causes an update to be required, this is checked at the end of the event and if needed, and window refreshes are carried out.

31. @property @synthesize @dyanamic

· Properties are a feature in Objective-C that allow us to automatically generate accessors

· The @synthesize directive automatically generates the setters and getters for us, so all we have to implement for this class is the dealloc method.

· @synthesize will generate getter and setter methods for your property. @dynamic just tells the compiler that the getter and setter methods are implemented not by the class itself but somewhere else (like the superclass)

· Uses for @dynamic are e.g. with subclasses of NSManagedObject (CoreData) or when you want to create an outlet for a property defined by a superclass that was not defined as an outlet:

32. @property vs @synthesize

@property - declares a property.

@synthesize - creates getter and setter methods for a property

Example:

@property float value;

is equivalent to:

-(float)value;

- (void)setValue:(float)newValue;

@synthesize defines the properties.

33. Relation between iVar and @property.

iVar are just instance variables. It cant be accessed unless we create accessors, which are generated by @property. iVar and its counterpart @property can be of different names.

@interface Box : NSObject{

NSString *boxName;

}

@property (strong) NSString *boxDescription;//this will become another ivar

-(void)aMethod;

@end

@implementation Box

@synthesize boxDescription=boxName;//now boxDescription is accessor for name

-(void)aMethod {

NSLog(@"name=%@", boxName);

NSLog(@"boxDescription=%@",self.boxDescription);

NSLog(@"boxDescription=%@",boxDescription); //throw an error

}

@end

34. Differnce between boxName and self.boxName.

boxName: Accessing directly.

self. boxName: Accessing boxName through accessors. If property/synthesize is not there it will throw error.

35. What it does “@synthesize boxDescription=boxName;” ?

Here you can use boxName or self.boxName. We cant use boxDescription.

36. atomic vs nonatomic

@property(atomic, retain)…….

@property(retain)…….

@property(nonatomic, retain)…….

atomic is the default behavior, so first and second are same.

Assuming that you are @synthesizing the method implementations, atomic vs. non-atomic changes the generated code. If you are writing your own setter/getters, atomic/nonatomic/retain/assign/copy are merely advisory.

With atomic, the synthesized setter/getter will ensure that a whole value is always returned from the getter or set by the setter, regardless of setter activity on any other thread. That is, if thread A is in the middle of the getter while thread B calls the setter, an actual viable value -- an autoreleased object, most likely -- will be returned to the caller in A.

In nonatomic, no such guarantees are made. Thus, nonatomic is considerably faster than atomic.

What atomic does not do is make any guarantees about thread safety. If thread A is calling the getter simultaneously with thread B and C calling the setter with different values, thread A may get any one of the three values returned -- the one prior to any setters being called or either of the values passed into the setters in B and C. Likewise, the object may end up with the value from B or C, no way to tell.

Ensuring data integrity -- one of the primary challenges of multi-threaded programming -- is achieved by other means.

37. Collection

In Cocoa and Cocoa Touch, a collection is a Foundation framework class used for storing and managing groups of objects. Its primary role is to store objects in the form of either an array, a dictionary, or a set.

38. Threads and how to use

Use this class when you want to have an Objective-C method run in its own thread of execution. Threads are especially useful when you need to perform a lengthy task, but don’t want it to block the execution of the rest of the application. In particular, you can use threads to avoid blocking the main thread of the application, which handles user interface and event-related actions. Threads can also be used to divide a large job into several smaller jobs, which can lead to performance increases on multi-core computers.

Two ways to create threads…

· detachNewThreadSelector:toTarget:withObject:

· Create instances of NSThread and start them at a later time using the “start” method.

NSThread is not as capable as Java’s Thread class, it lacks

· Built-in communication system.

· An equivalent of “join()”

39.Threadsafe

When it comes to threaded applications, nothing causes more fear or confusion than the issue of handling signals. Signals are a low-level BSD mechanism that can be used to deliver information to a process or manipulate it in some way. Some programs use signals to detect certain events, such as the death of a child process. The system uses signals to terminate runaway processes and communicate other types of information.

The problem with signals is not what they do, but their behavior when your application has multiple threads. In a single-threaded application, all signal handlers run on the main thread. In a multithreaded application, signals that are not tied to a specific hardware error (such as an illegal instruction) are delivered to whichever thread happens to be running at the time. If multiple threads are running simultaneously, the signal is delivered to whichever one the system happens to pick. In other words, signals can be delivered to any thread of your application.

The first rule for implementing signal handlers in applications is to avoid assumptions about which thread is handling the signal. If a specific thread wants to handle a given signal, you need to work out some way of notifying that thread when the signal arrives. You cannot just assume that installation of a signal handler from that thread will result in the signal being delivered to the same thread.

40. Which one is thread-safe-atomic or non-atomic?

Immutable objects are generally threadsafe. E.g, NSString

None are threadsafe.

atomic guarantees atomic access to the variable but it DOESN'T make your code thread safe. Neither does non-atomic.

With "atomic", the synthesized setter/getter methods will ensure that a whole value is always returned from the getter or set by the setter, regardless of setter activity on any other thread. So if thread A is in the middle of the getter while thread B calls the setter, an actual viable value will be returned to the caller in A. For nonatomic, you have no such guarantees.

41. @synchronized

Objective-C supports multithreading in applications. Therefore, two threads can try to modify the same object at the same time, a situation that can cause serious problems in a program. To protect sections of code from being executed by more than one thread at a time, Objective-C provides the @synchronized() directive.

The @synchronized()directive locks a section of code for use by a single thread. Other threads are blocked until the thread exits the protected code—that is, when execution continues past the last statement in the @synchronized() block.

The @synchronized() directive takes as its only argument any Objective-C object, including self. This object is known as a mutual exclusion semaphore or mutex. It allows a thread to lock a section of code to prevent its use by other threads. You should use separate semaphores to protect different critical sections of a program. It’s safest to create all the mutual exclusion objects before the application becomes multithreaded, to avoid race conditions.

(void)criticalMethod{

@synchronized(self) {

// Critical code.

}

42. MVC

It is useful to divide the complex task of computer application design into domains in order to simplify the process. Object oriented approaches are modular in philosophy, so the Model View Controller design pattern is a popular way to make logical divisions among class responsibilities.

Each object oriented programming environment/language has a slightly different definition/convention of MVC.

The main advantage of adopting a design pattern like MVC is that it allows the code in each unit to be decoupled from the others, making it more robust and immune to changes in other code.

Within the scope of Cocoa, MVC is an extremely important pattern. The major enhancements that Apple have made to Cocoa, namely Bindings and Core Data, are manifestly based on the MVC pattern.

Model: A Model object:

· is usually a simple subclass of NSObject (or an instance of NSManagedObject for CoreData)

· has a set of instance variables in which to store its data

· has a series of accessor methods for those ivars

· has one or more init: methods to return new instances to other classes

· has a dealloc method

· may have custom methods to manipulate the model objects internal data

· is frequently reusable

View: A View object:

· is some subclass of NSView

· contains a drawRect: method which is the basis of all drawing

· is rarely subclassed or modified

· makes extensive use of delegates for customisation

· is generally reusable

Controller: A Controller object:

· mediates between model and view

· is usually a subclass of NSObject

· contains the outlets and actions for IB

· contains ivars and collections to own and hold model objects

· has methods for manipulating and composing model objects

· contains the main awakeFromNib method

· is instantiated in the nib file/s

· contains the business logic of the program

· is rarely reusable

43. Application lifecycle

Chronology of an application: When the process is started, it runs the NSApplicationMain function, which creates an instance of NSApplication. The application object reads the main nib file and unarchives the objects inside. The objects are all sent the message awakeFromNib. Then the application object checks for events.

This lifecylce of a typical cocoa application is depicted in the below diagram.

44. NSBundle

An NSBundle object represents a location in the file system that groups code and resources that can be used in a program. NSBundle objects locate program resources, dynamically load and unload executable code, and assist in localization. You build a bundle in Xcode using one of these project types: Application, Framework, plug-ins.

45. Delegate

The delegation is a commonly used pattern in object-oriented programming. It is a situation where an object, instead of performing a tasks itself, delegates that task to another, helper object. The helper object is called the delegate.

A delegate allows one object to send messages to another object when an event happens.

A delegate is just an object that another object sends messages to when certain things happen, so that the delegate can handle app-specific details the original object wasn't designed for. It's a way of customizing behavior without subclassing.

They are never retained.

46. Notification and Observers

A notification is a message sent to one or more observing objects to inform them of an event in a program. The notification mechanism of Cocoa follows a broadcast model. It is a way for an object that initiates or handles a program event to communicate with any number of objects that want to know about that event. These recipients of the notification, known as observers, can adjust their own appearance, behavior, and state in response to the event. The object sending (or posting) the notification doesn’t have to know what those observers are. Notification is thus a powerful mechanism for attaining coordination and cohesion in a program. It reduces the need for strong dependencies between objects in a program (such dependencies would reduce the reusability of those objects). Many classes of the Foundation, AppKit, and other Objective-C frameworks define notifications that your program can register to observe.

The centerpiece of the notification mechanism is a per-process singleton object known as the notification center (NSNotificationCenter). When an object posts a notification, it goes to the notification center, which acts as a kind of clearing house and broadcast center for notifications. Objects that need to know about an event elsewhere in the application register with the notification center to let it know they want to be notified when that event happens. Although the notification center delivers a notification to its observers synchronously, you can post notifications asynchronously using a notification queue (NSNotificationQueue).

47. Delegate vs Notification

· The concept of notification differs from delegation in that it allows a message to be sent to more than one object. It is more like a broadcast rather than a straight communication between two objects. It removes dependencies between the sending and receiving object(s) by using a notification center to manage the sending and receiving of notifications. The sender does not need to know if there are any receivers registered with the notification center. There can be one, many or even no receivers of the notification registered with the notification center. Simply, Delegate is 1-to-1 object and Notification can be *-to-* objects.

· The other difference between notifications and delegates is that there is no possibility for the receiver of a notification to return a value to the sender.

· Typical uses of notifications might be to allow different objects with an application to be informed of an event such as a file download completing or a user changing an application preference. The receiver of the notification might then perform additional actions such as processing the downloaded file or updating the display.

48. Plist

Property lists organize data into named values and lists of values using several object types. These types give you the means to produce data that is meaningfully structured, transportable, storable, and accessible, but still as efficient as possible. Property lists are frequently used by applications running on both Mac OS X and iOS. The property-list programming interfaces for Cocoa and Core Foundation allow you to convert hierarchically structured combinations of these basic types of objects to and from standard XML. You can save the XML data to disk and later use it to reconstruct the original objects.

The user defaults system, which you programmatically access through the NSUserDefaults class, uses property lists to store objects representing user preferences. This limitation would seem to exclude many kinds of objects, such as NSColor and NSFont objects, from the user default system. But if objects conform to the NSCoding protocol they can be archived to NSData objects, which are property list–compatible objects

49. Responder Chain and First Responder

A ResponderChain is a hierarchy of objects that have the opportunity to respond to events received.

The first object in the ResponderChain is called the FirstResponder.

50. Helper Objects

Helper Objects are used throughout Cocoa and CocoaTouch, and usually take the form of a delegate or dataSource. They are commonly used to add functionality to an existing class without having to subclass it.

51. TableView’s delegate, datasource

“delegate” methods control tableview behavior.

“datasource methods focus on providing and effecting data.

Delegate of NSTableView

· (void)tableViewSelectionDidChange:(NSNotification *)aNotification

· NSTableViewSelectionDidChangeNotification

To be a data source for an NSTableView, you just have to implement three methods:

· (int)numberOfRowsInTableView:(NSTableView *)aTableView - Returns the number of rows to display

· (id)tableView:(NSTableView*)aTableView

objectValueForTableColumn:(NSTableColumn *)aTableColumn

row:(int)rowIndex - Returns data for a given row in a given column. This data is fed into the NSCell set up for that column.

· (void)tableView:(NSTableView*)aTableView

setObjectValue:(id)anObject

forTableColumn:(NSTableColumn *)aTableColumn

row:(int)rowIndex - Called when the user changes the value of a given data cell. Don't implement this if you want a read only NSTableView.

52. KVC

Key-value coding is a mechanism for accessing an object’s properties indirectly, using strings to identify properties, rather than through invocation of an accessor method or accessing them directly through instance variables. E.g. NSDictionary and NSMutableDictionary

"Keys" are just strings, and "values" can be any type of object.

53. Key value path

Cocoa makes a distinction between "keys" and "key paths". A "key" allows you to get a value on an object. A "key path" allows you to chain multiple keys together, separated by dots.

For example :

[p valueForKeyPath:@"spouse.name"];

… is exactly the same as this…

[[p valueForKey:@"spouse"] valueForKey:@"name"];

54. KVO

Key-value observing is a mechanism that allows objects to be notified of changes to specified properties of other objects. Key-value observing is a mechanism that allows objects to be notified of changes to specified properties of other objects.

55. KVB or Binding

In simple terms KVB=KVC + KVO

A binding is an attribute of one object that may be bound to a property in another such that a change in either one is reflected in the other. For example, the “value” binding of a text field might be bound to the temperature attribute of a particular model object. More typically, one binding might specify that a controller object “presents” a model object and another binding might specify that the value of a text field be tied to the temperature property of the object presented by the controller.

Cocoa bindings reduces the code dependencies between models, views and controllers, supports multiple ways of viewing your data, and automatically synchronizes views when models change. Cocoa bindings provides extensible controllers, protocols for models and views to adopt, and additions to classes in Foundation and the Application Kit. You can eliminate most of your glue code by using bindings available in Interface Builder to connect controllers with models and views.

56. #import and @class filename

#import brings the entire header file in question into the current file; any files that THAT file#imports are also included. @class, on the other hand (when used on a line by itself with some class names), just tells the compiler "Hey, you're going to see a new token soon; it's a class, so treat it that way).

57. Singleton class

Only one instance of that class is created in the application.

@interface SomeManager : NSObject

+ (MyObject *)singleton;

@end

@implementation SomeManager

+ (MyObject *)singleton {

static id singleton = nil;

@synchronized([MyObject class]){

if (singleton == nil) {

singleton = [[self alloc] init];

}

return singleton;

}

@end

58. File’s owner

The File's Owner of your primary nib file is, by default, the NSApplication class and this comes ready-made for you when you create your Cocoa application. If your application has just the one nib file, you really don't need to worry about File's Owner. But if that's true, your application is probably really trivial or not well written.

The File's Owner of the nib is the object that makes communication possible between this new nib and other parts of the application.

59. Whats the difference between frame and bounds?

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).

60. What’s the NSCoder class used for?  

NSCoder is an abstractClass which represents a stream of data. They are 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 decodeObject methods in them).

61. Implement the following methods: retain, release, autorelease. 

-(id) retain{

NSIncrementExtraRefCount(self);

return self;

}

-(id) release{

if(NSDecrementExtraRefCountWasZero(self)){

NSDeallocObject(self);

}

-(id) autorelease{

//add the object to the autorelease pool

[NSAutoreleasePool addObject:self];

return self;

}

62. Implement your own synthesized methods for the property NSString *title.

-(NSString*) title {

return title;

}

-(void) setTitle: (NSString *) newTitle{

if(newTitle != title){

[title release];

title=[newTitle retain]; // or copy as per your need

}

63. Cluster Class

Class clusters are a design pattern that the Foundation framework makes extensive use of. Class clusters group a number of private concrete subclasses under a public abstract superclass. The grouping of classes in this way simplifies the publicly visible architecture of an object-oriented framework without reducing its functional richness.

64. Shallow copying vs deep copy.

Copies of objects can be shallow or deep. Both shallow- and deep-copy approaches directly duplicate scalar properties but differ on how they handle pointer references, particularly references to objects (for example, NSString *str). A deep copy duplicates the objects referenced while a shallow copy duplicates only the references to those objects. So if object A is shallow-copied to object B, object B refers to the same instance variable (or property) that object A refers to. Deep-copying objects is preferred to shallow-copying, especially with value objects.

Shallow is “by Refernce”, Deep is “by Value”

65. Differentiate Foundation vs Core Foundation

CoreFoundation is a general-purpose C framework whereas Foundation is a general-purpose Objective-C framework. Both provide collection classes, run loops, etc, and many of the Foundation classes are wrappers around the CF equivalents. CF is mostly open-source , and Foundation is closed-source.

Core Foundation is the C-level API, which provides CFString, CFDictionary and the like.Foundation is Objective-C, which provides NSString, NSDictionary, etc. CoreFoundation is written in C while Foundation is written in Objective-C. Foundation has a lot more classes CoreFoundation is the common base of Foundation and Carbon.

66. Difference between coreData and Database

Database	Core Data
Primary function is storing and fetching data	Primary function is graph management (although reading and writing to disk is an important supporting feature)
Operates on data stored on disk (or minimally and incrementally loaded)	Operates on objects stored in memory (although they can be lazily loaded from disk)
Stores "dumb" data	Works with fully-fledged objects that self-manage a lot of their behavior and can be subclassed and customized for further behaviors
Can be transactional, thread-safe, multi-user	Non-transactional, single threaded, single user (unless you create an entire abstraction around Core Data which provides these things)
Can drop tables and edit data without loading into memory	Only operates in memory
Perpetually saved to disk (and often crash resilient)	Requires a save process
Can be slow to create millions of new rows	Can create millions of new objects in-memory very quickly (although saving these objects will be slow)
Offers data constraints like "unique" keys	Leaves data constraints to the business logic side of the program

67. Core data vs sqlite.

Core data is an object graph management framework. It manages a potentially very large graph of object instances, allowing an app to work with a graph that would not entirely fit into memory by faulting objects in and out of memory as necessary. Core Data also manages constraints on properties and relationships and maintains reference integrity (e.g. keeping forward and backwards links consistent when objects are added/removed to/from a relationship). Core Data is thus an ideal framework for building the "model" component of an MVC architecture.

To implement its graph management, Core Data happens to use sqlite as a disk store. Itcould have been implemented using a different relational database or even a non-relational database such as CouchDB. As others have pointed out, Core Data can also use XML or a binary format or a user-written atomic format as a backend (though these options require that the entire object graph fit into memory).

68. Retain cycle or Retain loop.

When object A retains object B, and object B retains A. Then Retain cycle happens. To overcome this use “close” method.

Objective-C's garbage collector (when enabled) can also delete retain-loop groups but this is not relevant on the iPhone, where Objective-C garbage collection is not supported.

69. What is unnamed category.

A named category -- @interface Foo(FooCategory) -- is generally used to:

i. Extend an existing class by adding functionality.

ii. Declare a set of methods that might or might not be implemented by a delegate.

Unnamed Categories has fallen out of favor now that @protocol has been extended to support @optional methods.

A class extension -- @interface Foo() -- is designed to allow you to declare additional private API -- SPI or System Programming Interface -- that is used to implement the class innards. This typically appears at the top of the .m file. Any methods / properties declared in the class extension must be implemented in the @implementation, just like the methods/properties found in the public @interface.

Class extensions can also be used to redeclare a publicly readonly @property as readwrite prior to @synthesize'ing the accessors.

Example:

Foo.h

@interface Foo:NSObject

@property(readonly, copy) NSString *bar;

-(void) publicSaucing;

@end

Foo.m

@interface Foo()

@property(readwrite, copy) NSString *bar;

- (void) superSecretInternalSaucing;

@end

@implementation Foo

@synthesize bar;

.... must implement the two methods or compiler will warn ....

@end

70. Copy vs mutableCopy.

copy always creates an immutable copy.

mutableCopy always creates a mutable copy.

71. Strong vs Weak

The strong and weak are new ARC types replacing retain and assign respectively.

Delegates and outlets should be weak.

A strong reference is a reference to an object that stops it from being deallocated. In other words it creates a owner relationship.

A weak reference is a reference to an object that does not stop it from being deallocated. In other words, it does not create an owner relationship.

72. __strong, __weak, __unsafe_unretained, __autoreleasing.

Generally speaking, these extra qualifiers don’t need to be used very often. You might first encounter these qualifiers and others when using the migration tool. For new projects however, you generally you won’t need them and will mostly use strong/weak with your declared properties.

__strong – is the default so you don’t need to type it. This means any object created using alloc/init is retained for the lifetime of its current scope. The “current scope” usually means the braces in which the variable is declared

__weak – means the object can be destroyed at anytime. This is only useful if the object is somehow strongly referenced somewhere else. When destroyed, a variable with __weak is set to nil.

__unsafe_unretained – is just like __weak but the pointer is not set to nil when the object is deallocated. Instead the pointer is left dangling.

__autoreleasing, not to be confused with calling autorelease on an object before returning it from a method, this is used for passing objects by reference, for example when passing NSError objects by reference such as [myObject performOperationWithError:&tmp];

73. Types of NSTableView

Cell based and View based. In view based we can put multiple objects.

74. When to use Bindings.

75. Software Design Pattern.

Creational Patterns

Factory

Abstract Factory

Singleton

Builder

Prototype

Structural Patterns

Adapter

Bridge

Composite

Decorator

Façade

Flyweight

Proxy

Behaviour Patterns

Chain of responsibilty

Command

Interpreter

Iterator

Momentro

State

Observer

Strategey

Template Visitor

76. Mac OS Releases.

Version 10.0: "Cheetah"

Version 10.1: "Puma"

Version 10.2: "Jaguar"

Version 10.3: "Panther"

Version 10.4: "Tiger"

Version 10.5: "Leopard"

Version 10.6: "Snow Leopard"

Version 10.7: "Lion"

Version 10.8: "Mountain Lion"

77. Structure of MacOS.

78. Web Services

What are Web Services?

· Web services are application components

· Web services communicate using open protocols

· Web services are self-contained and self-describing

· Web services can be discovered using UDDI

· Web services can be used by other applications

· XML is the basis for Web services

How Does it Work?

The basic Web services platform is XML + HTTP.

XML provides a language which can be used between different platforms and programming languages and still express complex messages and functions.

The HTTP protocol is the most used Internet protocol.

Web services platform elements:

· SOAP (Simple Object Access Protocol)

· UDDI (Universal Description, Discovery and Integration)

· WSDL (Web Services Description Language)

In cocoa, NSURLConnection and NSURLRequest are used for this.

79. Abstract class in cocoa.

Cocoa doesn’t provide anything called abstract. We can create a class abstract which gets check only at runtime, compile time this is not checked.

@interface AbstractClass : NSObject

@end

@implementation AbstractClass

+ (id)alloc{

if (self == [AbstractClass class]) {

NSLog(@"Abstract Class cant be used");

}

return [super alloc];

@end

80. xml parsers.

NSXML is SAX parser.

SAX parser is one where your code is notified as the parser walks through the XML tree, and you are responsible for keeping track of state and constructing any objects you might want to keep track of the data as the parser marches through.

A DOM parser reads the entire document and builds up an in-memory representation that you can query for different elements. Often, you can even construct XPath queries to pull out particular pieces.

81. What is syncronous and asynchronous call?
A synchronous process is invoked by a request/response operation, and the result of the process is returned to the caller immediately via this operation.

An asynchronous process is invoked by a one-way operation and the result and any faults are returned by invoking other one-way operations. The process result is returned to the caller via a callback operation.

For example, you can think of a synchronous process as a telephone, and an asynchronous process as the postal system. When you are having a conversation on the phone, you send and receive messages instantaneously using the same connection. If you were to send the same message in a letter via the postal service, it would be delivered in one manner, and its response returned in another.

~~82. what matrices u follow while developing applications~~

~~83. How u decide background or foreground application?~~

~~84. How u do unit testing for your code and gui.~~

~~85. How server knows where to send the notifications in xmpp iris.~~

~~86. Sandboxing~~

~~87. How a textfield knows that if became the first responder.~~

~~88.~~ ~~Cocoa class naming conventions.~~

89. Difference between HTTP and HTTPS.

· HTTP stands for HyperText Transfer Protocol, whereas, HTTPS is HyperText Transfer Protocol Secure.

· HTTP transmits everything as plan text, while HTTPS provides encrypted communication, so that only the recipient can decrypt and read the information. Basically, HTTPS is a combination of HTTP and SSL (Secure Sockets Layer). This SSL is that protocol which encrypts the data.

· HTTP is fast and cheap, where HTTPS is slow and expensive.

As, HTTPS is safe it’s widely used during payment transactions or any sensitive transactions over the internet. On the other hand, HTTP is used most of the sites over the net, even this blogspot sites also use HTTP.

· HTTP URLs starts with “http:// “ and use port 80 by default, while HTTPS URLs stars with “https:// “ and use port 443.

· HTTP is unsafe from attacks like man-in-the-middle and eavesdropping, but HTTPS is secure from these sorts of attacks.

90.GCD

Grand Central Dispatch is not just a new abstraction around what we've already been using, it's an entire new underlying mechanism that makes multithreading easier and makes it easy to be as concurrent as your code can be without worrying about the variables like how much work your CPU cores are doing, how many CPU cores you have and how much threads you should spawn in response. You just use the Grand Central Dispatch API's and it handles the work of doing the appropriate amount of work. This is also not just in Cocoa, anything running on Mac OS X 10.6 Snow Leopard can take advantage of Grand Central Dispatch ( libdispatch ) because it's included in libSystem.dylib and all you need to do is include #import <dispatch/dispatch.h> in your app and you'll be able to take advantage of Grand Central Dispatch.

91. How you attain the backward compatibility?

Set the Base SDK to Current version of Mac (ex. 10.7)
Set the Deployment SDK to older version (ex.1.4)

92. Call Back.

Synchronous operations are ones that happen in step with your calling code. Most of Cocoa works this way: you send a message to an object, say to format a string, etc, and by the time that line of code is "done", the operation is complete.

But in the real world, some operations take longer than "instantaneous" (some intensive graphics work, but mainly high or variably latency things like disk I/O or worse, network connectivity). These operations are unpredictable, and if the code were to block until finish, it might block indefinitely or forever, and that's no good.

So the way we handle this is to set up "callbacks"-- you say "go off and do this operation, and when you're done, call this other function". Then inside that "callback" function, you start the second operation that depends on the first. In this way, you're not spinning in circles waiting, you just get called "asynchronously" when each task is done.

93. When to use Blocks?
Blocks are first-class functions, which is a fancy way of saying that Blocks are regular Objective-C objects. Since they’re objects, they can be passed as parameters, returned from methods and functions, and assigned to variables. Blocks are called closures in other languages such as Python, Ruby and Lisp, because they encapsulate state when they are declared. A block creates a const copy of any local variable that is referenced inside of its scope. Before blocks, whenever you wanted to call some code and have it call you back later, you would typically use delegates or NSNotificationCenter. That worked fine, except it spreads your code all over – you start a task in one spot, and handle the result in another.

94. Does Objective-C contain private methods?
NO.

There is nothing called a private method in Obj-C. If a method is defined in .m only then it becomes protected. If in .h it is public.

If you really want a private method then you need to add a local category on the class and add the method in the category and define the method in the class.m

95. What is new with XCode4.4+
The compiler LLVM/clang 3.2
literals for arrays, dictionary.
auto-synthesize for @property. @synthisize prop=_prop;

96. NSThread vs GCD

Migrating Away from Threads

The idea is that you eliminate work on your part, since the paradigm fits MOST code more easily.

It reduces the memory penalty your application pays for storing thread stacks in the application’s memory space.

It eliminates the code needed to create and configure your threads.

It eliminates the code needed to manage and schedule work on threads.

It simplifies the code you have to write.

Empirically, using GCD-type locking instead of @synchronized is about 80% faster or more, though micro-benchmarks may be deceiving. Read more here, though I think the advice to go async with writes does not apply in many cases, and it's slower (but it's asynchronous).

Advantages of Threads

Why would you continue to use Threads? From the same document:

It is important to remember that queues are not a panacea for replacing threads. The asynchronous programming model offered by queues is appropriate in situations where latency is not an issue. Even though queues offer ways to configure the execution priority of tasks in the queue, higher execution priorities do not guarantee the execution of tasks at specific times. Therefore, threads are still a more appropriate choice in cases where you need minimal latency, such as in audio and video playback.

Another place where I haven't personally found an ideal solution using queues is daemon processes that need to be constantly rescheduled. Not that you cannot reschedule them, but looping within a NSThread method is simpler (I think). Edit: Now I'm convinced that even in this context, GCD-style locking would be faster, and you could also do a loop within a GCD-dispatched operation

iOS interview questions with answers

The following list of questions and answers may help you to clear iOS/iPhone interviews.

iOS Questions  for Beginners

* Q: How would you create your own custom view?

A:

By Subclassing the UIView class.

*Q: Whats fast enumeration?

A:

Fast enumeration is a language feature that allows you to enumerate over the contents of a collection. (Your code will also run faster because the internal implementation reduces

message send overhead and increases pipelining potential.)

*Q: Whats a struct?

A:

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. *

Q: Whats the difference between  NSArray and  NSMutableArray?

A:

NSArrayʼs contents can not be modified once itʼs been created whereas a NSMutableArray can be modified as needed, i.e items can be added/removed from it.

* Q: Explain retain counts.

A:

Retain counts are the way in which memory is managed in Objective-C. When you create an object, it has a retain count of 1. When you send an object a retain message, its retain count is incremented by 1. When you send an object a release message, its retain count is decremented by 1. When you send an object a autorelease message, its retain count is decremented by 1 at some stage in the future. If an objectʼs retain count is reduced to 0, it is deallocated.

Q: Whats the difference between frame and bounds?

A:

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).

* Q: Is a delegate retained?

A:

No, the delegate is never retained! Ever!

 * Q: Outline the class hierarchy for a UIButton until NSObject. 

A:

UIButton inherits from UIControl, UIControl inherits from UIView, UIView inherits from UIResponder, UIResponder inherits from the root class NSObject

 *Q: What is dynamic?
A:
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

iOS Questions  for Intermediate level

*

Q: If I call performSelector:withObject:afterDelay: – is the object retained?

A:

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.

* Q: Can you explain what happens when you call autorelease on an object?

A:

When you send an object a 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 release it at the end. This establishes a pool for the lifetime of the task. However, this also means that any autoreleased 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.)

* Q: Whats the NSCoder class used for?

A:

NSCoder is an abstractClass which represents a stream of data. They are 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 decodeObject methods in them).

* Q: Whats an NSOperationQueue and how/would you use it?

A:

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.

* Q: Explain the correct way to manage Outlets memory

A:

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.

iOS Questions for  Expert level

*Q: Is the delegate for a CAAnimation retained?

A:

Yes it is!! This is one of the rare exceptions to memory management rules.

* Q: What happens when the following code executes?

Ball *ball = [[[[Ball alloc] init] autorelease] autorelease];

A:

It will crash because itʼs added twice to the autorelease pool and when it it dequeued the autorelease pool calls release more than once.

* Q: Explain the difference between NSOperationQueue concurrent and non-concurrent.

A:

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.

* Q: Implement your own synthesized methods for the property NSString *title.

A:

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.

}

}

* Q: Implement the following methods: retain, release, autorelease.

A:

-(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;

}

*Q: Explain the steps involved in submitting the App to App-Store.

A:Ref: https://developer.apple.com/appstore/resources/approval/guidelines.html

*Q: What are all  the newly added frameworks iOS 4.3 to iOS 5.0?

A:
• Accounts
• CoreBluetooth
• CoreImage
• GLKit
• GSS
• NewsstandKit
• Twitter

*Q: What are the App states. Explain them?

A:
Not running State:  The app has not been launched or was running but was terminated by the system.
Inactive state: The app is running in the foreground but is currently not receiving events. (It may be executing other code though.) An app usually stays in this state only briefly as it transitions to a different state. The only time it stays inactive for any period of time is when the user locks the screen or the system prompts the user to respond to some event, such as an incoming phone call or SMS message.
Active state: The app is running in the foreground and is receiving events. This is the normal mode for foreground apps.
Background state:  The app is in the background and executing code. Most apps enter this state briefly on their way to being suspended. However, an app that requests extra execution time may remain in this state for a period of time. In addition, an app being launched directly into the background enters this state instead of the inactive state. For information about how to execute code while in the background, see “Background Execution and Multitasking.”
Suspended state:The app is in the background but is not executing code. The system moves apps to this state automatically and does not notify them before doing so. While suspended, an app remains in memory but does not execute any code. When a low-memory condition occurs, the system may purge suspended apps without notice to make more space for the foreground app.

*Q:  Explain the options and bars available in xcode 4.2/4.0 workspace window ?

A:

*Q: What is Automatic Reference Counting (ARC) ?

A:

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.

*Q: Multitasking support is available from which version?

A:

iOS 4.0

*Q: How many bytes we can send to apple push notification server.

A:

256bytes.

*Q: Can you just explain about memory management in iOS?

A:

Refer: iOS Memory Management

*Q: What is the difference between retain & assign?

A:

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];  

}

*Q: Why do we need to use @Synthesize?

A:

We can use generated code like nonatomic, atmoic, 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, 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

 *Q: What is categories in iOS?

A:

A Category is a feature of the Objective-C language that enables you to add methods (interface and implementation) to a class without having to make a subclass. There is no runtime difference—within the scope of your program—between the original methods of the class and the methods added by the category. The methods in the category become part of the class type and are inherited by all the class’s subclasses.As with delegation, categories are not a strict adaptation of the Decorator pattern, fulfilling the intent but taking a different path to implementing that intent. The behavior added by categories is a compile-time artifact, and is not something dynamically acquired. Moreover, categories do not encapsulate an instance of the class being extended.Refer: Categories and Extensions

*Q: What is Delegation in iOS?

A:

Delegation is a design pattern in which one object sends messages to another object—specified as its delegate—to ask for input or to notify it that an event is occurring. Delegation is often used as an alternative to class inheritance to extend the functionality of reusable objects. For example, before a window changes size, it asks its delegate whether the new size is ok. The delegate replies to the window, telling it that the suggested size is acceptable or suggesting a better size. (For more details on window resizing, see thewindowWillResize:toSize: message.)Delegate methods are typically grouped into a protocol. A protocol is basically just a list of methods. The delegate protocol specifies all the messages an object might send to its delegate. If a class conforms to (or adopts) a protocol, it guarantees that it implements the required methods of a protocol. (Protocols may also include optional methods).In this application, the application object tells its delegate that the main startup routines have finished by sending it theapplicationDidFinishLaunching: message. The delegate is then able to perform additional tasks if it wants.

*Q: How can we achieve singleton pattern in iOS?

A:

The Singleton design pattern ensures a class only has one instance, and provides a global point of access to it. The class keeps track of its sole instance and ensures that no other instance can be created. Singleton classes are appropriate for situations where it makes sense for a single object to provide access to a global resource.Several Cocoa framework classes are singletons. They include NSFileManager, NSWorkspace, NSApplication, and, in UIKit, UIApplication. A process is limited to one instance of these classes. When a client asks the class for an instance, it gets a shared instance, which is lazily created upon the first request.Refer: Singleton Pattren

*Q: What is delegate pattern in iOS?

A:

Delegation is a mechanism by which a host object embeds a weak reference (weak in the sense that it’s a simple pointer reference, unretained) to another object—its delegate—and periodically sends messages to the delegate when it requires its input for a task. The host object is generally an “off-the-shelf” framework object (such as an NSWindow or NSXMLParserobject) that is seeking to accomplish something, but can only do so in a generic fashion. The delegate, which is almost always an instance of a custom class, acts in coordination with the host object, supplying program-specific behavior at certain points in the task (see Figure 4-3). Thus delegation makes it possible to modify or extend the behavior of another object without the need for subclassing.Refer: delegate pattern

*Q: What are all the difference between categories and subclasses?Why should we go to subclasses?

A:

Category is a feature of the Objective-C language that enables you to add methods (interface and implementation) to a class without having to make a subclass. There is no runtime difference—within the scope of your program—between the original methods of the class and the methods added by the category. The methods in the category become part of the class type and are inherited by all the class’s subclasses.As with delegation, categories are not a strict adaptation of the Decorator pattern, fulfilling the intent but taking a different path to implementing that intent. The behavior added by categories is a compile-time artifact, and is not something dynamically acquired. Moreover, categories do not encapsulate an instance of the class being extended.The Cocoa frameworks define numerous categories, most of them informal protocols . Often they use categories to group related methods. You may implement categories in your code to extend classes without subclassing or to group related methods. However, you should be aware of these caveats:
You cannot add instance variables to the class.
If you override existing methods of the class, your application may behave unpredictably.

*Q: What is notification in iOS?

A:

The notification mechanism of Cocoa implements one-to-many broadcast of messages based on the Observer pattern. Objects in a program add themselves or other objects to a list of observers of one or more notifications, each of which is identified by a global string (the notification name). The object that wants to notify other objects—the observed object—creates a notification object and posts it to a notification center. The notification center determines the observers of a particular notification and sends the notification to them via a message. The methods invoked by the notification message must conform to a certain single-parameter signature. The parameter of the method is the notification object, which contains the notification name, the observed object, and a dictionary containing any supplemental information.Posting a notification is a synchronous procedure. The posting object doesn’t regain control until the notification center has broadcast the notification to all observers. For asynchronous behavior, you can put the notification in a notification queue; control returns immediately to the posting object and the notification center broadcasts the notification when it reaches the top of the queue.Regular notifications—that is, those broadcast by the notification center—are intraprocess only. If you want to broadcast notifications to other processes, you can use the istributed notification center and its related API.

 *Q: What is the difference between delegates and notifications?

A:

We can use notifications for a variety of reasons. For example, you could broadcast a notification to change how user-interface elements display information based on a certain event elsewhere in the program. Or you could use notifications as a way to ensure that objects in a document save their state before the document window is closed. The general purpose of notifications is to inform other objects of program events so they can respond appropriately.But objects receiving notifications can react only after the event has occurred. This is a significant difference from delegation. The delegate is given a chance to reject or modify the operation proposed by the delegating object. Observing objects, on the other hand, cannot directly affect an impending operation.

*Q: What is posing in iOS?

A:

Objective-C permits a class to entirely replace another class within an application. The replacing class is said to “pose as” the target class. All messages sent to the target class are then instead received by the posing class. There are some restrictions on which classes can pose:
A class may only pose as one of its direct or indirect superclasses
The posing class must not define any new instance variables which are absent from the target class (though it may define or override methods).
No messages must have been sent to the target class prior to the posing.

Posing, similarly to categories, allows globally augmenting existing classes. Posing permits two features absent from categories:
A posing class can call overridden methods through super, thus incorporating the implementation of the target class.
A posing class can override methods defined in categories.

*Q:What is atomic and nonatomic? Which one is safer? Which one is default?

A:

You can use this attribute to specify that accessor methods are not atomic. (There is no keyword to denote atomic.)

nonatomic
Specifies that accessors are nonatomic. By default, accessors are atomic.

Properties are atomic by default so that synthesized accessors provide robust access to properties in a multithreaded environment—that is, the value returned from the getter or set via the setter is always fully retrieved or set regardless of what other threads are executing concurrently.

If you specify strong, copy, or retain and do not specify nonatomic, then in a reference-counted environment, a synthesized get accessor for an object property uses a lock and retains and autoreleases the returned value—the implementation will be similar to the following:

[_internal lock]; // lock using an object-level lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;

If you specify nonatomic, a synthesized accessor for an object property simply returns the value directly.

Markup and Deprecation
Properties support the full range of C-style decorators. Properties can be deprecated and support __attribute__ style markup:
@property CGFloat x
AVAILABLE_MAC_OS_X_VERSION_10_1_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4;
@property CGFloat y __attribute__((...));

What is Objective C?
The Objective-C language is a simple computer language designed to enable sophisticated object-oriented programming. Objective-C is defined as a small but powerful set of extensions to the standard ANSI C language. Its additions to C are mostly based on Smalltalk, one of the first object-oriented programming languages. Objective-C is designed to give C full object-oriented programming capabilities, and to do so in a simple and straightforward way.

What are features of Objective C?
Objective-C's features often allow for flexible, and often easy, solutions to programming issues.
Delegating methods to other objects and remote invocation can be easily implemented using categories and message forwarding.
Swizzling of the isa pointer allows for classes to change at runtime. Typically used for debugging where freed objects are swizzled into zombie objects whose only purpose is to report an error when someone calls them. Swizzling was also used in Enterprise Objects Framework to create database faults. Swizzling is used today by Apple’s Foundation Framework to implement Key-Value Observing.
Serialization, commonly called Archiving in Objective-C, can be done by overriding read and write methods.

Classes are objects
Each class is an instance of a meta-class automatically created and managed by the run-time. We can define class methods, pass classes as arguments, put them in collections and so on. To create an object, we just send a message to the class we want to instantiate. No need to reinvent a "factory" system. No need for a specific constructor mechanism at the language level. This helps keeping the language simple and powerful.
And, by the way, meta-classes are objects too!

Dynamic typing
As in Ruby, Python, Smalltalk, Groovy… Extremely useful because we don’t always know beforehand what our objects are going to be at run-time. Dynamic typing in Objective-C is simple to use. For example, this declares a variable that can hold a reference to an object:
    id myObject;

Optional static typing
Still, Objective-C also has support for static typing. Best of both worlds.
This declares a variable that can hold a reference to an object of class (or subclass of) NSView:
    NSView *myObject;

Categories
Categories let us define new methods and add them to classes for which we don’t have the source code (such as the standard Cocoa classes provided by Apple). This makes it easy to extend classes without resorting to subclassing. Extremely useful to adapt existing classes to the requirements of frameworks we want to use or create.

Message sending
We interact with objects by sending them messages. Often, the receiver of a message will have a method that directly matches the message (i.e. that has the same name, or, in Objective-C terms, the same selector). In this case the method will be invoked. But this is not the only possible outcome, as an object can choose to handle a message in other ways such as forwarding it to another object, broadcasting it to a number of objects, introspecting it and applying custom logic, etc.
Very powerful…

Expressive message syntax
Message patterns in Objective-C are like natural language sentences with holes in them (prefixed with colons). When we write code that sends a message to an object, we fill the holes with actual values, creating a meaningful sentence. This way of denoting messages comes from Smalltalk and makes the code very expressive.
Example, sending a message to an ordered collection, asking it to insert a given object at index 10:
    [myCollection insert:myObject atIndex:10]

A message sending expressions can be read like a sentence where the receiver is the subject and the message is the rest of the sentence (for instance, an action that we would like the receiver to perform): "myCollection insert myObject at index 10".

Introspection
Introspecting objects is easy. For example, we can ask an object for its class like this:
   [myObject class]    
Determine if an object has a method "foo":
   [myObject respondsToSelector:@selector(foo)]    
Ask an object for the signature of its method "foo":
   [myObject methodSignatureForSelector:@selector(foo)]    
Ask a class whether it is a subclass of another class:
   [class1 isSubclassOfClass:class2]   
And so on…

Dynamic run-time
Objective-C has a dynamic run-time. It allows crafting messages at run-time, dynamically creating classes, dynamically adding methods to existing classes, changing method implementations and so on…

Automatic garbage collection
The automatic garbage collector runs in its own thread, concurrently with the application code. It uses a generational model to improve its efficiency by targeting in priority memory zones that are more likely to be garbage. It works for objects and also for raw C memory blocks allocated with the NSAllocateCollactable() and similar functions. malloc() works as usual, providing control over memory not managed by the collector.
The garbage collector is an opt-in service: you can choose to not make use of it in your application and instead rely on a reference counting system. This system includes a rather ingenious delayed release mechanism that goes a long way to reduce the burden of manual reference counting.
Note that at the time of this writing, the automatic garbage collector is not available on the iPhone.

C inside
Objective-C is primarily an object-oriented extension to the C language and constitutes a superset of C. This means that the raw power of C is available, and that C libraries can be accessed directly (as you know, there is quite a number of them available out there!). Beside, this creates a symbiotic relationship between the language and the operating system, as Mac OS X, which is a UNIX system, is primarily written in C and, for the upper-level parts, in Objective-C.

C++ fluent
Not only is Objective-C a superset of C but it can also understand and call C++ code. Used in this configuration, the language is named Objective-C++ and allows mixing Objective-C and C++ code in the same code statements. It also allows directly using C++ libraries.

Simplicity
Objective-C’s Smalltalk-inspired object system is leaning toward simplicity. Many features that tend to render languages complex (templates, overloading, multiple inheritance, etc.) are simply absent from Objective-C, which offer simpler programming models taking advantage of its dynamic nature.

Access to Apple technologies
Each new version of Mac OS X, and now, of the iPhone OS, is full of interesting new technologies which are directly available from Objective-C to play with. This contributes significantly to make Objective-C fun to use.

What are the advantages of using Objective-C over C++?
Dynamic typing and the id typeAny variable in an Objective C object may be declared as type id, meaning a pointer to an object of an undetermined type. The type can be determined at run time, and the appropriate messages sent. Using Objective C's SEL type, you can determine at runtime which message is sent to the object, and therefore what method (member function) is accessed. To avoid runtime problems, the programmer can also test at runtime (with the respondsToSelector: method) to see which messages an object recognizes. Class methods (static member functions) are also available; unlike C++ classes, Objective C classes are true objects and exist at runtime.
Categories and dynamic loading
The dynamic nature of Objective C allows existing classes to be extended at runtime. Objective C allows you to define categories, related sets of extensions to objects you've already created. For example, in converting a text-based app into a graphics app, the code your objects needed to draw themselves could be compiled as a category and loaded at run-time only when needed. This saves memory and allows you to leave your original objects unmodified.
Simple and standard
C++ is a complex and evolving language, leading to differences between compilers and implementations; as a result, C++ users need to be more careful about using features like boolean types that may not be supported on all compilers. Objective C 's simplicity makes these problems less likely; it has also helped it maintain a stable standard. (And yes, Objective C does have a BOOL data type.)
Shortcuts
C++ doesn't have a monopoly on convenient features, either. Objective C's additions include C++-style // comments and the #import directive, which acts like the #include directive but ensures that each referenced file is included only once per project.

What are the advantages of using C++ over Objective-C?
Multiple inheritanceObjective C, like Java, does not support multiple inheritance. Instead, it allows the user to define a protocol. Declaring an Objective C class to conform to a protocol is similar to declaring a Java class to implement an interface; it defines a standard set of methods (member functions) that the class must respond to. Another object can check at runtime to see if a particular class conforms to a particular protocol. Thus, Boat would be a subclass of Vehicle and Duck would be a subclass of bird, and both would conform to the FloatingThings protocol. Unlike with multiple inheritance, only method declarations (member function declarations) are included, not definitions or instance variables (data members). Alternatively, the dynamic nature of Objective C allows you to simulate multiple inheritance.
A friendly languageC++ gives finer access control over all of an object's elements than Objective C, with private, public, and protected keywords and the concept of friend functions. Objective C does allow instance variables (data members) to be set as public, private, or protected, but does not have an equivalent construct for methods (member functions).
iostream.hC++ provides a new implementation of the ANSI input/output library for stream-based i/o. Objective C does not have an analogous library, but some implementations of Objective C++ do allow you to call the C++ iostream library from your Objective C++ projects.

Objective-C Questions

identify basic OO concepts and the keywords Objective-C uses (interface, implementation, property, protocol, etc)
what is a designated initializer, what is the pattern for the initializers and why ( if (self = [super ...] ) )
basic memory management topics, like ownership retain/release/autorelease
- what happens if you add your just created object to a mutable array, and you release your object
- what happens if the array is released
- what happens if you remove the object from the array, and you try to use it
trick: garbage collection on iPhone
autorelease pool usage
property declarations ( assign, nonatomic, readonly, retain, copy )
- trick: ask about the nonexistent atomic keyword, what does atomic mean
- ask on how to correctly implement a retaining setter property
- ask about the circular reference problem and delegates being usually saved with assign rather then retain
what is the difference between the dot notation and using the square brackets
- what happens when we invoke a method on a nil pointer
- difference between nil and Nil
what is KVO and related theory + methods to use when observing
- does KVO work with ivars too?
protocols – maybe: main difference between c#/java interface and protocols
- what to do in a situation when a class doesn’t implement a method from a protocol
what about multiple class inheritance
what is fast enumeration
class methods vs instance methods
- visibility of methods
what is an actual class in Objective-c (struct)
- ask about the isa member
- ask about isKindOfClass isMemberOfClass
root classes: NSObject, NSProxy
- how does proxy-ing work
- how to fake multiple class inheritance
id type
- what happens during compilation if we invoke a method on an variable with the type id
- what happens runtime if the method exists
- what happens if the methods doesn’t exist
- pro and cons of using the type id
- what happens here(compile + runtime): NSString *s = [NSNumber numberWithInt:3]; int i = [s intValue];
what are class categories and the () category
what is an informal protocol
what is a delegate, how to create one, and use one
what is a selector, how to do a perform selector
- how to delay executing a selector
- what to do when the selector has more paramters (NSInvocation>
- how to start a selector on a background thread
how to start a thread
- what is the first thing to do on a thread (autorelease pool)
- what is a runloop, and one very common place where it is used (timers, nsurlconnection)
how to download something from the internet
- what is the difference between a synchronous and an asynchronous request
- small task: explain how to download an image from the internet, and show this in an image view – all this after a button is tapped on the view
what are notifications, how to use them
what is a memory warning, how do we respond to it
when to use retainCount (never, and why)
why shouldn’t we invoke instance methods in an initializer and the dealloc
NSCoding, archiving
NSCopying, why can’t we simply use our own objects as key in a dictionary, what to do to solve the problem ( and the difference between a shallow and a deep copy)

UIKit Related Questions

what is a view, and a window
difference between a view’s bounds and frame
what is the resolution of the current available devices, difference between points and pixels (starting with iOS4)
what is the responder chain, becomeFirstResponder
what do IBOutlet and IBAction mean, what are they preprocessed to
how do tableviews function
what about multithreading and UIKit
what to do when the keyboard appears and hides some parts of the UI that are important
why should we release the outlets in viewDidUnload
what is awakeFromNib, what is the difference between a nib and a xib

CoreData Questions

what is a context
what about multi threading and core data usage
what is an NSManagedObjectId – can we save it for later if the application was stopped
what types of stores does core data support
what is lazy loading, how does this relate to core data, situations when this can be handy
how to ready only a few attributes of an entity
what is an fetch result controller
how to synchronize contexts
how could one simulate an NSManagedObject (i’m thinking of the fact that all the properties are dynamic and not synthesized).

What is iPhone?

IPhone is a combination of internet and multimedia enabled smart phone developed by Apple Inc.IPhone functions as a camera phone, including text messaging, and visual voice mail. IPhone is a portable media player that resembles a video iPod It has user interface that is built around the multi-touch screen including virtual keyboard.

What is an iPhone app?

An iPhone app is a program that runs on our iPhone/iPod Touch. It enables us to ccomplish a certain task. They could be utility apps, games, enterprise apps, entertainment apps, apps to access our bank account etc.

Introduction to Iphone application Development?

In 2007, Apple entered the cellular phone business with the introduction of the iPhone, a multi-touch display cell phone, which also includes the features of iPod.

Multitasking support is available from which version?

iOS 4.0

How many bytes we can send to apple push notification server.

256bytes.

What are the features of iPhone 3gs?

Video: Videos can be edited, shared. High quality VGA video can be shot in portrait or landscape.
3 Mega pixel Camera: Still photos with greater quality can be taken
Voice control: It recognizes the names in contacts and recognizes the music on iPod.
Compass: iPhone 3GS has built-in digital compass, used to point the way.
Internet Tethering: Internet surfing can be done from anywhere. A 3G connection can be shared on Iphon3 with Mac notebook or laptop.

Why iPhone apps are popular?

Give our business a whole new way of transacting business for millions of users.

IPhones are the market leaders in the smart phone segment. The iPhone has become a great device to surf the internet, play games, interact with social networks and transact business.

Where can you test Apple iPhone apps if you don’t have the device?

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 the real device before publishing it.

Does iOS support multitasking?

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.

Which JSON framework is supported by iOS?

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.

What is iPhone OS?

iPhone OS runs on iPhone and iPod touch devices.

Hardware devices are managed by iPhone OS and provides the technologies needed for implementing native applications on the phone.

The OS ships with several system applications such as Mail, Safari, Phone, which provide standard services to the user.

Difference between shallow copy and deep copy?

Shallow copy is also known as address copy. In this process you only copy address not actual data while in deep copy you copy data.

Suppose there are two objects A and B. A is pointing to a different array while B is pointing to different array. Now what I will do is following to do shallow copy. Char *A = {‘a’,’b’,’c’}; Char *B = {‘x’,’y’,’z’}; B = A; Now B is pointing is at same location where A pointer is pointing.Both A and B in this case sharing same data. if change is made both will get altered value of data.Advantage is that coping process is very fast and is independent of size of array.

while in deep copy data is also copied. This process is slow but Both A and B have their own copies and changes made to any copy, other will copy will not be affected.

What are the requirements for developing iPhone Apps?

Mac OS 10.5/10.6 iPhone SDK (Software Development Kit 3.0/4.0).

IPhone SDK consists of:

IDE to develop iPhone Apps is XCode(This tool is inbuilt in iPhone SDK)
Interface Builder This is used to design GUI of Apps(Inbuilt feature of iPhone SDK)
Instruments This is used to check any memory leaks in our apps (Inbuilt in SDK)
Simulator This is used to test our apps before deploying into real device.

What are the popular apps of iPhone?

Face book-Social networking
Doodle Buddy-drawing
Pandora Radio-radio on our iPhone
Yelp-restaurant reviews

What is iPhone reference library?

iPhone reference library is a set of reference documents for iPhone OS. It can be downloaded by subscribing to the iPhone OS Library doc set. Select Help>Documentation from X code, and click the subscribe button next to the iPhone OS Library doc set, which appears in the left column.

What is iPhone sdk?

iPhone SDK is available with tools and interfaces needed for developing, installing and running custom native applications. Native applications are built using the iPhone OS’s system frameworks and Objective-C language and run directly on iPhone OS. Native applications are installed physically on a device and can run in presence or absence of network connection.

What is iPhone architecture?

It is similar to Mac OS X architecture

It acts as an intermediary between the iPhone and iPod hardware an the appearing applications on the screen

The user created applications never interact directly with the appropriate drivers, which protects the user applications from changes to the hardware.

What are the location services?

Applications such as Maps, camera and compass are allowed to use the information from cellular, Wi-Fi and Global Positioning System networks for determining the approximate locations.

The location is displayed on the screen, using a blue marker.

Describe the functionality of accelerometer of an iPhone ?

iPhone responds to motion using a built-in accelerometer.

The accelerometer detects the movement and changes the display accordingly, at the time of rotating iPhone from portrait to landscape.

Name the application thread from where UIKit classes should be used?

UIKit classes should be used only from an application’s main thread. Note: The derived classes of UIResponder and the classes which manipulate application’s user interface should be used from application’s main thread.

Which API is used to write test scripts that help in exercising the application's user interface elements?

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.

Explain about the applications that can be used with iPhone ?

Technology, Entertainment and Design (TED): Allows to watch and listen to world’s most fascinating people have to say, all on the iPhone.

What are the tools required to develop iOS applications?

iOS development requires Intel-based Macintosh computer and iOS SDK.

Name the framework that is used to construct application’s user interface for iOS.

The UIKit framework is used to develop application’s user interface for iOS. UIKit framework provides event handling, drawing model, windows, views, and controls specifically designed for a touch screen interface.

What is iPhone reference library?

iPhone reference library is a set of reference documents for iPhone OS.

It can be downloaded by subscribing to the iPhone OS Library doc set.

Select Help>Documentation from X code, and click the subscribe button next to the iPhone OS Library doc set, which appears in the left column.

What are sensors in iPhone?

The proximity sensor immediately turns off the display when the iPhone is lifted to ear. With this sensor the power is saved and accidental dialing is prevented.

The display is automatically brightens the iPhone by the ambient light sensor when the sunlight or bright rooms and dims in darker places.

How can an operating system improve battery life while running an app?

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 foreground app.

Why an app on iOS device behaves differently when running in foreground than in background?

An application behaves differently when running in foreground than in background because of the limitation of resources on iOS devices.

Which framework delivers event to custom object when app is in foreground?

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.

When an app is said to be in not running state?

An app is said to be in 'not running' state when:

it is not launched.
it gets terminated by the system during running.

Assume that your app is running in the foreground but is currently not receiving events. In which sate it would be in?

An app will be in 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.

How can you respond to state transitions on your app?

On state transitions can be responded to state changes in an appropriate way by calling corresponding methods on app's delegate object.

For example:

applicationDidBecomeActive method can be used to prepare to run as the foreground app.
applicationDidEnterBackground method can be used to execute some code when 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
applicationWillTerminate method is called when your app is being terminated.

List down app's state transitions when it gets launched.

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.

Who calls the main function of you app during the app launch cycle?

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.

Give example scenarios when an application goes into InActive state?

An app can get into 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.

When an app is said to be in active state?

An app is said to be in active state when it is running in foreground and is receiving events.

Name the app sate which it reaches briefly on its way to being suspended.

An app enters background state briefly on its way to being suspended.

Assume that an app is not in foreground but is still executing code. In which state will it be in?

Background state.

An app is loaded into memory but is not executing any code. In which state will it be in?

An app is said to be in suspended state when it is still in memory but is not executing any code.

Assume that system is running low on memory. What can system do for suspended apps?

In case system is running low on memory, the system may purge suspended apps without notice.

What is the use of controller object UIApplication?

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.

How is the app delegate is declared by Xcode project templates?

App delegate is declared as a subclass of UIResponder by Xcode project templates.

What happens if IApplication object does not handle an event?

In such case the event will be dispatched to your app delegate for processing.

Which app specific objects store the app's content?

Data model objects are app specific objects and store app’s content. Apps can also use document objects to manage some or all of their data model objects.

Are document objects required for an application? What does they offer?

Document objects are not required but are very useful in grouping data that belongs in a single file or file package.

How do you change the content of your app in order to change the views displayed in the corresponding window?

To change the content of your app, you use a view controller to change the views displayed in the corresponding window. Remember, window itself is never replaced.

Define view object.

Views along with controls are used to provide visual representation of the app content. View is an object that draws content in a designated rectangular area and it responds to events within that area.

You wish to define your custom view. Which class will be subclassed?

Custom views can be defined by subclassing UIView.

Which object is create by UIApplicationMain function at app launch time?

The app delegate object is created by UIApplicationMain function at app launch time. The app delegate object's main job is to handle state transitions within the app.

Which object manage the presentation of app's content on the screen?

View controller objects takes care of the presentation of 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.

Which is the super class of all view controller objects?

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.

What is the purpose of UIWindow object?

The presentation of one or more views on a screen is coordinated by UIWindow object.

Apart from incorporating views and controls, what else an app can incorporate?

Apart from incorporating views and controls, an app can also incorporate Core Animation layers into its view and control hierarchies.

What are layer objects and what do they represent?

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.

Difference between categories and extensions?

Class extensions are similar to categories. The main difference is that with an extension, the compiler will expect you to implement the methods within your main @implementation, whereas with a category you have a separate @implementation block. So you should pretty much only use an extension at the top of your main .m file (the only place you should care about ivars, incidentally) — it’s meant to be just that, an extension.

What are KVO and KVC?

KVC: Normally instance variables are accessed through properties or accessors but KVC gives another way to access variables in form of strings. In this way your class acts like a dictionary and your property name for example “age” becomes key and value that property holds becomes value for that key. For example, you have employee class with name property.

You access property like

NSString age = emp.age;

setting property value.

emp.age = @”20″;

Now how KVC works is like this

[emp valueForKey:@"age"];

[emp setValue:@"25" forKey:@"age"];

KVO : The mechanism through which objects are notified when there is change in any of property is called KVO.

For example, person object is interested in getting notification when accountBalance property is changed in BankAccount object.To achieve this, Person Object must register as an observer of the BankAccount’s accountBalance property by sending an

addObserver:forKeyPath:options:context: message.

What is difference between NSNotification and delegate?

Delegate is passing message from one object to other object. It is like one to one communication while nsnotification is like passing message to multiple objects at the same time. All other objects that have subscribed to that notification or acting observers to that notification can or can’t respond to that event. Notifications are easier but you can get into trouble by using those like bad architecture. Delegates are more frequently used and are used with help of protocols.

What is push notification?

Imagine, you are looking for a job. You go to software company daily and ask sir “is there any job for me” and they keep on saying no. Your time and money is wasted on each trip.(Pull Request mechanism).

So, one day owner says, if there is any suitable job for you, I will let you know. In this mechanism, your time and money is not wasted. (Push Mechanism).

What is Automatic Reference Counting (ARC) ?

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.

What is polymorphism?

This is very famous question and every interviewer asks this. Few people say polymorphism means multiple forms and they start giving example of draw function which is right to some extent but interviewer is looking for more detailed answer.

Ability of base class pointer to call function from derived class at runtime is called polymorphism.

Whats fast enumeration?

Fast enumeration is a language feature that allows you to enumerate over the contents of a collection. (Your code will also run faster because the internal implementation reduces
message send overhead and increases pipelining potential.)

Whats a struct?

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.

Whats the difference between frame and bounds?

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).

AweSome

Friday, 17 May 2013

Cocoa Objective-C Interview Questions-Answers

Cocoa Objective-C Interview Questions-Answers

iOS interview questions with answers