1)What are categories in iOS?
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.
2) What is Delegation in iOS?
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 the windowWillResize: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 the applicationDidFinishLaunching: message. The
delegate is then able to perform additional tasks if it wants. 3) What are all the difference between categories and subclasses? Why should we go to subclasses?
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.
4) What is notification in iOS?
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.
5) What is the difference between delegates and notifications?
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.6)What is protocol?
A protocol is an important
language feature in Objective-C. Protocols provide, among other things, the
ability to realize multiple inheritance in a single-inheritance language.
Think of a protocol as an
interface in the Java language. Just as classes in Java can implement multiple
interfaces, so can classes in Objective-C adopt multiple protocols.
A protocol is just a list of
methods. Each method in this list can be tagged as either required (@required,
the default) or optional (@optional). If a class adopts a protocol, it must
implement at least all required methods in that protocol
7) Difference
between protocol and delegate?
A protocol is an
interface that a class can conform to, meaning that class implements the listed
methods. A class can be tested for conformance to a protocol at compile-time
and also at run-time using the conformsToProtocol:.. NSObject method.
A delegate is a
more abstract term that refers to the Delegation Design Patten. Using this
design pattern, a class would have certain operations that it delegates out
(perhaps optionally). Doing so creates an alternative to subclassing by
allowing specific tasks to be handled in an application-specific manner, which
would be implemented by a delegate.
They are related
terms because you often see a Protocol created for the purpose of delegation.
If I wanted to allow a delegate to sort something, I'd create a Protocol with a
required method listed such as "sortMyCoolStuff:.." and I would
require the delegate to implement it. That way, within class that supports
calling to a delegate, I can accept a pointer to a delegate and then can say
"if that delegate conforms to myCoolProtocol, I know it implements
sortMyCoolStuff, so it's safe to call that method instead of doing my built in
behavior"
No comments:
Post a Comment