Objective C For Iphone Development

Objective-C
7/20/2009 go4nishu@yahoo.com
Overview
Objective-C is an object oriented language.
follows ANSI C style coding with methods
from Smalltalk
Relies mostly on libraries written by others
Flexible almost everything is done at
runtime.
Dynamic Binding
Dynamic Typing
Dynamic Linking
Some Special Keywords
id - The generic object type that can
hold a pointer to any type of object. This uses
dynamic typing
Isa - The isa variable is used to identify the
class to which an object belongs at runtime.
nil – represents an invalid object.
self - in a method self refers to the receiver
of the message
Class – when used as a message returns the
class object
Object Messaging
[receiver message]
eg. [myRectangle display];
[myRectangle setOriginX: 30.0 y: 50.0];
Sending Messages to nil

Person *motherInLaw = [[aPerson
spouse] mother];
Polymorphism & Dynamic Binding
The selection of a method
implementation happens at runtime.
When a message is sent, a runtime
messaging routine looks at the receiver
and at the method named in the
message. It locates the receiver’s
implementation of a method matching
the name, “calls” the method,
Interview Buzz iPhone App
Dot Syntax
Compact and convenient
Invoke accessor methods .
Doesn't access instance variable
directly
myInstance.value = 10;
Is same as
[myInstance setValue:10];
Dot Syntax
myInstance.value
is same as
[myInstance value];
compiler can signal an error when it

detects a write to a read-only property
using dot syntax
Key-value coding (KVC)
identify properties with string-based
keys
valueForKey:
setValue: forKey:
Key-value coding (KVC)
@property NSString *stringProperty;
NSString *string = [objectInstance

valueForKey:@"stringProperty"];
[objectInstance setValue:[NSString @”
constantString”] forKey:@“stringProperty"];
Dynamic Language
Almost everything is done at runtime
Uses dynamic typing, linking, and
binding
This allows for greater flexibility
Minimizes RAM and CPU usage
To Import or Include?
#import head.h
C/C++’s #include will insert head.h

into the code even if its been added
before.
Obj-C’s #import checks if head.h has
been imported beforehand.
Messages
Almost every object manipulation is
done by sending objects a message
Two words within a set of brackets, the
object identifier and the message to
send. [Identifier message ]
Because of dynamic binding, the

message and receiver are joined at
runtime
Interview Buzz On App Store
Free promotinal codes for App : WXPN3FWTRP3X and

R3F73AA4RP4P .can be used only once on US store for
iPhone 3.0
Please give +ve Feedback in review section
Type Instrospection
[anObject isMemberOfClass:someClass]
receiver is an instance of a particular class
[anObject isKindOfClass:someClass]
Checks whether receiver inherits from or is an

instance of a particular class:
Memory Allocation
Objects are created dynamically
through the keyword, “alloc”
Objects are dynamically deallocated
using the words “release” and
“autorelease”
autorelease dealocates the object once
it goes out of scope.
NOTE: None of these words are built-in
Ownership
Objects are initially owned by the id
that created them.
Like C++ pointers, multiple IDs can use
the same object.
However, like in C++ if one ID releases
the object, then any remaining pointers
will be referencing invalid memory.
A method like “retain” can allow the
object to stay if one ID releases it.
Prototyping functions
When declaring or implementing
functions for a class, they must begin
with a + or -
+ indicates a “class method” that can
only be used by the class itself. In other
words, they’re for private functions.
- indicates “instance methods” to be
used by the client program (public
functions).
Class Declaration (Interface)
#import <Cocoa/Cocoa.h>
node.h
@interface Node : NSObject {
Node *link;
int contents;
}
+(id)new;
-(void)setContent:(int)number;
-(void)setLink:(Node*)next;
-(int)getContent;
-(Node*)getLink;
@end
Class Definition (Implementation)
#import "node.h”
@implementation Node node.m
+(id)new
{ return [Node alloc];}
-(void)setContent:(int)number
{contents = number;}
-(void)setLink:(Node*)next {
[link autorelease];
link = [next retain];
}
-(int)getContent
{return contents;}
-(Node*)getLink
{return link;}
@end
Class Object
One per class
Responsible for producing instances
Class methods are for class object
All class objects are of type class.
Class name stands for the class object
only as the receiver in a message
expression
Class Object
int versionNumber = [Rectangle
version];
Retrieving class object id
id aClass = [anObject class];
id rectClass = [Rectangle class];
class objects can also be more
specifically typed to the Class data
type:
Class
7/20/2009
aClass = [anObject
go4nishu@yahoo.com
class];
Allocation and Intitalization
myRectangle = [Rectangle alloc];
allocates memory for the new object’s
instance variables and initializes them all
to 0.
isa connects new instance to its class.
myRectangle = [[Rectangle alloc] init];
Initialize the newly allocated memory to
appropriate values
Returned Object
Init method can return object other than
newly allocated receiver or even return
nil.
Use the value returned by the

initialization method, not just that
returned by alloc or allocWithZone:
Brief About Interview Buzz
Interview Buzz is an app with complete
Q&A for Behavioral or HR interviews. No
need to buy an expensive book or search
through 100’s of websites. This app
covers almost all questions that you might
expect on an HR, Behavioral or round one
of interviews. It includes Do’s, Dont’s and
attire tips for the interview.
Returned Object
id anObject = [SomeClass alloc];

[anObject init];
[anObject someOtherMessage];
Code is dangerous since it ignores return of init.
Safe Initialization: combine allocation and initialization
id anObject = [[SomeClass alloc] init];

[anObject someOtherMessage];
Custom Initializer
Name must begin with init e.g. initWithFormat
Return type should be id
invoke the superclass’s designated initializer
assign self to the value returned by the designated initializer
return self, unless the initializer fails in which case you return nil
if there is a problem during an initialization method, you should call [self
release] and return nil.
- (id)init {
// Assign self to value returned by super's designated initializer
// Designated initializer for NSObject is init
if (self = [super init]) {
creationDate = [[NSDate alloc] init];
}
return self;
7/20/2009 } go4nishu@yahoo.com
Designated Initializer
Method that guarantees inherited instance variables
are initialized (by sending a message to super to
perform an inherited method).
Designated initializers are chained to each other

through messages to super.
Other initialization methods are chained to

designated initializers through messages to self.
Designated Initializer
- (id)initWithName:(NSString *)string
{
if ( self = [super init] ) {
name = [string copy];
}
return self;
}
- init
{
return [self initWithName:"default"];
}
Using Super
- negotiate{
...
return [super negotiate];
}
overrides existing method to modify or
add and still incorporates the original
method.
Using Super
Initialization with init
- (id)init
{ if (self = [super init]) {
...
}}
sends an init message to super to have
the classes it inherits from initialize
their instance variables.
Redefining self in Class Methods
Class methods are often concerned not with the class object,
but with instances of the class.
+ (Rectangle*)rectangleOfColor:(NSColor *) color
{
self = [[Rectangle alloc] init]; // BAD
[self setColor:color];
return [self autorelease];
}
self here refers to class object.
To avoid confusion, use a variable other than self to

refer to an instance inside a class method:
+ (id)rectangleOfColor:(NSColor *)color
{
id newInstance = [[Rectangle alloc] init]; // GOOD
[newInstance setColor:color];
return [newInstance autorelease];
}
Rather than sending the alloc message to the class
in a class method, it’s often better to send alloc to
self. This way, if the class is subclassed, and the
rectangleOfColor: message is received by a
subclass,the instance returned will be the same type
as the subclass
+ (id)rectangleOfColor:(NSColor *)color
{
id newInstance = [[self alloc] init]; // EXCELLENT
[newInstance setColor:color];
return [newInstance autorelease];
7/20/2009
} go4nishu@yahoo.com
Super vs. Self
super - is simply a flag to the compiler
telling it where to begin searching for
the method to perform; it’s used only as
the receiver of a message.
self - is a local variable within method
and it can be used in any number of
ways, even assigned a new value
Declared Properties
shorthand for declaring accessor methods
provides a clear, explicit specification of how the accessor
methods behave
compiler can synthesize accessor methods for you
Properties are represented syntactically as identifiers and are
scoped
you have less code to write and maintain
NSTextField *textField;
@property (retain) IBOutlet NSTextField *textField;
@synthesize textField;
Links To Buy Interview Buzz
http://itunes.apple.
com/WebObjects/MZStore.
woa/wa/viewSoftware?
id=326640614&mt=8
Facebook Fan Page

http://www.facebook.
com/pages/Interview-
Buzz/132862644759
Property Declaration
@property(attributes) type name;
is equivalent to:
- (float)value;
- (void)setValue:(float)newValue;
Property Declaration
Attributes
- readwrite
- readonly
- assign
- retain
- copy
- nonatomic
Using Properties
Property Re-declaration
Re-declare a property in a subclass, but
you must repeat its attributes in whole in
the subclasses
If you declare a property in one class as
readonly, you can redeclare it as
readwrite in a class extension
Re-declare readonly to readwrite
// public header file
@interface MyObject : NSObject {
NSString *language;
}
@property (readonly, copy) NSString *language;
@end
// private implementation file
@interface MyObject ()
@property (readwrite, copy) NSString *language;
@end
@implementation MyObject
@synthesize language;
@end
using a class extension to provide a property that is declared as read-only

in the public header but is redeclared privately as read/write
Copy Attribute
value is copied during assignment
@property (nonatomic, copy) NSString *string;
string = [newString copy];
synthesized method uses the copy

method
Copy returns immutable version of
collection.
Provide your own implementation for
mutable arrays or collections
Copy For mutable Array
@interface MyClass : NSObject {
NSMutableArray *myArray;
}
@property (nonatomic, copy) NSMutableArray *myArray;
@end
@implementation MyClass
@synthesize myArray;
- (void)setMyArray:(NSMutableArray *)newArray {
if (myArray != newArray) {
[myArray release];
myArray = [newArray mutableCopy];
}
}
@end
Category
Allows you to add methods to an existing class
without subclassing.
Additional instance variables can not be added using
category.
No difference between methods declared in class
implementation and declared as category.
Category methods are inherited by all subclasses of
the class.
All instance variables within the scope of the class
are also within the scope of the category
Category Declaration
#import "ClassName.h"
@interface ClassName ( CategoryName )
// method declarations
@end
#import "ClassName+CategoryName.h"
@implementation ClassName ( CategoryName )
// method definitions
@end
Category
A category can also override methods
declared in the class interface.
Cannot reliably override methods
declared in another category of the
same class.
Not a substitute for subcalss.
Use categories to distribute the
implementation of a new class into
separate source files
Protocols
Objective C protocols are similar to
java’s interfaces.
Declare methods that any class can
implement.
Declare the interface to an object while
concealing its class.
List of methods declarations,
unattached to class definition.
Formal and informal protocols.
Formal protocols
@protocol ProtocolName
method declarations
@end
@protocol NSCopying
- (id)copyWithZone: (NSZone *)zone;
@end
@optional & @required(default)

Informal Protocols
Category that lists a group of methods but does not implement
them.
Typically declared for root NSObject class.
Implementing class need to declare methods again in interface
file and define with other methods in implementation file.
No type checking at compile time nor a check at runtime to see
whether an object conforms to the protocol.
@interface NSObject ( MyXMLSupport )

- initFromXMLRepresentation:(NSXMLElement *)XMLElement;
@property (nonatomic, readonly) (NSXMLElement *)
XMLRepresentation;
@end
Conform & Adopt a protocol
[receiver conformsToProtocol:@protocol(MyXMLSupport)]
@interface ClassName : ItsSuperclass < protocol list >
@interface Formatter : NSObject < Formatting, Prettifying >
Protocol adopting protocol
@protocol Drawing3D<Drawing>
Type Checking
- (id <Formatting>)formattingService;
id <MyXMLSupport> anObject;
anObject will contain objects which
conform to MyXMLSupport protocol.
Fast Enumeration
Type existingItem;
for ( existingItem in expression ) { statements }
NSArray, NSDictionary, and NSSet—adopt

NSFastEnumeration protocol
NSArray *array = [NSArray arrayWithObjects:
@"One", @"Two", @"Three", @"Four", nil];
for (NSString *element in array) {
NSLog(@"element: %@", element);
}
Exception Handling
Similar to java and C++
@try, @catch, @throw, and @finally
directives and NSException
Cup *cup = [[Cup alloc] init];

@try {
[cup fill];
}
@catch (NSException *exception) {
NSLog(@"main: Caught %@: %@", [exception name], [exception reason]);
}
@finally {
[cup release];
}
Exception Handling
Throwing an exception
inside catch block throw exception usinf
@throw directive
NSException *exception = [NSException

exceptionWithName:@"HotTeaException"
reason:@"The tea is too hot" userInfo:nil];
@throw exception;
Selectors
Two Meaning
Name of the method when used inside
source code message to object.
Unique identifier when the source code is
compiled.
SEL and @selector
Use @selector directive to refer to
compiled selector.
SEL setWidthHeight;
setWidthHeight = @selector(setWidth:height:);
Selectors
String to selector
setWidthHeight = NSSelectorFromString
(aBuffer);
Selector to String
NSStringFromSelector function returns a method name for a
selector:
NSString *method;
method = NSStringFromSelector(setWidthHeight)
Memory Management
No garbage collection for iphone
Auto release pool
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

adds certain arrays, strings, dictionaries to this pool
[pool drain];
Pool contains reference to objects to be released.

[anObject autorelease] adds anObject to autorelase
pool.
Memory Management
Auto release pool is must for using foundation
objects.
[NSString stringWithString: @”string 2”];
Reference Counting.
[anObject retain]
[anObject release]
[anObject retainCount]
Constant strings have no reference-counting

mechanism because they can never be released
Reference count & Instance variables
-(void) setName: (NSString *) theName

{
name = theName;
}
NSString *newName;
...
[myCard setName: newName];
-(void) setName: (NSString *) theName

{
[name release];
name = [[NSString alloc] initWithString: theName];
}
Dealloc and Autorelease
-(void) dealloc {
[name release];
[super dealloc];
}
@end
ClassA *myA = [[ClassA alloc] init];
.......
[myA release];
ClassA *myA = [[ClassA alloc] init];

[myA autorelease];
Interview Buzz
Thanks

Objective C For Iphone Development

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Objective C For Iphone Development

Enviado por

Direitos autorais:

Formatos disponíveis

Objective-C

Sending Messages to nil

compiler can signal an error when it

@property NSString *stringProperty;

NSString *string = [objectInstance

C/C++’s #include will insert head.h

Because of dynamic binding, the

Free promotinal codes for App : WXPN3FWTRP3X and

receiver is an instance of a particular class

Checks whether receiver inherits from or is an

Use the value returned by the

id anObject = [SomeClass alloc];

Code is dangerous since it ignores return of init.

Safe Initialization: combine allocation and initialization

id anObject = [[SomeClass alloc] init];

Designated initializers are chained to each other

Other initialization methods are chained to

To avoid confusion, use a variable other than self to

Facebook Fan Page

using a class extension to provide a property that is declared as read-only

synthesized method uses the copy

@optional & @required(default)

@interface NSObject ( MyXMLSupport )

@interface ClassName : ItsSuperclass < protocol list >

@interface Formatter : NSObject < Formatting, Prettifying >

Protocol adopting protocol

NSArray, NSDictionary, and NSSet—adopt

Cup *cup = [[Cup alloc] init];

NSException *exception = [NSException

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Pool contains reference to objects to be released.

Constant strings have no reference-counting

-(void) setName: (NSString *) theName

-(void) setName: (NSString *) theName

ClassA *myA = [[ClassA alloc] init];

Você também pode gostar