2013-08-13 12:32:20 +00:00
---
2013-08-13 12:38:39 +00:00
language: Objective-C
contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"]
2014-01-07 02:21:29 +00:00
- ["Levi Bostian", "https://github.com/levibostian"]
2013-08-13 12:38:39 +00:00
filename: LearnObjectiveC.m
2013-08-13 12:32:20 +00:00
---
2013-08-13 12:45:49 +00:00
Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch.
It is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language.
2013-08-13 12:32:20 +00:00
2014-01-11 18:27:47 +00:00
```objective-c
2013-08-13 12:32:20 +00:00
// Single-line comments start with //
/*
2014-01-11 18:51:41 +00:00
Multi-line comments look like this
2013-08-13 12:32:20 +00:00
*/
2013-08-13 12:56:09 +00:00
// Imports the Foundation headers with #import
2014-01-11 18:27:47 +00:00
// Use < > to import global files (in general frameworks)
// Use "" to import local files (from project)
2013-08-13 12:56:09 +00:00
#import <Foundation/Foundation.h>
2013-08-13 14:50:22 +00:00
#import "MyClass.h"
2013-08-13 12:56:09 +00:00
2014-01-11 18:27:47 +00:00
// If you enable modules for iOS >= 7.0 or OS X >= 10.9 projects in
// Xcode 5 you can import frameworks like that:
@import Foundation;
2013-08-13 12:56:09 +00:00
// Your program's entry point is a function called
2014-01-11 18:51:41 +00:00
// main with an integer return type
2013-08-13 12:56:09 +00:00
int main (int argc, const char * argv[])
{
2013-08-13 14:04:20 +00:00
// Create an autorelease pool to manage the memory into the program
2013-08-13 12:56:09 +00:00
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
2014-01-02 01:01:50 +00:00
// If using automatic reference counting (ARC), use @autoreleasepool instead:
@autoreleasepool {
2013-08-13 13:25:47 +00:00
// Use NSLog to print lines to the console
2013-08-13 13:50:09 +00:00
NSLog(@"Hello World!"); // Print the string "Hello World!"
2013-08-13 12:56:09 +00:00
2013-08-13 14:04:20 +00:00
///////////////////////////////////////
// Types & Variables
///////////////////////////////////////
// Primitive declarations
2013-08-13 14:09:38 +00:00
int myPrimitive1 = 1;
long myPrimitive2 = 234554664565;
2013-08-13 14:04:20 +00:00
// Object declarations
// Put the * in front of the variable names for strongly-typed object declarations
2013-08-13 14:09:38 +00:00
MyClass *myObject1 = nil; // Strong typing
id myObject2 = nil; // Weak typing
2013-08-13 13:50:09 +00:00
// %@ is an object
2013-08-13 14:07:58 +00:00
// 'description' is a convention to display the value of the Objects
NSLog(@"%@ and %@", myObject1, [myObject2 description]); // Print "(null) and (null)"
2013-08-13 14:04:20 +00:00
// String
NSString *worldString = @"World";
2013-12-23 08:26:11 +00:00
NSLog(@"Hello %@!", worldString); // prints => "Hello World!"
2014-01-11 18:51:41 +00:00
// NSMutableString is a mutable version of the NSString object
2013-12-22 16:37:02 +00:00
NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
[mutableString appendString:@" World!"];
NSLog(@"%@", mutableString); // prints => "Hello World!"
2013-08-13 13:50:09 +00:00
// Character literals
2013-08-13 13:52:11 +00:00
NSNumber *theLetterZNumber = @'Z';
2013-12-22 16:37:02 +00:00
char theLetterZ = [theLetterZNumber charValue]; // or 'Z'
2013-08-13 13:52:11 +00:00
NSLog(@"%c", theLetterZ);
2013-08-13 12:56:09 +00:00
2013-08-13 13:50:09 +00:00
// Integral literals
NSNumber *fortyTwoNumber = @42 ;
2013-12-22 16:37:02 +00:00
int fortyTwo = [fortyTwoNumber intValue]; // or 42
2013-08-13 13:50:09 +00:00
NSLog(@"%i", fortyTwo);
NSNumber *fortyTwoUnsignedNumber = @42U ;
2013-12-22 16:37:02 +00:00
unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // or 42
2013-08-13 13:50:09 +00:00
NSLog(@"%u", fortyTwoUnsigned);
2013-08-13 14:04:20 +00:00
NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
2013-12-22 16:37:02 +00:00
short fortyTwoShort = [fortyTwoShortNumber shortValue]; // or 42
2013-08-13 14:04:20 +00:00
NSLog(@"%hi", fortyTwoShort);
2013-12-22 16:37:02 +00:00
2014-01-07 01:16:47 +00:00
NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41];
unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // or 41
NSLog(@"%u", fortyOneUnsigned);
2013-08-13 14:04:20 +00:00
2013-08-13 13:50:09 +00:00
NSNumber *fortyTwoLongNumber = @42L ;
2013-12-22 16:37:02 +00:00
long fortyTwoLong = [fortyTwoLongNumber longValue]; // or 42
2013-08-13 13:50:09 +00:00
NSLog(@"%li", fortyTwoLong);
2014-01-07 01:16:47 +00:00
NSNumber *fiftyThreeLongNumber = @53L ;
unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // or 53
2013-12-22 16:37:02 +00:00
NSLog(@"%lu", fiftyThreeUnsigned);
2013-08-13 13:50:09 +00:00
// Floating point literals
NSNumber *piFloatNumber = @3 .141592654F;
2013-12-22 16:37:02 +00:00
float piFloat = [piFloatNumber floatValue]; // or 3.141592654f
NSLog(@"%f", piFloat); // prints => 3.141592654
NSLog(@"%5.2f", piFloat); // prints => " 3.14"
2013-08-13 13:50:09 +00:00
NSNumber *piDoubleNumber = @3 .1415926535;
2013-12-27 04:26:34 +00:00
double piDouble = [piDoubleNumber doubleValue]; // or 3.1415926535
2013-08-13 13:50:09 +00:00
NSLog(@"%f", piDouble);
2013-12-22 16:37:02 +00:00
NSLog(@"%4.2f", piDouble); // prints => "3.14"
2013-12-23 08:26:11 +00:00
// NSDecimalNumber is a fixed-point class that's more precise then float or double
2013-12-22 16:37:02 +00:00
NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
2013-12-23 08:26:11 +00:00
// NSDecimalNumber isn't able to use standard +, -, *, / operators so it provides its own:
[oneDecNum decimalNumberByAdding:twoDecNum];
2013-12-22 16:37:02 +00:00
[oneDecNum decimalNumberBySubtracting:twoDecNum];
[oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
[oneDecNum decimalNumberByDividingBy:twoDecNum];
2014-01-11 18:51:41 +00:00
NSLog(@"%@", oneDecNum); // prints => 10.99 as NSDecimalNumber is immutable
2013-08-13 12:32:20 +00:00
2013-08-13 13:25:47 +00:00
// BOOL literals
2013-08-13 13:50:09 +00:00
NSNumber *yesNumber = @YES ;
NSNumber *noNumber = @NO ;
2013-12-22 16:37:02 +00:00
// or
BOOL yesBool = YES;
2013-12-27 04:26:34 +00:00
BOOL noBool = NO;
2013-12-22 16:37:02 +00:00
NSLog(@"%i", yesBool); // prints => 1
2013-08-13 13:50:09 +00:00
// Array object
2014-01-11 18:51:41 +00:00
// May contain different data types, but must be an Objective-C object
2013-08-13 13:50:09 +00:00
NSArray *anArray = @[@1, @2 , @3 , @4 ];
NSNumber *thirdNumber = anArray[2];
2013-08-17 22:06:23 +00:00
NSLog(@"Third number = %@", thirdNumber); // Print "Third number = 3"
2013-12-22 16:37:02 +00:00
// NSMutableArray is mutable version of NSArray allowing to change items in array
2014-01-11 18:51:41 +00:00
// and extend or shrink array object. Convenient, but not as efficient as NSArray
2013-12-22 16:37:02 +00:00
NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
[mutableArray addObject:@"Hello"];
[mutableArray addObject:@"World"];
[mutableArray removeObjectAtIndex:0];
NSLog(@"%@", [mutableArray objectAtIndex:0]); // prints => "World"
2013-08-13 13:50:09 +00:00
// Dictionary object
NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
NSObject *valueObject = aDictionary[@"A Key"];
NSLog(@"Object = %@", valueObject); // Print "Object = (null)"
2014-01-11 18:51:41 +00:00
// NSMutableDictionary also available as a mutable dictionary object
2013-12-26 18:20:16 +00:00
NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
[mutableDictionary setObject:@"value1" forKey:@"key1"];
[mutableDictionary setObject:@"value2" forKey:@"key2"];
[mutableDictionary removeObjectForKey:@"key1"];
2013-08-13 12:32:20 +00:00
2013-12-22 16:37:02 +00:00
// Set object
NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
2013-12-23 08:26:11 +00:00
NSLog(@"%@", set); // prints => {(Hello, World)} (may be in different order)
2014-01-11 18:51:41 +00:00
// NSMutableSet also available as a mutable set object
2013-12-26 18:20:16 +00:00
NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
[mutableSet addObject:@"Hello"];
[mutableSet addObject:@"Hello"];
2013-12-27 04:26:34 +00:00
NSLog(@"%@", mutableSet); // prints => {(Hello)}
2013-12-22 16:37:02 +00:00
2013-08-13 14:04:20 +00:00
///////////////////////////////////////
// Operators
///////////////////////////////////////
2013-08-13 14:22:40 +00:00
// The operators works like in the C language
// For example:
2013-08-13 14:32:16 +00:00
2 + 5; // => 7
4.2f + 5.1f; // => 9.3f
2013-08-13 14:22:40 +00:00
3 == 2; // => 0 (NO)
3 != 2; // => 1 (YES)
1 & & 1; // => 1 (Logical and)
0 || 1; // => 1 (Logical or)
~0x0F; // => 0xF0 (bitwise negation)
0x0F & 0xF0; // => 0x00 (bitwise AND)
0x01 < < 1 ; / / = > 0x02 (bitwise left shift (by 1))
///////////////////////////////////////
// Control Structures
///////////////////////////////////////
// If-Else statement
if (NO)
{
NSLog(@"I am never run");
} else if (0)
{
NSLog(@"I am also never run");
} else
{
NSLog(@"I print");
}
// Switch statement
2013-08-13 14:32:16 +00:00
switch (2)
{
2013-08-13 14:22:40 +00:00
case 0:
{
NSLog(@"I am never run");
} break;
case 1:
{
NSLog(@"I am also never run");
} break;
default:
{
NSLog(@"I print");
} break;
}
2013-08-13 14:32:16 +00:00
// While loops statements
2013-08-13 14:22:40 +00:00
int ii = 0;
while (ii < 4 )
{
2014-01-11 18:51:41 +00:00
NSLog(@"%d,", ii++); // ii++ increments ii in-place, after using its value
2013-08-13 14:32:16 +00:00
} // => prints "0,"
2013-08-13 14:34:12 +00:00
// "1,"
// "2,"
// "3,"
2013-08-13 14:22:40 +00:00
2013-08-13 14:32:16 +00:00
// For loops statements
2013-08-13 14:22:40 +00:00
int jj;
for (jj=0; jj < 4 ; jj + + )
{
2013-09-04 11:38:47 +00:00
NSLog(@"%d,", jj);
2013-08-13 14:32:16 +00:00
} // => prints "0,"
2013-08-13 14:34:12 +00:00
// "1,"
// "2,"
// "3,"
2013-08-13 14:22:40 +00:00
2013-08-13 14:32:16 +00:00
// Foreach statements
2013-08-13 14:22:40 +00:00
NSArray *values = @[@0, @1 , @2 , @3 ];
for (NSNumber *value in values)
{
NSLog(@"%@,", value);
2013-08-13 14:32:16 +00:00
} // => prints "0,"
2013-08-13 14:34:12 +00:00
// "1,"
// "2,"
// "3,"
2013-08-13 14:04:20 +00:00
2014-01-11 18:51:41 +00:00
// Object for loop statement. Can be used with any Objective-C object type
2013-12-23 08:26:11 +00:00
for (id item in values) {
NSLog(@"%@,", item);
} // => prints "0,"
// "1,"
// "2,"
// "3,"
2013-08-13 14:32:16 +00:00
// Try-Catch-Finally statements
@try
{
// Your statements here
2013-08-13 17:30:44 +00:00
@throw [NSException exceptionWithName:@"FileNotFoundException"
reason:@"File Not Found on System" userInfo:nil];
2013-08-13 14:32:16 +00:00
} @catch (NSException * e)
{
NSLog(@"Exception: %@", e);
} @finally
{
NSLog(@"Finally");
} // => prints "Exception: File Not Found on System"
2013-08-13 14:34:12 +00:00
// "Finally"
2013-08-13 14:32:16 +00:00
2013-08-13 14:49:23 +00:00
///////////////////////////////////////
// Objects
///////////////////////////////////////
2014-01-11 18:51:41 +00:00
// Create an object instance by allocating memory and initializing it
// An object is not fully functional until both steps have been completed
2013-08-13 14:49:23 +00:00
MyClass *myObject = [[MyClass alloc] init];
2013-08-13 17:30:44 +00:00
// The Objective-C model of object-oriented programming is based on message
2014-01-11 18:51:41 +00:00
// passing to object instances
// In Objective-C one does not simply call a method; one sends a message
2013-08-13 17:30:44 +00:00
[myObject instanceMethodWithParameter:@"Steve Jobs"];
2013-08-13 14:49:23 +00:00
2013-08-13 13:25:47 +00:00
// Clean up the memory you used into your program
[pool drain];
2014-01-02 01:01:50 +00:00
2014-01-11 18:51:41 +00:00
// End of @autoreleasepool
2014-01-02 01:01:50 +00:00
}
2013-08-13 13:25:47 +00:00
2013-08-13 14:04:20 +00:00
// End the program
2013-08-13 13:25:47 +00:00
return 0;
}
2013-08-13 12:32:20 +00:00
2013-08-13 13:25:47 +00:00
///////////////////////////////////////
// Classes And Functions
///////////////////////////////////////
2013-08-13 12:32:20 +00:00
2014-01-03 18:50:35 +00:00
// Declare your class in a header file (MyClass.h):
// Class declaration syntax:
2013-08-13 14:58:13 +00:00
// @interface ClassName : ParentClassName < ImplementedProtocols >
2013-08-13 14:46:16 +00:00
// {
2014-01-03 18:50:35 +00:00
// type name; < = variable declarations;
2013-08-13 14:46:16 +00:00
// }
2014-01-11 18:51:41 +00:00
// @property type name; < = property declarations
// -/+ (type) Method declarations; < = Method declarations
2013-08-13 14:46:16 +00:00
// @end
2014-01-07 14:41:07 +00:00
@interface MyClass : NSObject < MyProtocol > // NSObject is Objective-C's base object class.
2013-08-13 13:25:47 +00:00
{
2014-01-11 18:51:41 +00:00
// Instance variable declarations (can exist in either interface or implementation file)
2013-12-27 04:26:34 +00:00
int count; // Protected access by default.
2014-01-11 18:51:41 +00:00
@private id data; // Private access (More convenient to declare in implementation file)
2013-12-27 04:26:34 +00:00
NSString *name;
2013-08-13 12:32:20 +00:00
}
2014-01-11 18:51:41 +00:00
// Convenient notation for public access variables to auto generate a setter method
// By default, setter method name is 'set' followed by @property variable name
2014-01-08 19:03:31 +00:00
@property int propInt; // Setter method name = 'setPropInt'
2014-01-11 18:51:41 +00:00
@property (copy) id copyId; // (copy) => Copy the object during assignment
// (readonly) => Cannot set value outside @interface
@property (readonly) NSString *roString; // Use @synthesize in @implementation to create accessor
2013-12-27 04:26:34 +00:00
// You can customize the getter and setter names instead of using default 'set' name:
2014-01-03 18:50:35 +00:00
@property (getter=lengthGet, setter=lengthSet:) int length;
2013-08-13 14:46:16 +00:00
// Methods
+/- (return type)methodSignature:(Parameter Type *)parameterName;
2013-08-13 12:32:20 +00:00
2014-01-08 19:03:31 +00:00
// + for class methods:
2013-08-13 13:25:47 +00:00
+ (NSString *)classMethod;
2014-01-07 02:18:45 +00:00
+ (MyClass *)myClassFromHeight:(NSNumber * )defaultHeight;
2013-08-13 12:32:20 +00:00
2014-01-08 19:03:31 +00:00
// - for instance methods:
2013-09-04 11:56:58 +00:00
- (NSString *)instanceMethodWithParameter:(NSString * )string;
2013-08-13 14:46:16 +00:00
- (NSNumber *)methodAParameterAsString:(NSString* )string andAParameterAsNumber:(NSNumber *)number;
2013-08-13 17:30:44 +00:00
2014-01-07 02:18:45 +00:00
// Constructor methods with arguments:
- (id)initWithDistance:(int)defaultDistance;
2014-01-11 18:51:41 +00:00
// Objective-C method names are very descriptive. Always name methods according to their arguments
2014-01-07 02:18:45 +00:00
2014-01-11 18:51:41 +00:00
@end // States the end of the interface
2014-01-03 18:50:35 +00:00
// To access public variables from the implementation file, @property generates a setter method
// automatically. Method name is 'set' followed by @property variable name:
2014-01-11 18:51:41 +00:00
MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance
2014-01-03 18:50:35 +00:00
[myClass setCount:10];
2014-01-07 01:16:47 +00:00
NSLog(@"%d", [myClass count]); // prints => 10
2014-01-03 18:50:35 +00:00
// Or using the custom getter and setter method defined in @interface:
[myClass lengthSet:32];
NSLog(@"%i", [myClass lengthGet]); // prints => 32
// For convenience, you may use dot notation to set and access object instance variables:
myClass.count = 45;
NSLog(@"%i", myClass.count); // prints => 45
2014-01-08 19:03:31 +00:00
// Call class methods:
NSString *classMethodString = [MyClass classMethod];
MyClass *classFromName = [MyClass myClassFromName:@"Hello"];
// Call instance methods:
2014-01-11 18:51:41 +00:00
MyClass *myClass = [[MyClass alloc] init]; // Create MyClass object instance
2014-01-08 19:03:31 +00:00
NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"];
2014-01-11 18:51:41 +00:00
// Selectors
2014-01-08 19:03:31 +00:00
// Way to dynamically represent methods. Used to call methods of a class, pass methods
// through functions to tell other classes they should call it, and to save methods
2014-01-11 18:51:41 +00:00
// as a variable
// SEL is the data type. @selector () returns a selector from method name provided
2014-01-07 04:18:54 +00:00
// methodAParameterAsString:andAParameterAsNumber: is method name for method in MyClass
SEL selectorVar = @selector (methodAParameterAsString:andAParameterAsNumber:);
2014-01-11 18:51:41 +00:00
if ([myClass respondsToSelector:selectorVar]) { // Checks if class contains method
// Must put all method arguments into one object to send to performSelector function
2014-01-07 04:18:54 +00:00
NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4 , nil];
2014-01-11 18:51:41 +00:00
[myClass performSelector:selectorVar withObject:arguments]; // Calls the method
2014-01-07 04:18:54 +00:00
} else {
2014-01-11 18:51:41 +00:00
// NSStringFromSelector() returns a NSString of the method name of a given selector
2014-01-07 04:18:54 +00:00
NSLog(@"MyClass does not have method: %@", NSStringFromSelector(selectedVar));
}
2013-08-13 12:32:20 +00:00
2013-08-13 14:50:22 +00:00
// Implement the methods in an implementation (MyClass.m) file:
2013-12-27 04:26:34 +00:00
@implementation MyClass {
2014-01-11 18:51:41 +00:00
long distance; // Private access instance variable
2014-01-07 02:18:45 +00:00
NSNumber height;
2013-12-27 04:26:34 +00:00
}
2013-08-13 12:32:20 +00:00
2014-01-07 14:41:07 +00:00
// To access a public variable from the interface file, use '_' followed by variable name:
2014-01-11 18:51:41 +00:00
_count = 5; // References "int count" from MyClass interface
2014-01-03 18:50:35 +00:00
// Access variables defined in implementation file:
2014-01-11 18:51:41 +00:00
distance = 18; // References "long distance" from MyClass implementation
2014-01-07 04:18:54 +00:00
// To use @property variable in implementation, use @synthesize to create accessor variable:
2014-01-11 18:51:41 +00:00
@synthesize roString = _roString; // _roString available now in @implementation
2014-01-03 18:50:35 +00:00
2014-01-11 18:51:41 +00:00
// Called before calling any class methods or instantiating any objects
2014-01-07 02:18:45 +00:00
+ (void)initialize
{
if (self == [MyClass class]) {
distance = 0;
}
}
2014-01-11 18:51:41 +00:00
// Counterpart to initialize method. Called when an object's reference count is zero
2013-08-13 14:58:13 +00:00
- (void)dealloc
{
2014-01-07 02:18:45 +00:00
[height release]; // If not using ARC, make sure to release class variable objects
2014-01-11 18:51:41 +00:00
[super dealloc]; // and call parent class dealloc
2013-08-13 14:58:13 +00:00
}
2014-01-11 18:51:41 +00:00
// Constructors are a way of creating instances of a class
// This is a default constructor which is called when the object is initialized.
2013-08-13 14:46:16 +00:00
- (id)init
{
2014-01-11 18:51:41 +00:00
if ((self = [super init])) // 'super' used to access methods from parent class
2013-08-13 14:46:16 +00:00
{
2014-01-11 18:51:41 +00:00
self.count = 1; // 'self' used for object to call itself
2013-08-13 14:46:16 +00:00
}
return self;
}
2014-01-07 02:18:45 +00:00
// Can create constructors that contain arguments:
- (id)initWithDistance:(int)defaultDistance
{
distance = defaultDistance;
return self;
}
2013-08-13 14:46:16 +00:00
2013-08-13 13:25:47 +00:00
+ (NSString *)classMethod
{
2013-08-13 14:46:16 +00:00
return [[self alloc] init];
2013-08-13 12:32:20 +00:00
}
2014-01-07 02:18:45 +00:00
+ (MyClass *)myClassFromHeight:(NSNumber * )defaultHeight
{
height = defaultHeight;
return [[self alloc] init];
}
2013-09-04 11:56:58 +00:00
- (NSString *)instanceMethodWithParameter:(NSString * )string
2013-08-13 12:32:20 +00:00
{
2013-08-13 13:25:47 +00:00
return @"New string";
2013-08-13 12:32:20 +00:00
}
2013-08-13 13:25:47 +00:00
- (NSNumber *)methodAParameterAsString:(NSString* )string andAParameterAsNumber:(NSNumber *)number
2013-08-13 12:32:20 +00:00
{
2013-08-13 13:25:47 +00:00
return @42 ;
2013-08-13 12:32:20 +00:00
}
2013-08-13 13:25:47 +00:00
2014-01-11 18:51:41 +00:00
// To create a private method, create the method in the @implementation but not in the @interface
2014-01-07 02:18:45 +00:00
- (NSNumber *)secretPrivateMethod {
return @72 ;
}
2014-01-11 18:51:41 +00:00
[self secretPrivateMethod]; // Calls private method
2014-01-07 02:18:45 +00:00
2013-08-13 14:58:13 +00:00
// Methods declared into MyProtocol
- (void)myProtocolMethod
{
// statements
}
2014-01-11 18:51:41 +00:00
@end // States the end of the implementation
2013-08-13 12:32:20 +00:00
2014-01-09 03:27:42 +00:00
// Categories
// A category is a group of methods designed to extend a class. They allow you to add new methods
// to an existing class for organizational purposes. This is not to be mistaken with subclasses.
// Subclasses are meant to CHANGE functionality of an object while categories instead ADD
// functionality to an object.
// Categories allow you to:
// -- Add methods to an existing class for organizational purposes.
// -- Allow you to extend Objective-C object classes (ex: NSString) to add your own methods.
// -- Add ability to create protected and private methods to classes.
// NOTE: Do not override methods of the base class in a category even though you have the ability
// to. Overriding methods may cause compiler errors later between different categories and it
// ruins the purpose of categories to only ADD functionality. Subclass instead to override methods.
// Here is a simple Car base class.
@interface Car : NSObject
@property NSString *make;
@property NSString *color;
- (void)turnOn;
- (void)accelerate;
@end
// And the simple Car base class implementation:
#import "Car.h"
@implementation Car
@synthesize make = _make;
@synthesize color = _color;
- (void)turnOn {
NSLog(@"Car is on.");
}
- (void)accelerate {
NSLog(@"Accelerating.");
}
@end
// Now, if we wanted to create a Truck object, we would create a subclass of Car instead as it would
// be changing the functionality of the Car to behave like a truck. But lets say we want to just add
// functionality to this existing Car. A good example would be to clean the car. So we would create
// a category to add these cleaning methods:
// @interface filename: Car+Clean.h
#import "Car.h" // Make sure to import base class to extend.
@interface Car (Clean) // The category name is inside () following the name of the base class.
- (void)washWindows; // Names of the new methods we are adding to our Car object.
- (void)wax;
@end
// @implementation filename: Car+Clean.m
#import "Car+Clean.h"
@implementation Car (Clean)
- (void)washWindows {
NSLog(@"Windows washed.");
}
- (void)wax {
NSLog(@"Waxed.");
}
@end
// Any Car object instance has the ability to use a category. All they need to do is import it:
#import "Car+Clean.h" // Import as many different categories as you want to use.
#import "Car.h" // Also need to import base class to use it's original functionality.
int main(int argc, const char *argv[]) {
@autoreleasepool {
Car *mustang = [[Car alloc] init];
mustang.color = @"Red";
mustang.make = @"Ford";
[mustang turnOn]; // Use methods from base Car class.
[mustang washWindows]; // Use methods from Car's Clean category.
}
return 0;
}
// Protocols
// A protocol declares methods that can be implemented by any class.
// Protocols are not classes themselves. They simply define an interface
// that other objects are responsible for implementing.
2013-08-13 14:58:13 +00:00
@protocol MyProtocol
- (void)myProtocolMethod;
@end
2013-12-31 19:50:37 +00:00
///////////////////////////////////////
// Memory Management
///////////////////////////////////////
/*
For each object used in an application, memory must be allocated for that object. When the application
is done using that object, memory must be deallocated to ensure application efficiency.
Objective-C does not use garbage collection and instead uses reference counting. As long as
there is at least one reference to an object (also called "owning" an object), then the object
will be available to use (known as "ownership").
When an instance owns an object, its reference counter is increments by one. When the
object is released, the reference counter decrements by one. When reference count is zero,
the object is removed from memory.
With all object interactions, follow the pattern of:
(1) create the object, (2) use the object, (3) then free the object from memory.
*/
2014-01-11 18:51:41 +00:00
MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object
[classVar release]; // Decrements classVar's reference count
// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object
MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner
[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object
2013-12-31 19:50:37 +00:00
2014-01-11 18:51:41 +00:00
// @property can use 'retain' and 'assign' as well for small convenient definitions
@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference)
@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference)
2013-12-31 19:50:37 +00:00
2014-01-07 01:16:47 +00:00
// Automatic Reference Counting (ARC)
2013-12-31 20:04:07 +00:00
// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC,
2014-01-11 18:51:41 +00:00
// you must not use retain, relase, or autorelease
2014-01-07 01:16:47 +00:00
MyClass *arcMyClass = [[MyClass alloc] init];
// ... code using arcMyClass
// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC,
2014-01-11 18:51:41 +00:00
// there is no need. It will insert this release statement for you
2013-12-31 20:04:07 +00:00
2014-01-11 18:51:41 +00:00
// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'
2014-01-07 01:16:47 +00:00
@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count
2014-01-11 18:51:41 +00:00
// is set to zero, weakVar will automatically receive value of nil to avoid application crashing
@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use
2013-12-31 20:04:07 +00:00
// For regular variables (not @property declared variables), use the following:
2014-01-11 18:51:41 +00:00
__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope
__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil
__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released
2013-08-13 14:58:13 +00:00
2013-08-13 12:32:20 +00:00
```
## Further Reading
[Wikipedia Objective-C ](http://en.wikipedia.org/wiki/Objective-C )
2014-01-03 18:52:23 +00:00
[Programming with Objective-C. Apple PDF book ](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf )
2013-08-13 12:32:20 +00:00
[iOS For High School Students: Getting Started ](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started )