Session 4 - Object oriented programming with Objective-C (part 2)

Object Oriented Programming with
Objective-C (Part 2)
These are conﬁdential sessions - please refrain from streaming, blogging, or taking pictures
Session 4
Vu Tran Lam
IAD-2013

• Customizing existing classes by categories and extensions
• Working with protocols
• Working with blocks
Today’s Topics

• Categories add methods to existing classes
• Class extensions extend the internal implementation
Customizing Existing Classes

• Categories are a way to split a single class definition into multiple
files. Their goal is to ease the burden of maintaining large code
bases by modularizing a class. This prevents your source code
from becoming monolithic 10000+ line files that are impossible to
navigate and makes it easy to assign specific, well-defined portions
of a class to individual developers.
Categories

• Before we can start experimenting with categories, we need a base
class to work off of. Create or change your existing Car interface to
the following:
// Car.h
!
#import <Foundation/Foundation.h>
!
@interface Car : NSObject
!
@property (copy) NSString *model;
@property (readonly) double odometer;
!
- (void)startEngine;
- (void)drive;
- (void)turnLeft;
- (void)turnRight;
!
@end
Setting Up

• The corresponding implementation just outputs some descriptive
messages so we can see when different methods get called:
// Car.m
!
#import "Car.h"
!
@implementation Car
!
@synthesize model = _model;
!
- (void)startEngine {
NSLog(@"Starting the %@'s engine", _model);
}
- (void)drive {
NSLog(@"The %@ is now driving", _model);
}
- (void)turnLeft {
NSLog(@"The %@ is turning left", _model);
}
- (void)turnRight {
NSLog(@"The %@ is turning right", _model);
}
!
@end
Setting Up

• Categories work just like normal class definitions in that they are
composed of an interface and an implementation. To add a new
category to your Xcode project, create a new file and choose the
Objective-C category template under iOS > Cocoa Touch. Use
Maintenance for the Category field and Car for Category on.
Creating Categories

• As you can see in Car+Maintenance.h, a category interface looks
exactly like a normal interface, except the class name is followed by
the category name in parentheses. Let’s go ahead and add a few
methods to the category:
// Car+Maintenance.h
!
#import "Car.h"
!
@interface Car (Maintenance)
!
- (BOOL)needsOilChange;
- (void)changeOil;
- (void)rotateTires;
- (void)jumpBatteryUsingCar:(Car *)anotherCar;
!
@end
Creating Categories

• At runtime, these methods become part of the Car class. Even
though they’re declared in a different ﬁle, you will be able to access
them as if they were deﬁned in the original Car.h.
• Of course, you have to implement the category interface for the
above methods to actually do anything. Again, a category
implementation looks almost exactly like a standard
implementation, except the category name appears in parentheses
after the class name:
Creating Categories

// Car+Maintenance.m
!
#import "Car+Maintenance.h"
!
@implementation Car (Maintenance)
!
- (BOOL)needsOilChange {
return YES;
}
- (void)changeOil {
NSLog(@"Changing oil for the %@", [self model]);
}
- (void)rotateTires {
NSLog(@"Rotating tires for the %@", [self model]);
}
- (void)jumpBatteryUsingCar:(Car *)anotherCar {
NSLog(@"Jumped the %@ with a %@", [self model], [anotherCar model]);
}
!
@end
Creating Categories

• It’s important to note that a category can also be used to override
existing methods in the base class (e.g., the Car class’s drive
method), but you should never do this.
• The problem is that categories are a ﬂat organizational structure. If
you override an existing method in Car+Maintenance.m, and then
decide you want to change its behavior again with another
category, there is no way for Objective-C to know which
implementation to use. Subclassing is almost always a better
option in such a situation.
Creating Categories

• Any ﬁles that use an API deﬁned in a category need to import that category
header just like a normal class interface. After importing Car+Maintenance.h,
all of its methods will be available directly through the Car class:
// main.m
#import "Car.h"
#import "Car+Maintenance.h"
!
int main(int argc, const char * argv[]) {
@autoreleasepool {
Car *porsche = [[Car alloc] init];
porsche.model = @"Porsche 911 Turbo";
Car *ford = [[Car alloc] init];
ford.model = @"Ford F-150";
// "Standard" functionality from Car.h
[porsche startEngine];
[porsche drive];
[porsche turnLeft];
[porsche turnRight];
// Additional methods from Car+Maintenance.h
if ([porsche needsOilChange]) {
[porsche changeOil];
}
[porsche rotateTires];
[porsche jumpBatteryUsingCar:ford];
}
return 0;
}
Using Categories

• But, categories aren’t just for spreading a class definition over
several files. They are a powerful organizational tool that allow
arbitrary files to “opt-in” to a portion of an API by simply importing
the category. To everybody else, that API remains hidden.
• Recall from the Methods module that protected methods don’t
actually exist in Objective-C; however, the opt-in behavior of
categories can be used to emulate protected access modifiers.
• The idea is to define a “protected” API in a dedicated category, and
only import it into subclass implementations. This makes the
protected methods available to subclasses, but keeps them hidden
from other aspects of the application. For example:
“Protected” Methods

// Car+Protected.h
!
#import "Car.h"
!
@interface Car (Protected)
!
- (void)prepareToDrive;
!
@end
!
!
// Car+Protected.m
!
#import "Car+Protected.h"
!
@implementation Car (Protected)
!
- (void)prepareToDrive {
NSLog(@"Doing some internal work to get the %@ ready to drive",
[self model]);
}
!
@end

• The Protected category shown above deﬁnes a single method for
internal use by Car and its subclasses. To see this in action, let’s
modify Car.m’s drive method to use the protected prepareToDrive
method:
• After the interface has been imported with the #import directive,
you can instantiate objects with the alloc/init pattern shown above.
As you can see, instantiation is a two-step process: ﬁrst you must
allocate some memory for the object by calling the alloc method,
then you need to initialize it so it’s ready to use. You should never
use an uninitialized object.
• To call a method on an Objective-C object, you place the instance
and the method in square brackets, separated by a space:
[toyota setModel:@"Toyota Corolla"]

• The Protected category shown above deﬁnes a single method for
internal use by Car and its subclasses. To see this in action, let’s modify
Car.m’s drive method to use the protected prepareToDrive method:
// Car.m
#import "Car.h"
!
@implementation Car
!
!
…
!
- (void)drive
{
[self prepareToDrive];
NSLog(@"The %@ is now driving", _model);
}
!
…
@end

• Next, let’s take a look at how this protected method works by
creating a subclass called Coupe. There’s nothing special about the
interface, but notice how the implementation opts-in to the
protected API by importing Car+Protected.h. This makes it possible
to use the protected prepareToDrive method in the subclass. If
desired, you can also override the protected method by simply re-
deﬁning it in Coupe.m.

// Coupe.h
!
#import "Car.h"
!
@interface Coupe : Car
// Extra methods defined by the Coupe subclass
@end
!
!
// Coupe.m
!
#import "Coupe.h"
!
@implementation Coupe
- (void)startEngine
{
[super startEngine];
// Call the protected method here instead of in drive
[self prepareToDrive];
}
!
- (void)drive
{
NSLog(@"VROOOOOOM!");
}
@end

• To enforce the protected status of the methods in Car+Protected.h,
it should only be made available to subclass implementations—do
not import it into other ﬁles. In the following main.m, you can see
the protected prepareToDrive method called by [ford drive] and
[porsche startEngine], but the compiler will complain if you try to
call it directly.

// main.m
!
#import "Car.h"
#import "Coupe.h"
!
int main(int argc, const char * argv[])
{
@autoreleasepool
{
Car *ford = [[Car alloc] init];
ford.model = @"Ford F-150";
[ford startEngine];
[ford drive]; // Calls the protected method
Car *porsche = [[Coupe alloc] init];
porsche.model = @"Porsche 911 Turbo";
[porsche startEngine]; // Calls the protected method
[porsche drive];
// "Protected" methods have not been imported, so this will not work
//[porsche prepareToDrive];
SEL protectedMethod = @selector(prepareToDrive);
if ([porsche respondsToSelector:protectedMethod])
{
// This will work
[porsche performSelector:protectedMethod];
}
}
return 0;
}

• Notice that you can access prepareToDrive dynamically through
performSelector:. Once again, all methods in Objective-C are
public, and there is no way to truly hide them from client code.
Categories are merely a convention-based way to control which
parts of an API are visible to which ﬁles.

// Car.m
!
#import "Car.h"
!
// The class extension
@interface Car()
!
- (BOOL)engineIsWorking;
!
@end
!
@implementation Car
!
!
- (BOOL)engineIsWorking {
// In the real world, this would probably return a useful value
return YES;
}
if ([self engineIsWorking]) {
}
}
…
@end

• Extensions are similar to categories in that they let you add methods
to a class outside of the main interface file. But, in contrast to
categories, an extension’s API must be implemented in the main
implementation file—it cannot be implemented in a category.
• Remember that private methods can be emulated by adding them to
the implementation but not the interface. This works when you have
only a few private methods, but can become unwieldy for larger
classes. Extensions solve this problem by letting you declare a formal
private API.
• For example, if you wanted to formally add a private engineIsWorking
method to the Car class defined above, you could include an
extension in Car.m. The compiler complains if the method isn’t
defined in the main @implementation block, but since it’s declared in
Car.m instead of Car.h, it remains a private method. The extension
syntax looks like an empty category:
Extensions

• In addition to declaring formal private API’s, extensions can be used
to re-declare properties from the public interface. This is often used
to make properties internally behave as read-write properties while
remaining read-only to other objects.
// Car.h
#import “Person.h"
!
!
@property (readonly) Person *driver;
@property (copy) NSString *model;
@property (readwrite) double odometer;
!
…
!
- (id)initWithDriver:(Person *)driver;
!
@end
Extensions

// Car.m
#import "Car.h"
!
// The class extension
@interface Car ()
// Override the property and method inside of a class extension
@property (strong, readwrite) Person *driver;
@end
!
// The main implementation
@implementation Car
…
- (id)initWithDriver:(Person *)driver {
self = [super init];
if (self) {
// This will work because of the extension
[self setDriver:driver];
}
return self;
}
- (BOOL)engineIsWorking {
// In the real world, this would probably return a useful value
return YES;
}
// This will work because of the extension
if ([self engineIsWorking]) {
}
}
…
@end
Extensions

// Person.h
!
!
@interface Person : NSObject
!
@property (copy) NSString* name;
!
- (void)sayHello;
- (void)sayGoodbye;
!
@end
Extensions

// Person.m
!
#import "Person.h"
!
@implementation Person
!
@synthesize name = _name;
!
- (void)sayHello
{
NSLog(@"Hello, says %@.", _name);
}
!
- (void)sayGoodbye
{
NSLog(@"Goodbye, says %@.", _name);
}
!
@end
Extensions

// main.m
!
#import "Person.h"
#import "Car.h"
!
{
@autoreleasepool
{
Person *steve = [[Person alloc] init];
steve.name = @"Steve Jobs";
Car *bmwX5 = [[Car alloc] initWithDriver:steve];
NSLog(@"%@", [bmwX5 driver].name);
Person *bill = [[Person alloc] init];
bill.name = @"Bill Gates";
// This will not work because the property is still read-only.
// [bmwX5 setDriver:bill];
}
return 0;
}
Extensions

• We can then assign values to [self setDriver:driver] inside of the
implementation, but trying to do so outside of Car.m will result in a
compiler error.
• Again, re-declaring properties as read-write and creating formal
private API’s isn’t all that useful for small classes. Their real utility
comes into play when you need to organize larger frameworks.
• Extensions used to see much more action before Xcode 4.3, back
when private methods had to be declared before they were used.
This was inconvenient for many developers, and extensions
provided a workaround by acting as forward-declarations of private
methods. So, even if you don’t use the above pattern in your own
projects, you’re likely to encounter it at some point in your
Objective-C career.
Extensions

• A protocol is a group of related properties and methods that can be
implemented by any class. They are more ﬂexible than a normal
class interface, since they let you reuse a single API declaration in
completely unrelated classes. This makes it possible to represent
horizontal relationships on top of an existing class hierarchy.
Protocols

• Like class interfaces, protocols typically reside in a .h ﬁle. To add a
protocol to your Xcode project, navigate to File > New> File… or use
the Cmd+N shortcut. Select Objective-C protocol under the
iOS > Cocoa Touch category.
Creating Protocols

• Our protocol will capture the necessary behaviors of a street-legal
vehicle. Deﬁning these characteristics in a protocol lets you apply
them to arbitrary objects instead of forcing them to inherit from the
same abstract superclass. A simple version of the StreetLegal
protocol might look something like the following:
!
!
@protocol StreetLegal <NSObject>
!
- (void)signalStop;
- (void)signalLeftTurn;
- (void)signalRightTurn;
!
@end
Creating Protocols

• The above API can be adopted by a class by adding it in angled
brackets after the class/superclass name. Create a new classed
called Bicycle and change its header to the following. Note that you
need to import the protocol before you can use it.
// Bicycle.h
!
#import "StreetLegal.h"
!
@interface Bicycle : NSObject<StreetLegal>
!
- (void)startPedaling;
- (void)removeFrontWheel;
- (void)lockToStructure:(id)theStructure;
!
@end
Adopting Protocols

• Adopting the protocol is like adding all of the methods in StreetLegal.h
to Bicycle.h. This would work the exact same way even if Bicycle
inherited from a different superclass. Multiple protocols can be adopted
by separating them with commas (e.g., <StreetLegal,
SomeOtherProtocol>).
• There’s nothing special about the Bicycle implementation—it just has to
make sure all of the methods declared by Bicycle.h and StreetLegal.h
are implemented:
// Bicycle.h
!
!
@interface Bicycle : NSObject<StreetLegal>
!
- (void)startPedaling;
- (void)removeFrontWheel;
- (void)lockToStructure:(id)theStructure;
!
@end
Adopting Protocols

// Bicycle.m
!
#import "Bicycle.h"
!
@implementation Bicycle
!
- (void)signalStop {
NSLog(@"Bending left arm downwards");
}
- (void)signalLeftTurn {
NSLog(@"Extending left arm outwards");
}
- (void)signalRightTurn {
NSLog(@"Bending left arm upwards");
}
- (void)startPedaling {
NSLog(@"Here we go!");
}
- (void)removeFrontWheel {
NSLog(@"Front wheel is off."
"Should probably replace that before pedaling...");
}
- (void)lockToStructure:(id)theStructure {
NSLog(@"Locked to structure. Don't forget the combination!");
}
!
@end
Adopting Protocols

• Now, when you use the Bicycle class, you can assume it responds
to the API deﬁned by the protocol. It’s as though signalStop,
signalLeftTurn, and signalRightTurn were declared in Bicycle.h:
// main.m
!
#import "Bicycle.h"
!
{
@autoreleasepool
{
Bicycle *bike = [[Bicycle alloc] init];
[bike startPedaling];
[bike signalLeftTurn];
[bike signalStop];
[bike lockToStructure:nil];
}
return 0;
}
Adopting Protocols

• Just like classes, protocols can be used to type check variables. To
make sure an object adopts a protocol, put the protocol name after the
data type in the variable declaration, as shown below. The next code
snippet also assumes that you have created a Car class that adopts
the StreetLegal protocol:
// main.m
!
#import "Bicycle.h"
#import "Car.h"
!
{
@autoreleasepool
{
id <StreetLegal> mysteryVehicle = [[Car alloc] init];
[mysteryVehicle signalLeftTurn];
mysteryVehicle = [[Bicycle alloc] init];
}
return 0;
}
Type Checking With Protocols

• It doesn’t matter if Car and Bicycle inherit from the same superclass—
the fact that they both adopt the StreetLegal protocol lets us store
either of them in a variable declared with id <StreetLegal>. This is an
example of how protocols can capture common functionality between
unrelated classes.
• Objects can also be checked against a protocol using the
conformsToProtocol: method deﬁned by the NSObject protocol. It
takes a protocol object as an argument, which can be obtained via the
@protocol() directive. This works much like the @selector() directive,
but you pass the protocol name instead of a method name, like so:
// main.m
...
mysteryVehicle = [[Bicycle alloc] init];
if ([mysteryVehicle conformsToProtocol:@protocol(StreetLegal)]) {
[mysteryVehicle signalStop];
[mysteryVehicle signalRightTurn];
}

• Using protocols in this manner is like saying, “Make sure this object
has this particular set of functionality.” This is a very powerful tool
for dynamic typing, as it lets you use a well-deﬁned API without
worrying about what kind of object you’re dealing with.

• A more realistic use case can be seen in your everyday iOS
application development. The entry point into any iOS app is an
“application delegate” object that handles the major events in a
program’s life cycle. Instead of forcing the delegate to inherit from
any particular superclass, the UIKit Framework just makes you
adopt a protocol:
@interface FBAppDelegate : UIResponder <UIApplicationDelegate>
Protocols In The Real World

• Blocks are Objective-C’s anonymous functions. They let you pass
arbitrary statements between objects as you would data, which is
often more intuitive than referencing functions deﬁned elsewhere. In
addition, blocks are implemented as closures, making it trivial to
capture the surrounding state.
Blocks

• Blocks use all the same mechanics as normal functions. You can
declare a block variable just like a function, deﬁne the block as though
you would implement a function, and then call the block as a function:
!
{
@autoreleasepool
{
// Declare the block variable
double (^distanceFromRateAndTime)(double rate, double time);
// Create and assign the block
distanceFromRateAndTime = ^double(double rate, double time) {
return rate * time;
};
// Call the block
double dx = distanceFromRateAndTime(35, 1.5);
NSLog(@"A car driving 35 mph will travel " @"%.2f miles in 1.5 hours.", dx);
}
return 0;
}
Creating Blocks

• The caret (^) is used to mark the distanceFromRateAndTime
variable as a block. Like a function declaration, you need to include
the return type and parameter types so the compiler can enforce
type safety. The ^ behaves in a similar manner to the asterisk before
a pointer (e.g., int *aPointer) in that it is only required when declaring
the block, after which you can use it like a normal variable.
• The block itself is essentially a function deﬁnition—without the
function name. The ^double(double rate, double time) signature
begins a block literal that returns a double and has two parameters
that are also doubles (the return type can be omitted if desired).
Arbitrary statements can go inside the curly braces ({}), just like a
normal function.
• After assigning the block literal to the distanceFromRateAndTime
variable, we can call that variable as though it were a function.
Creating Blocks

• If a block doesn’t take any parameters, you can omit the argument
list in its entirety. And again, specifying the return type of a block
literal is always optional, so you can shorten the notation to ^ { ... }:
// Declare parameterless block
double (^randomPercent)(void) = ^ {
return (double)arc4random() / 4294967295;
};
NSLog(@"Gas tank is %.1f%% full", randomPercent() * 100);
Parameterless Blocks

• The built-in arc4random() function returns a random 32-bit integer.
By dividing by the maximum possible value of arc4random()
(4294967295), we get a decimal value between 0 and 1.
• So far, it might seem like blocks are just a complicated way of
deﬁning functions. But, the fact that they’re implemented as
closures opens the door to exciting new programming
opportunities.
Parameterless Blocks

• Inside of a block, you have access to same data as in a normal
function: local variables, parameters passed to the block, and
global variables/functions. But, blocks are implemented as
closures, which means that you also have access to non-local
variables. Non-local variables are variables deﬁned in the block’s
enclosing lexical scope, but outside the block itself.
• For example, getFullCarName can reference the make variable
deﬁned before the block:
// Closures demo
// Access non-local variables
NSString *make = @"Honda";
NSString *(^getFullCarName)(NSString *) = ^(NSString *model)
{
return [make stringByAppendingFormat:@" %@", model];
};
NSLog(@"%@",getFullCarName(@"Accord")); // Honda Accord
Closures

• Non-local variables are copied and stored with the block as const
variables, which means they are read-only. Trying to assign a new
value to the make variable from inside the block will throw a
compiler error.
Closures

• The fact that non-local variables are copied as constants means that
a block doesn’t just have access to non-local variables—it creates a
snapshot of them. Non-local variables are frozen at whatever value
they contain when the block is deﬁned, and the block always uses
that value, even if the non-local variable changes later on in the
program. Watch what happens when we try to change the make
variable after creating the block:
// Closures demo
// Access non-local variables
NSString *make = @"Honda";
NSString *(^getFullCarName)(NSString *) = ^(NSString *model)
{
return [make stringByAppendingFormat:@" %@", model];
};
NSLog(@"%@",getFullCarName(@"Accord")); // Honda Accord
!
// Try changing the non-local variable (it won't change the block)
make = @"Porsche";
NSLog(@"%@", getFullCarName(@"911 Turbo")); // Honda 911 Turbo
Closures

• Closures are an incredibly convenient way to work with the
surrounding state, as it eliminates the need to pass in extra values
as parameters—you simply use non-local variables as if they were
deﬁned in the block itself.
Closures

• Freezing non-local variables as constant values is a safe default
behavior in that it prevents you from accidentally changing them
from within the block; however, there are occasions when this is
desirable. You can override the const copy behavior by declaring a
non-local variable with the __block storage modiﬁer:
// Declare mutable non-local variable
__block NSString *make = @"Honda";
Mutable Non-Local Variables

• This tells the block to capture the variable by reference, creating a
direct link between the make variable outside the block and the one
inside the block. You can now assign a new value to make from
outside the block, and it will be reﬂected in the block, and vice versa.
!

• Like static local variables in normal functions, the __block modiﬁer
serves as a “memory” between multiple calls to a block. This makes
it possible to use blocks as generators. For example, the following
snippet creates a block that “remembers” the value of i over
subsequent invocations.
// Use mutable non-local variable
__block int i = 0;
int (^count)(void) = ^ {
i += 1;
return i;
};
NSLog(@"%d", count()); // 1

• Storing blocks in variables is occasionally useful, but in the real
world, they’re more likely to be used as method parameters. They
solve the same problem as function pointers, but the fact that they
can be deﬁned inline makes the resulting code much easier to read.
• For example, the following Car interface declares a method that
tallies the distance traveled by the car. Instead of forcing the caller
to pass a constant speed, it accepts a block that deﬁnes the car’s
speed as a function of time.
Blocks as Method Parameters

• The data type for the block is double (^)(double time), which states
that whatever block the caller passes to the method should return a
double and accept a single double parameter. Note that this is
almost the exact same syntax as the block variable declaration
discussed at the beginning of this module, but without the variable
name.
• The implementation can then call the block via speedFunction. The
following example uses a naïve right-handed Riemann sum to
approximate the distance traveled over duration. The steps
argument is used to let the caller determine the precision of the
estimate.

// Car.h
!
!
!
@property double odometer;
!
- (void)driveForDuration:(double)duration
withVariableSpeed:(double (^)(double time))speedFunction
steps:(int)numSteps;
!
@end

• As you can see in the main() function included below, block literals
can be deﬁned within a method invocation. While it might take a
second to parse the syntax, this is still much more intuitive than
creating a dedicated top-level function to deﬁne the
withVariableSpeed parameter.
// Car.m
#import "Car.h"
!
@implementation Car
!
@synthesize odometer = _odometer;
!
withVariableSpeed:(double (^)(double time))speedFunction
steps:(int)numSteps {
double dt = duration / numSteps;
for (int i=1; i<=numSteps; i++) {
_odometer += speedFunction(i*dt) * dt;
}
}
!
@end

// main.m
!
#import "Car.h"
!
int main(int argc, const char * argv[]) {
@autoreleasepool {
Car *theCar = [[Car alloc] init];
// Drive for awhile with constant speed of 5.0 m/s
[theCar driveForDuration:10.0
withVariableSpeed:^(double time) {
return 5.0;
} steps:100];
NSLog(@"The car has now driven %.2f meters", theCar.odometer);
// Start accelerating at a rate of 1.0 m/s^2
[theCar driveForDuration:10.0
withVariableSpeed:^(double time) {
return time + 5.0;
} steps:100];
NSLog(@"The car has now driven %.2f meters", theCar.odometer);
}
return 0;
}

• This is a simple example of the versatility of blocks, but the
standard frameworks are chock-full of other use cases. NSArray
lets you sort elements with a block via the
sortedArrayUsingComparator: method, and UIView uses a block to
deﬁne the ﬁnal state of an animation via the
animateWithDuration:animations: method. Blocks are also a
powerful tool for concurrent programming.

• Since the syntax for block data types can quickly clutter up your
method declarations, it’s often useful to typedef common block
signatures. For instance, the following code creates a new type
called SpeedFunction that we can use as a more semantic data
type for the withVariableSpeed argument.
Deﬁning Block Types

• You can also create types for blocks—doing so is generally
considered to be best practice when you use a block with a given
signature in multiple places:
// Car.h
!
!
// Define a new type for block
typedef double(^SpeedFunction)(double);
!
!
@property double odometer;
// Use SpeedFunction block
withVariableSpeed:(SpeedFunction)speedFunction
steps:(int)numSteps;
@end
• Many of the standard Objective-C frameworks also use this
technique (e.g., NSComparator).
Deﬁning Block Types

Documentation
Programming with Objective-C
https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/
Introduction/Introduction.html
Blocks Programming Topics
https://developer.apple.com/library/ios/documentation/cocoa/Conceptual/Blocks/Articles/00_Introduction.html

many thanks
to
lamvt@fpt.com.vn
please
say
Stanford University
https://developer.apple.com
Developer Center
http://www.stanford.edu/class/cs193p
xin
chào

Session 4 - Object oriented programming with Objective-C (part 2)

Recommended

More Related Content

Viewers also liked (20)

Similar to Session 4 - Object oriented programming with Objective-C (part 2) (20)

Recently uploaded (20)

Session 4 - Object oriented programming with Objective-C (part 2)