Objective-C Beginner's Dive: A Quick Introduction

Objective-C
A Beginner’s Dive

Saturday, March 9, 13

I Assume

• A Background in Java or C++
• An understanding of OOP
• A basic understanding of C


What is Objective-C?

• Superset of C
• Smalltalk style Object-Oriented
• The Ofﬁcial Language for iOS and OS X


Cool!
But before we dive in...


Hello World!
//
// main.m

#include <stdio.h>
#include <Foundation/Foundation.h>

int main(int argc, const char **argv)
{
NSString *message = @"Hello World!";

printf("%sn", [message cString]);

return 0;
}


Hello World!
• Objective-C String Literal

• @”Hello World!” //
// main.m

• C Function #include <stdio.h>
#include <Foundation/Foundation.h>

• printf() int main(int argc, const char **argv)
{
NSString *message = @"Hello World!";

• main() printf("%sn", [message cString]);

return 0;

•
}
Objective-C message

• [message cString]


Ok.
Now, on to the teaching!


Objective-C Features
• C Functions
• C Structs
• C Unions
• C Pointers
• C Arrays
• C Everything Else

Objective-C Features
• Objects • Data and Collections
• Methods • Object Literals
• Inheritance • Object Subscripts
• Properties • Forin loops
• Protocols • Blocks and Closures
• Categories • ARC

You Will Learn About

• Making and Using Objects
• Using Foundation Framework Data Types
• Automatic Reference Counting (ARC)


Writing Objects
A Quick Run-Through


Objects
• Interface

• like Java’s Interface, but every object has one

• placed in the header file

• Implementation

• must fill minimum requirements of Interface

• placed in the implementation file


Example Object
// //
// MyObject.m // MyObject.h
// Implementation // Interface

#import “MyObject.h” #import <Foundation/Foundation.h>

@implementation MyObject @interface MyObject : NSObject {
int _myInt;
// method implementations go here }

@end // method declarations go here

@end


Objects (More Info)
• Objects have Instance Variables (ivars)
• No Class variables, use C static globals
• No enforced “public” and “private”
• Object Instances can be of type:
•id
•Class *

Object Methods

• Class Method or Instance Method
• Variables are “named” in the method’s
signature (fancy word for method name)
• Default return and variable type is id


Format of a Method

+/- (return type)methodName;

+/- (return type)methodWithVar:(var type)var;

+/- (return type)methodWithVar1:(var type)var1
! ! ! ! ! ! ! ! var2:(var type)var2;


Method Examples
// //


int _myInt;
// setter }
- (void)setMyInt:(int)myInt {
_myInt = myInt; // setter
} - (void)setMyInt:(int)myInt;

// getter // getter
- (int)myInt { - (int)myInt;
return _myInt;
} @end

@end


Object Method Calling
• Not like C, C++, or Java
• Based on Smalltalk message passing
• The Square Brackets [] are your friend!
[object method];
[object methodWithVar:value];
[object methodWithVar1:val1
! ! ! ! ! ! ! ! var2:val2];


Testing Responsiveness
to a Selector
• The name of a method is its Selector
SEL mySelector = selector(myMethodWithParameter:)

• Every object inherits respondsToSelector:
• Takes the selector to test for
• Returns YES when the object can respond to
that method
• Returns NO when the object cannot respond to
that method


Object Constructor

• Not a special method (unlike Java)
• Just an instance method to set up the
Object’s Instance Variables
• Generally named init


Generic Constructor

- (id)init {
if (self = [super init]) {
// initialize variables
}
return self;
}


Constructor Example
// default constructor
- (id)init {
// calls my custom constructor
return [self initWithInt:0];
}

// custom constructor
- (id)initWithInt:(int)myInt {
_myInt = myInt;
}
return self;
}


Inheritance

• Single Inheritance from Objects
• Method Overloading Supported
• Superclass deﬁned in the Interface
• Super class referenced with super


Inheritance Example
// //


int _myInt;
- (id)init { }
_myInt = 5; - (id)init;
}
return self; @end
}

@end


Properties
• Syntactic sugar for variable, accessor, and
mutator declarations all-in-one
• Properties are declared in the Interface and
synthesized in the Implementation
• Let you use “dot syntax” with getters and
setters
! myObjectInstance.myInt = 5;
! int x = myObjectInstance.myInt;


Property Example
// //
// NSString+Reverse.m // NSString+Reverse.h
// Category // Category

#import "NSString.h" #import <Foundation/Foundation.h>

@implementation MyObject @interface MyObject : NSObject

// creates variable _myInt @property (assign, nonatomic) int myInt;
// creates getter myInt
// creates setter setMyInt: @end
@synthesize myInt = _myInt;

@end


More on Properties
• Attributes
strong weak copy assign readonly
atomic nonatomic

•

@synthesize vs @dynamic
!synthesize variable = nameOfIvar;
@

• Default ivar name for variable is
_variable

• Custom getters and setters
getter = myGetter, setter = mySetter:


Protocols

• Like an Objective-C Interface
• Similar to Java Interfaces
• Can implement multiple Protocols
• Protocols can ‘inherit’ other Protocols


Example Protocol
// //
// MyProtocol.h // MyObject.h
// Protocol // Interface

#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import "MyProtocol.h"
@protocol MyProtocol <NSObject>
@interface MyObject : NSObject <MyProtocol>
@property (assign, nonatomic) int myInt;
@end
- (NSString *)stringMyInt;

@end


Categories
• The ability to add new methods to an
Object
• Changes apply to all instances of the object
• Overwrites any methods that already exist
in the class
• Cannot add Properties and ivars
• Can be dangerous

Example Category
// //
// NSString+Reverse.m // NSString+Reverse.h
// Category // Category

#import "NSString+Reverse.h" #import <Foundation/Foundation.h>
#import <stdlib.h>
@interface NSString (Reverse)
@implementation NSString (Reverse)
- (NSString *)reverse;
- (NSString *)reverse {
int length = [self length]; @end
char *newString =
! ! calloc(length+1, sizeof(char));
int current = 0;

const char *cstr = [self cString];
for (int i=length-1; i >= 0; i--) {
newString[current] = cstr[i];
current++;
}

NSString *new =
! ! [NSString stringWithCString:newString];
free(newString);

return new;
}

@end


Class Extension

• Like Categories, but with the ability to add
ivars and Properties
• Implementations of methods required in
the main Implementation block
• Can be used to declare “private” methods


Class Extension
Example
//
// MyObject.m

// Class Extension
@interface MyObject ()

@property (assign) int myPrivateInt;

@end

// Implementation
@implementation MyObject

@synthesize myPrivateInt = _myPrivateInt;

// more implementation here

@end


Ok.
Now, lets take a look at MyObject


MyObject
// //

#import "MyObject.h" #import <Foundation/Foundation.h>
#import "MyProtocol.h"
@interface MyObject ()
@property (assign, nonatomic) int myPrivateInt; @interface MyObject : NSObject <MyProtocol>
@end
@property (assign, nonatomic) int myInt;
@implementation MyObject
// default constructor
@synthesize myInt = _myInt; - (id)init;
@synthesize myPrivateInt = _myPrivateInt;
// custom constructor
- (id)init { - (id)initWithInt:(int)myInt;
return [self initWithInt:0];
} @end

- (id)initWithInt:(int)myInt {
_myInt = myInt;
! ! _myPrivateInt = 5;
}
return self;
}

- (NSString *)stringMyInt {
return [NSString stringWithFormat:@"%d", _myInt];
}

@end


Great
But how do I use it?


Using MyObject
MyObject *obj = [[MyObject alloc] init];
obj.myInt = 5;
NSLog(@"%in", obj.myInt);

MyObject *other = [MyObject alloc];
other = [other initWithInt:5];
[other setMyInt:10];
NSLog(@"%in", [obj myInt]);


Using MyObject
• alloc class method

• use of init and
initWithInt: methods MyObject *obj = [[MyObject alloc] init];
obj.myInt = 5;

•
NSLog(@"%in", obj.myInt);
splitting up the alloc and
init method calls
MyObject *other = [MyObject alloc];
other = [other initWithInt:5];

• use of dot syntax and [other setMyInt:10];
NSLog(@"%in", [obj myInt]);
generated methods

• NSLog() for printing
messages to the console


One More Thing
Imports and Forward Declarations


Imports
• Objective-C introduces the #import
Preprocessor Directive
#import "MyHeaderFile.h"
#import <SystemHeader.h>

• Guarantees the ﬁle is only included once
• Better Practice than C’s #include


Forward Declarations

• A Promise to the Compiler that a Class or
Protocol will exist at Compile Time

@class PromisedObject;

@protocol PromisedProtocol;

• Minimizes the amount of #includes


Objective-C Data
What you get with the Foundation Framework


nil

• Represents the absence of an object
• Messages passed to nil return nil
• nil is for objects, NULL is for C pointers


YES and NO

• Boolean type BOOL for “true” and “false”
• Use BOOL with YES and NO
• Dont use _Bool or bool with true and
false from stdbool.h


NSNumber

• Object Representation for Integers,
Booleans, Floats, Doubles, Characters, etc.
• Object Literal Syntax
@1 @1.0 @YES @NO @(1+2) @'a'


NSString

• Immutable string
• NSMutableString for mutable strings
@"Hello World!" @("Hello World!")


NSArray
• Immutable object array
• NSMutableArray for mutable arrays
@[object1, object2, ..., objectN];

• Object Subscripting Syntax
array[0] = object;
id object = array[0];


NSDictionary
• Immutable object dictionary
• NSMutableDictionary for mutable
@{key1:value1, key2:value2, ...};

• Object Subscripting Syntax
dictionary[key] = object;
id object = dictionary[key];


Implementing
Array Subscripting
• Accessing Objects
objectAtIndexedSubscript:

• Setting Objects
setObject:atIndexedSubscript:

• The index subscript must be an integral


Implementing
Dictionary Subscripting

• Accessing Object values with key Objects
objectForKeyedSubscript:

• Setting Object values with key Objects
setObject:forKeyedSubscript:


Forin Loops
• Loop over the contents of a collection
• Foundation NSDictionary
NSArray
Framework collections

• Any implementation of the
NSFastEnumeration Protocol

• Any Subclass of NSEnumerator


Forin Loops Example

NSArray *array = @[@1, @2, @3, @4, @5];

for (NSNumber *num in array) {
NSLog(@"%@", num);
}

for (id num in [array reverseObjectEnumerator]) {
NSLog(@"%@", num);
}


Objective-C Blocks

• Functions you can declare within functions
• Can close-over variables for later use
• Can pass block functions around like data


Block Syntax
• Similar to C Function Pointer Syntax
return_type (^name)(parameter types) =
! ^(parameter list) {
! ! // do stuff
! };

return_type (^name)() = ^{
! ! // do stuff
! ! // takes no parameters
! };


Block Example
int multiplier = 5; The block itself has read
int (^mult)(int) = ^(int num){
return num * multiplier; access to variables defined
}; in the lexical scope at the
int num = mult(5); // num = 25 creation of the block.

__block int number = 0; The block can close over
void (încrement)() = ^{
number++; outside variables and
}; modify their values by
increment(); // number = 1 declaring the variable with
increment(); // number = 2 the __block modifier.


Type-Safe Enums
• Enums that you can declare the type they enumerate over
• int, char, unsigned char, NSUInteger, ...

• Syntax similar to Object Subclassing
typedef enum MyEnum : NSUInteger {
A, B, C
} MyEnum;

enum MyUnsignedCharEnum : unsigned char {
FIRST, SECOND, THIRD
};

typedef enum MyUnsignedCharEnum MyUnsignedCharEnum;

typedef enum : NSUInteger {
ONE, TWO, THREE
} AnotherEnum;


Automatic Reference
Counting
What it is, and what it means to you


Referencing Counting
• Nearly-Manual Memory Management

• Objects have a counter showing how many
references are using them

• Retain Objects when you receive them
[object retain];

• Release Objects when you’re done using them
[object release];

• Objects deallocate themselves when their retain
count reaches 0


Automatic Reference
Counting (ARC)
• Almost Compile Time Garbage Collection

• Retain and Release messages are added at compile
time by the compiler

• ARC manages when to do this for you
• strong variables are Retained when assigned

• weak variables are not Retained on assignment
and are zeroed out when deallocated


Retain Cycle

• Two Objects Reference Each Other
• Their retain counts can never reach 0
• Set one of the references to weak to
prevent one of the objects from retaining
the other and causing a cycle


So there you have it
Objective-C thrown at you


Useful References
• Programming with Objective-C
http://developer.apple.com/library/ios/#documentation/cocoa/conceptual/
ProgrammingWithObjectiveC/Introduction/Introduction.html
http://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/
ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf

• Objective-C Cheat Sheet and Quick Reference
http://cdn5.raywenderlich.com/downloads/RW-Objective-C-Cheatsheet-v1_2.pdf

• Coding Guidelines for Cocoa
http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CodingGuidelines/
CodingGuidelines.html
http://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CodingGuidelines/
CodingGuidelines.pdf

• Ry’s Objective-C Tutorial
http://rypress.com/tutorials/objective-c/index.html


Objective-C Beginner's Dive: A Quick Introduction

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (12)

Similaire à Objective-C Beginner's Dive: A Quick Introduction

Similaire à Objective-C Beginner's Dive: A Quick Introduction (20)

Objective-C Beginner's Dive: A Quick Introduction