Delegates in Objective C

Delegate in Objective C is used when one class objects wants to assign some of its work to another object.
Example:- in NSTableView we want cell to be drawn as per requirement. So we can delegate that adding data to cell will be done by that another delegate class object.


use of category with delegate

@interface NSObject  (NSCommonDelegateMethods)

- (void) commonMethodForallclass: (NSObject *) browser;

@end

 By putting a category on NSObject , any kind of object can be used as a delegate object. There

is no need to inherit from a specialized   class.

Adding  category on NSObject  is called creating an informal protocol.

Read More

Categories in Objective C

When you want to add something to the existing class normally we go for subclassing.In Objective we can new method to the existing class and the term called as "Category".
 Suppose in Circle class u want to add method for converting radius from float to int (let say some extra rounding off). The declaration of category as

.h file

@interface Circle (Conversion)  // existing name + new name in parenthesis 

- (int *) floattoint;

@end 

It much look like class declaration.

Here category name is Conversion. You can not add instance variable to existing classes by category.

.m file

@implementation Circle (Conversion)

- (int *) floattoint

{

//here code for conversion+ return value. You can access method of circle class with self.

} 

@end 

In category if u have same function name as existing class then in that case category function wins and every time that will be get called.

categories are used for to split the single class into multiple file. In objective C its not possible to have single class in multiple .m files.

Example

1.Maincalss

.h file

@interface MainCategory

{

 int temp1;

 int temp2;

}

@end

,m file

@implementation MainCategory

//write if u want any function

@end

2.1st category class

h file

@interface MainCategory (Category1)

-(void) settemp1 :(int) t;

@end

,m file

@implementation MainCategory (Category1)

-(void) settemp1:(int) t

{

temp1=t;

}

@end

3.2nd category class

h file

@interface MainCategory (Category2)

-(void) settemp2 :(int) t;

@end

,m file

@implementation MainCategory (Category2)

-(void) settemp2:(int) t

{

temp2=t;

}

@end

main function

int main (int argc, const char *argv[])

{

MainCategory *maincat;

maincat = [[MainCategory alloc] init];

[maincat settemp1: 34];

[maincat settemp2: 24];

[thing release];

return (0);

} 

Category are used for forward declaration.

You can implement method in main class without declaring it in @interface. If you want to use same method out side the class better to  write new category  and in that category @interface declare that method and implementation part of that category will not have anything.

Categories are used for adding informal protocols to an object.

Read More

Properties in Objective C

Properties is the feature of the Objective C .
It reduces lots of code writing.
Its mainly used for accessor i.e. getting and setting data member. compiler will add that code of getter and setter with respect to the thread safe or not.
syntax

.h file

#import <Foundation/Foundation.h>

@interface Circle : Shape {

int color;

int radius;

}

@property int color;

@property int radius;

@end 

.m file

#import "circle.h"

@implementation Circle

@synthesize color;

@synthesize radius;

//here code of implementation 

@end

in above example for color and radius getter and setter will be added by compiler.

@property does work of declaration of setter and getter.

@synthesize does work of creating implementation of setter and getter.

u can acces these data member with dot operator outside. 

ex

circle.radius=10; //setter method will be get called sometime these setter can be thread safe.

We saw uses of property with simple data type.

If u want to use with class objects then its better to do with some extra attributes.

ex

@property (retain) Rect *circleorigin;// retain means at the time of setting method is written by compiler       object will be retained .

same way there are some attrinute:

1.nonatomic:- when u do not want that data member should not be thread safe . faster access.

2.copy:- objects copy will be get created.

3.assign:- if u do not want to retain that object.

4.readwrite:- we can read and write values to data member (
 By default, properties are mutable).

5.readonly:- for ready only properties. generate getter. not require setter.

 Suppose u want the internal name and property name should be different.

create data member inside class declaration and use as below

@synthesize  color=circlecolor;

inside setter method circlecolor value will be get set.  This is useful normally when u are referencing that data member inside class should be accessible without self.

By default when u want to access that data member anywhere u have to access with either objectname.datamember or inside class self.datamember.

Read More

Object Creation and initialization in Objective C

COCO suggest to use alloc and init method for object creation.
alloc:- allocates the required memory for the object and initializes memory content to zero.
init :- will initializes the object data members.

alloc and init should be chaining like this
Rect *rect=[[Rect alloc] init];
should not like

Rect *rect=[Rect alloc];
[rect init];

Reason for this is init sometimes return the object which is not same as on which method get called so.

init sometime create new object sometime that object require extra space eg. in String object .

When writing your custom init method always call [super init] to initialize the super classes.

as mentioned earlier init may return the different object so always call 

self= [super init];// as subclassing will take part of it in main derived class.

There is copy method which creates  brand new object and to make the new object same as on which it is called.

Read More

Memory Management in Objective C

Objective C 2.0 introduces garbage collection  to take care of memory.

Reference Counting/Retain counting:-

Every object has an integer with it called reference count or retain count.  Which keep count of that object are in use. When you are giving object to some class/ code and used retain when giving then retain/reference count is increased by one.

Eg.

 -(NSString*)  name

{

 return [name retain];//here name reference count is increased by one

}

When that class done with that object then it calls release on it it decrement reference / retain count by one. When reference count reduces to 0 (Zero)  that objects get freed from memory (by sending dealloc message to it).  System gets that memory.

Object creation through alloc/ new/copy set this count 1.

Declaration of retain, release

- (id) retain;

- (void) release;

- (unsigned) retainCount;

Never call dealloc manually system calls it automatically when count goes to zero.

Autorelease(pool to hold objects temporarily when pool destroy release all objects)

In COCO there is autorelease pool .ie class name NSAutoreleasePool. It holds the objects(collection of objects) that automatically gets released.
NSObject supreme base class of all objective C class has
- (id) autorelease;
method. When we call autorelease on object it means the release message is sent to object in sometime future.When call to  autorelease  method particular object is get added to NSAutoreleasePool. When that pool is destroyed all the object contain in that pool gets release method.

When you are using AppKit , COCO automatically creates and destroys  an autorelease pool on a regular basis.

Important the functions like

+ (id)stringWithFormat:(NSString *)format, ...

usually return the object with autorelease called on it so we do not require to take care for free that memory.

Some objects are like singleton

NSColor *color= [NSColor blueColor];

Any Ui application is in event loop , continuous  waiting for the input. 

Cocoa creates an autorelease pool before it starts handling the event and destroys the pool after the event is handled. So in this case u have to take care of the object u kept in autorelease pool and which u require after the completion of events. eg + (id)stringWithFormat:(NSString *)format, ...

object created with this method at time of event , will live after event .

A best example of custom autorelease pool take from book  Learning Objective C on the Mac By Mark Dalrymple | Scott Knaster

in below example the pool maintain so that memory will not reach at certain level.

NSAutoreleasePool *pool;

pool = [[NSAutoreleasePool alloc] init];

int i;

for (i = 0; i < 1000000; i++) {

id object = [someArray objectAtIndex: i];

NSString *desc = [object descrption];

// and do something with the description

if (i % 1000 == 0) {

      [pool release];

    pool = [[NSAutoreleasePool alloc] init];

    }

}

[pool release]

After every 1000 time pool is released so that memory will be available for next time to use.

 Autorelease pools are kept as a stack: if you make a new autorelease pool, it gets added to the top of the stack. An autorelease  message puts the receiver into the topmost pool. If you put an object into a pool, and then make a new pool and destroy it, the autoreleased object will still be around, because the pool holding that object is still in existence.

Garbage Collection objective C 2.0 onwards

Its same like as Java just create object use it , do not worry about its destruction . Garbage collector will find the use of object and it will automatically destroy the object. Developer has no need to worry abt it.

 Like the autorelease pool, garbage collection is triggered at the end of an event loop.

ARC VS Garbage collection

ARC is not a Garbage Collector. It is better to think of it as manual reference counting (retain/release/autorelease) calls which are added by the compiler. It also uses some runtime tricks.

OS has no method of Garbage Collection. Even so, Garbage Collection is entirely unnecessary (for all practical purposes) when ARC is used. ARC works its magic at compile time to do the reference counting for you thereby making it unnecessary (and actually non-allowed) to use any other sort of memory management.

Read More

COCO Foundation Framework in Objective C

This framework mainly consists of classes like NSArray , NSString etc.
Some classe starts with  CF they belongs to core foundation . Core  foundation is like COCO but implemented in c. Max of its code is open source. eg CFArray.
Classes starts with NS all are part of COCO.

NSValue
It used   to allow items of such data types to be added to collections such as instances of NSArray and NSSetIt can hold any of the scalar types such as int, float, and char, as well as pointers, structures, and object ids. 
Creation with
+ (NSValue *)value:(const void *)value withObjCType:(const char *)type

Ex: NSValue *value= [NSValue valueWithBytes: &rect objCType: @encode(NSRect)];

to retrive u can use [value getValue: &rect];

NSNumber
Its subclass of NSValue .Mainly for converting primitive data type into objective C object.
Creation with:-

+ (NSNumber *) numberWithChar: (char) value;

+ (NSNumber *) numberWithInt: (int) value;

+ (NSNumber *) numberWithFloat: (float) value;

+ (NSNumber *) numberWithBool: (BOOL) value;

NSPonit:-

typedef struct _NSPoint {

float x;

float y;

} NSPoint;

Initialization:-

1. NSPonit point = NSMakePoint (9, 18); // this is used when initializing NSPonit when passing its Object tot any function. without specifying object 

eg.[obj getStr: NSMakePoint (9, 18)];

2. NSPonit point = { 9, 18 };

 NSSize
typedef struct _NSSize {

float width;

float height;

} NSSize;

 NSRect

typedef struct _NSRect {

NSPoint origin;

NSSize size;

} NSRect;

same way of initialization as NSPoint NSMakePoint(), NSMakeSize(), and NSMakeRect()

NSRange:-
typedef struct _NSRange {

unsigned int location;

unsigned int length;

} NSRange;

Mainly used for finding range. location pointing to starting point  and length specifies the length from location. Ex. used in string.

When location has NSNotFound means range does not refer to anything.

Initialization

same way of intialization as NSPoint  normal + NSMakeRange (9, 18);

NSString:-
NSString are immutable. Once created you can not change them. You can just access it.

Its class used for storing/creating/access string.

Some of common method used for string are
1. length :- for getting length of string
2.stringWithFormat: :-for creating  string with format specifier. mainly  for equality
eg[NSString stringWithFormat:@"I will be in office at %d am", 10];
3. isEqualToString: for comparison just return true or false depend upon match.
4.compare: does case sensitive comparison.with  character-by- character comparison.
return values are NSComparisonResult.

typedef enum _NSComparisonResult {

NSOrderedAscending = -1,

NSOrderedSame,

NSOrderedDescending

} NSComparisonResult;

eg NSOrderedAscending when left- hand value is smaller than the right- hand one.
5. For case in sensitive compare use

- (NSComparisonResult) compare: (NSString *) string options: (unsigned) mask;

with mask value is NSCaseInsensitiveSearch

maks value will be NSNumericSearch] when strings are compared as number rather than characters.

6. when want to find first  substring with its location and range then use this- (NSRange) rangeOfString: (NSString *) aString;

7.- (BOOL) hasPrefix: (NSString *) aString;    for to check prefix value

- (BOOL) hasSuffix: (NSString *) aString;    for to check suffix value.

NSMutableString Its subclass of NSString

NSMutableString are mutable string.
You can manipulate string
1.add more character with    i.- (void) appendString: (NSString *) aString;
                                             ii.- (void) appendFormat: (NSString *) format, ...;
2. delete characters with i.- (void) deleteCharactersInRange: (NSRange) range;
3.creation + (id) stringWithCapacity: (unsigned) capacity;


NSArray
For storing only objective C objects. you can not store nil also.NSArray creates static arrays.
Static array means  you can not modifies its objects.

NSMutableArray
It is subclass of NSArray.  It is mutable array i.e. modifiable array of objects.
i. Add object at end - (void) addObject: (id) anObject;
ii. remove object  - (void) removeObjectAtIndex: (unsigned) index;

NSDictionary

It is used to store the key - value pair. It uses hashing mechanism so it is faster than array.

NSMutableDictionary

subclass of NSDictionary . mutable class.

NSNull 

We can not store the nil directly into NSArray or in NSDictionary.

NSNull used to store the nil value in NSArray and NSDictionary.

Mainly used to store  nothing . 

Example :- In case of keeping the employee info. Some employee may not have bike.

Fast Enumeration

It is used for to iterate through all objects of array. this is much faster.

ex

for (NSpoint *pt in array) {

NSLog (@"Value of point %@", pt);

}

NSDate

To get the date and time.

NSDate *date = [NSDate date];// date will be having current date and time.

NSData

It is used to hold buffer. It has buffer pointer plus length of buffer. 

It is mainly used to make memory management easy.

const char *string = "This is for test";

NSData *data = [NSData dataWithBytes: string length: strlen(string) + 1];

Read More

Useful information for Objective C developer

Use .mm   file extension,when your file has  C++ and Objective- C code together.

For import and include there is two different ways to include/import file 

i.use < > when adding system declared file(system provided file)

ii.use " " when adding local declared file.(declared by you.)

Forward declaration is used when u do not want to add(import/include) declaration in header file.

Forward declaration tell to compiler that you will get declaration of this later part. And we can add(import/include) that file in .m or .mm file. Mostly forward declaration is used in circular dependency. It means class X uses class Y and Class Y uses Class X.

Xcode shortcut are here
http://developer.apple.com/library/mac/#documentation/IDEs/Conceptual/xcode_help-command_shortcuts/MenuCommands/MenuCommands014.html#//apple_ref/doc/uid/TP40010560-CH2-SW1

http://developer.apple.com/library/mac/#documentation/IDEs/Conceptual/xcode_help-command_shortcuts/TextCmdsByType/TextCmdsByType.html#//apple_ref/doc/uid/TP40010560-CH4-SW1

http://developer.apple.com/library/mac/#documentation/IDEs/Conceptual/xcode_help-command_shortcuts/SystemAndOther/SystemAndOther.html#//apple_ref/doc/uid/TP40010560-CH5-SW3

Read More

Composition OOP

Composition
Composition means consists of many things.Mean Single big object/class consists of many objects in it.
Ex:-
@interface Computer
{
    CPU * ptrCpu;
   Monitor* ptrMonotor;
   Mouse* ptrMouse;
}
@end

Only objects are said to be composed not primitive data type like int ,char etc.

Composition set up "has a " relationship. Its represent that Main object own other small small objects.
Ex: Computer has a Cpu.

Inheritance set up "is a" relationship.
Ex:-Triangle is a shape

Read More

Inheritance OOP concept :

Inheritance:-
Different kinds of objects often have a certain amount in common with each other.
Object-oriented programming allows classes to inherit commonly used state and behavior from other classes.

What is need OR advantages using Inheritance:-
1.You can save code memory, easy to make changes. Suppose theres is function which is common between different classes .
We can move it in base class instead of defining same code in multiple classes.
eg.:- For Ui component setting bounds will be used by each UI component. Better to move it in common base class.

Common class is called as base/ Parent and the one which uses it is called as derived/subclass/child class
2.It is also useful when you want to store different kind of classes in same data object. You can make some common class to all that classes . Store the object of that common classes name.
eg. car, truck etc will be stored as vehicle.

Syntax:-
@interface Vehicle :NSObject
@interface Car : Vehicle

Note:- NSObject is supermost class for all the classes having lots of beneficial function to it .
like :- alloc, init etc.

In Objective C multiple inheritance is not allowed.
Multiple inheritance is achieved thru protocol and category.

Derived class get all function and data member from its base class except private.

Overriding is used  for to change the base implementation of base class. You can write the same function with signature in derived class. So when u will call that function derived class's function will get called.

How the call to function gets resolved:-
Method Dispatcher:- It does the method resolving work. It decide on basis of object which method to call.
i. If object is of base class then it call base class method.
ii. If object is of derived call then check for method in derived class if not present then goes for base class.

Like C++ in Objective C every method one hidden parameter get passed which is self.
Self is pointer to object on which method get called.

super is used when u want to call the superclass's method from base class.

Read More

OOP concept : As Objective C is Object oriented.

OOP(Object oriented programming) is way to construct software which is made of objects(Single or many). Object is like entity which differentiate from other types. eg. Car, Human etc.
In Object oriented programming Data is center point around which function are there this is exactly opposite to procedural programming.

In Objective calling function on object is called as sending a message

Some terms used in OOP
1.Class:- It is blueprint of object. actually its a structure which represent the Object. Contain required data member and function of object.
2.Object/ Instance:- Its an existing entity  in memory having value of objects .(In objective c one more parameter is there for each object is hidden pointer to its class)

OOP in objective C
anything after @ is compiler descriptive
1.@interface:-
It is used to declare a data member (i.e. of that object) and functions(i.e. features provided by object).
 eg:-
//starting of class
@interface Rectangle : NSObject
{//in this curly bracket add data members of objects
   int x;
   int y;
   int width;
   int height;
   int clr;
}
//here outside of curly bracket add functions/ features of objects
-(void) Draw;
-(void) setColor:(int) clr;

@end
//end of class

below is normal declaration of method in objective c
-(return type) funcname :(passing arg1 type) variablename;


-(return type) funcname :(passing arg1 type) variable2name (passing arg2 type) variablename;

-(return type) part1funcname :(passing arg1 type) variable1name  part2funcname :(passing arg2 type) variable2name part3funcname :(passing arg3 type) variable3name;

Objective C uses infix notation in which method and its arguments are intertwined.

eg:-

[rect setColor:clr];

[objectname fumctionname:arg];

[objectname part1fumctionname:arg1 part2fumctionname:arg2];

Imp note:-
When calling a method , do not add colon at the end of the it when it is without parameter.
Some times compiler will not give error as this is run time language.

2.@implementation
It is the place where class's method defined.
@ implementation Rectangle
//implementation starts here
-(void) draw
{
//write a code for drawing rectangle
}

-(void) setColor:(int) clr
{
//define function here
}
@end
//implementation ends here

You can define extra functions in the implementation which are not declared in the @interface .
These functions are private function not visible outside of class.

Like this pointer in c++ , In objective C for every function there is one hidden parameter  named self even for static method also (which is not in c++). But in static method it will not have instance variables.

3.Object Creation:-
Allocating memory to object and initialization of object.
NSObject is base class for almost every class in Objective . its is the super most class like Object in java.
Normally uses alloc and init method of the NSObject to allocate and initialize the Object;
eg.
Rectangle *rect=[[Rectangle alloc] init];

In object-oriented programming, the open/closed principle states "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification"
[source :- http://en.wikipedia.org/wiki/Open/closed_principle]

Read More