What is main reason behind use of Extensions in Objective C - objective-c

Question

I studied about extensions and now i have some queries on some points of extension use.
Point : Extensions extend the functionality of classes for which we have source code.
Query : If we already have source code for a class then we can easily write all the required methods in header file and in implementation file.So why we are using extension for this feature.
Point : Extensions also provide the alternative to private methods.
Query : we can write private methods in private interface in .m file.so why we are using extension for this feature also.
Point : Extensions makes a property readonly for other classes and readwrite for original class.
Query : this functionality also can be achieved by redefining the readonly property in implementation file with readwrite properties.
Confused with these queries, the actual concept behind the extensions.Any help would be appreciated.

Answer 1

The previous two answers have confused categories with class extensions, which is an easy mistake to make since Swift calls "extensions" what Objective-C calls "categories". But class extensions in Objective-C are a separate thing. As opposed to a category, which is declared like this:
#interface SomeoneElsesClass (MyCategoryName)
an Objective-C class extension is declared with nothing in the parens, like this:
#interface MyClass ()
The major differences between the two are that 1) unlike categories, an extension can only be declared for a class for which you have the source code, 2) unlike categories, which need a separate #implementation block, the implementation for anything you declare in the extension goes in the main #implementation block for the class, and 3) extensions can add stored properties, whereas categories cannot.
The primary thing extensions are used for is adding private stored properties, and extending publicly read-only properties to be writable. This can be done by other means, yes, but it requires more code. For example, a private property can be added via an extension like so:
#interface MyClass ()
#property (nonatomic, copy) NSString *someProperty;
#end
whereas to do it in the implementation, you'd have to make an ivar and then write the accessors:
#implementation MyClass {
NSString *_someIvar;
}
- (NSString *)someProperty {
return self->_someIvar;
}
- (void)setSomeProperty:(NSString *)str {
self->_someIvar = [str copy];
}
#end
As you see, the extension results in fewer lines of code, and clearer code overall. Similarly, adding read-write support to a publicly read-only property is more succinct and communicates what you want to do more clearly than writing out a setter.
Extensions can also be useful when writing library and/or framework code, because you can put an extension in an internal header file which is #imported by other source files in the framework project but not published as a public header. In this way, you can expose methods to other framework code but not to clients of the framework. In this way, you can get the same functionality that is provided by Swift's internal keyword. This can, of course, also be done with categories, but extensions provide a cleaner way to do it, since the corresponding implementation of the methods will not have to be in a separate #implementation block.
See the documentation for more information: https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html#//apple_ref/doc/uid/TP40011210-CH6-SW3

Answer 2

My Objective-C is getting rusty, and there are subtle differences in the use of extensions in Swift, but I'll take a stab at answering your questions:
Extensions let you extend the functionality for classes for which you don't have the source code. This includes system classes.
Extensions also let you group methods into logical groupings for clarity. For example, you might create an extension that defines all the methods needed to conform to a protocol.
Yes, you can use an extension to make a property read/write inside a class and readonly for external users of the class, and you can also do that by redefining the property in the implementation. This is a matter of style. It's common to have more than one way to achieve something in programming.

Answer 3

If we already have source code for a class then we can easily write all the required methods in header file and in implementation file.So why we are using extension for this feature.
That is rather targeted at the classes you didn't write yourself and don't have access nor the ability to modify their source code - like UIKit or Foundation classes. Sure, you can subclass them, but if you have a fairly large codebase and want to add additional functionality to a class, then without extensions (or rather, categories in Objective-C) you'd need to rewrite your codebase to use the derived class.
we can write private methods in private interface in .m file.so why we are using extension for this feature also.
and
this functionality also can be achieved by redefining the readonly property in implementation file with readwrite properties.
That only works within the single .m file defining the class - what if you want to have readwrite access to classes properties or access to private methods within entire module (for example, a framework you're writing), but readonly outside of it, as well as not exposing the methods? Categories provide you the means for that.