summaryrefslogtreecommitdiffhomepage
path: root/objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown
diff options
context:
space:
mode:
authorLevi Bostian <levi.bostian@gmail.com>2014-01-07 08:56:34 -0600
committerLevi Bostian <levi.bostian@gmail.com>2014-01-07 08:56:34 -0600
commit18b9cde0327b5384c4c9cd14106ddaa41b0f3673 (patch)
tree2e7b08f7536b88aa8aec20bc7e126f265fbcf77c /objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown
parentbcc8be737ad72d264ef3b6be459c3dc1137c588c (diff)
Remove unwanted Dropbox conflict file. Sorry.
Diffstat (limited to 'objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown')
-rw-r--r--objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown446
1 files changed, 0 insertions, 446 deletions
diff --git a/objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown b/objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown
deleted file mode 100644
index 490fefee..00000000
--- a/objective-c.html (levi-dell-banno-laptop's conflicted copy 2014-01-07).markdown
+++ /dev/null
@@ -1,446 +0,0 @@
----
-
-language: Objective-C
-contributors:
- - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- - ["Yannick Loriot", "https://github.com/YannickL"]
-filename: LearnObjectiveC.m
-
----
-
-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.
-
-```cpp
-// Single-line comments start with //
-
-/*
-Multi-line comments look like this.
-*/
-
-// Imports the Foundation headers with #import
-#import <Foundation/Foundation.h>
-#import "MyClass.h"
-
-// Your program's entry point is a function called
-// main with an integer return type.
-int main (int argc, const char * argv[])
-{
- // Create an autorelease pool to manage the memory into the program
- NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
- // If using automatic reference counting (ARC), use @autoreleasepool instead:
- @autoreleasepool {
-
- // Use NSLog to print lines to the console
- NSLog(@"Hello World!"); // Print the string "Hello World!"
-
- ///////////////////////////////////////
- // Types & Variables
- ///////////////////////////////////////
-
- // Primitive declarations
- int myPrimitive1 = 1;
- long myPrimitive2 = 234554664565;
-
- // Object declarations
- // Put the * in front of the variable names for strongly-typed object declarations
- MyClass *myObject1 = nil; // Strong typing
- id myObject2 = nil; // Weak typing
- // %@ is an object
- // 'description' is a convention to display the value of the Objects
- NSLog(@"%@ and %@", myObject1, [myObject2 description]); // Print "(null) and (null)"
-
- // String
- NSString *worldString = @"World";
- NSLog(@"Hello %@!", worldString); // prints => "Hello World!"
- // NSMutableString is a mutable version of the NSString object.
- NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
- [mutableString appendString:@" World!"];
- NSLog(@"%@", mutableString); // prints => "Hello World!"
-
- // Character literals
- NSNumber *theLetterZNumber = @'Z';
- char theLetterZ = [theLetterZNumber charValue]; // or 'Z'
- NSLog(@"%c", theLetterZ);
-
- // Integral literals
- NSNumber *fortyTwoNumber = @42;
- int fortyTwo = [fortyTwoNumber intValue]; // or 42
- NSLog(@"%i", fortyTwo);
-
- NSNumber *fortyTwoUnsignedNumber = @42U;
- unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // or 42
- NSLog(@"%u", fortyTwoUnsigned);
-
- NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
- short fortyTwoShort = [fortyTwoShortNumber shortValue]; // or 42
- NSLog(@"%hi", fortyTwoShort);
-
- NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:41];
- unsigned short fortyTwoUnsigned = [fortyTwoShortNumber unsignedShortValue]; // or 41
- NSLog(@"%hu", fortyTwoUnsigned);
-
- NSNumber *fortyTwoLongNumber = @42L;
- long fortyTwoLong = [fortyTwoLongNumber longValue]; // or 42
- NSLog(@"%li", fortyTwoLong);
-
- NSNumber *fortyTwoLongNumber = @53L;
- unsigned long fiftyThreeUnsigned = [fortyTwoLongNumber unsignedLongValue]; // or 53
- NSLog(@"%lu", fiftyThreeUnsigned);
-
- // Floating point literals
- NSNumber *piFloatNumber = @3.141592654F;
- float piFloat = [piFloatNumber floatValue]; // or 3.141592654f
- NSLog(@"%f", piFloat); // prints => 3.141592654
- NSLog(@"%5.2f", piFloat); // prints => " 3.14"
-
- NSNumber *piDoubleNumber = @3.1415926535;
- double piDouble = [piDoubleNumber doubleValue]; // or 3.1415926535
- NSLog(@"%f", piDouble);
- NSLog(@"%4.2f", piDouble); // prints => "3.14"
-
- // NSDecimalNumber is a fixed-point class that's more precise then float or double
- NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
- NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
- // NSDecimalNumber isn't able to use standard +, -, *, / operators so it provides its own:
- [oneDecNum decimalNumberByAdding:twoDecNum];
- [oneDecNum decimalNumberBySubtracting:twoDecNum];
- [oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
- [oneDecNum decimalNumberByDividingBy:twoDecNum];
- NSLog(@"%@", oneDecNum); // prints => 10.99 as NSDecimalNumber is immutable.
-
- // BOOL literals
- NSNumber *yesNumber = @YES;
- NSNumber *noNumber = @NO;
- // or
- BOOL yesBool = YES;
- BOOL noBool = NO;
- NSLog(@"%i", yesBool); // prints => 1
-
- // Array object
- NSArray *anArray = @[@1, @2, @3, @4];
- NSNumber *thirdNumber = anArray[2];
- NSLog(@"Third number = %@", thirdNumber); // Print "Third number = 3"
- // NSMutableArray is mutable version of NSArray allowing to change items in array
- // and extend or shrink array object. Convenient, but not as efficient as NSArray.
- NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
- [mutableArray addObject:@"Hello"];
- [mutableArray addObject:@"World"];
- [mutableArray removeObjectAtIndex:0];
- NSLog(@"%@", [mutableArray objectAtIndex:0]); // prints => "World"
-
- // Dictionary object
- NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
- NSObject *valueObject = aDictionary[@"A Key"];
- NSLog(@"Object = %@", valueObject); // Print "Object = (null)"
- // NSMutableDictionary also available as a mutable dictionary object.
- NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
- [mutableDictionary setObject:@"value1" forKey:@"key1"];
- [mutableDictionary setObject:@"value2" forKey:@"key2"];
- [mutableDictionary removeObjectForKey:@"key1"];
-
- // Set object
- NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
- NSLog(@"%@", set); // prints => {(Hello, World)} (may be in different order)
- // NSMutableSet also available as a mutable set object.
- NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
- [mutableSet addObject:@"Hello"];
- [mutableSet addObject:@"Hello"];
- NSLog(@"%@", mutableSet); // prints => {(Hello)}
-
- // Set object
- NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
- NSLog(@"%@", set); // prints => {(Hello, World)}
-
- ///////////////////////////////////////
- // Operators
- ///////////////////////////////////////
-
- // The operators works like in the C language
- // For example:
- 2 + 5; // => 7
- 4.2f + 5.1f; // => 9.3f
- 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
- switch (2)
- {
- case 0:
- {
- NSLog(@"I am never run");
- } break;
- case 1:
- {
- NSLog(@"I am also never run");
- } break;
- default:
- {
- NSLog(@"I print");
- } break;
- }
-
- // While loops statements
- int ii = 0;
- while (ii < 4)
- {
- NSLog(@"%d,", ii++); // ii++ increments ii in-place, after using its value.
- } // => prints "0,"
- // "1,"
- // "2,"
- // "3,"
-
- // For loops statements
- int jj;
- for (jj=0; jj < 4; jj++)
- {
- NSLog(@"%d,", jj);
- } // => prints "0,"
- // "1,"
- // "2,"
- // "3,"
-
- // Foreach statements
- NSArray *values = @[@0, @1, @2, @3];
- for (NSNumber *value in values)
- {
- NSLog(@"%@,", value);
- } // => prints "0,"
- // "1,"
- // "2,"
- // "3,"
-
- // Object for loop statement. Can be used with any Objective-C object type.
- for (id item in values) {
- NSLog(@"%@,", item);
- } // => prints "0,"
- // "1,"
- // "2,"
- // "3,"
-
- // Try-Catch-Finally statements
- @try
- {
- // Your statements here
- @throw [NSException exceptionWithName:@"FileNotFoundException"
- reason:@"File Not Found on System" userInfo:nil];
- } @catch (NSException * e)
- {
- NSLog(@"Exception: %@", e);
- } @finally
- {
- NSLog(@"Finally");
- } // => prints "Exception: File Not Found on System"
- // "Finally"
-
- ///////////////////////////////////////
- // Objects
- ///////////////////////////////////////
-
- // Create an object instance by allocating memory and initializing it.
- // An object is not fully functional until both steps have been completed.
- MyClass *myObject = [[MyClass alloc] init];
-
- // The Objective-C model of object-oriented programming is based on message
- // passing to object instances.
- // In Objective-C one does not simply call a method; one sends a message.
- [myObject instanceMethodWithParameter:@"Steve Jobs"];
-
- // Clean up the memory you used into your program
- [pool drain];
-
- // End of @autoreleasepool.
- }
-
- // End the program
- return 0;
-}
-
-///////////////////////////////////////
-// Classes And Functions
-///////////////////////////////////////
-
-// Declare your class in a header file (MyClass.h):
-// Class declaration syntax:
-// @interface ClassName : ParentClassName <ImplementedProtocols>
-// {
-// type name; <= variable declarations;
-// }
-// @property type name; <= property declarations.
-// -/+ (type) Method declarations; <= Method declarations.
-// @end
-@interface MyClass : NSObject <MyProtocol> // NSObject is Objective-C's base object class.
-{
- // Instance variable declarations (can exist in either interface or implementation file).
- int count; // Protected access by default.
- @private id data; // Private access. (More convenient to declare in implementation file).
- NSString *name;
-}
-// Convenient notation for public access variables to auto generate a setter method.
-// By default, setter method name is 'set' followed by @property variable name.
-@property int count; // Setter name = 'setCount'
-@property (copy) NSString *name; // (copy) => Copy the object during assignment.
-@property (readonly) id data; // (readonly) => Declare only a getter method.
-// You can customize the getter and setter names instead of using default 'set' name:
-@property (getter=lengthGet, setter=lengthSet:) int length;
-
-// Methods
-+/- (return type)methodSignature:(Parameter Type *)parameterName;
-
-// + for class method
-+ (NSString *)classMethod;
-
-// - for instance method
-- (NSString *)instanceMethodWithParameter:(NSString *)string;
-- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
-
-@end // States the end of the interface.
-
-
-// To access public variables from the implementation file, @property generates a setter method
-// automatically. Method name is 'set' followed by @property variable name:
-MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance.
-[myClass setCount:10];
-NSLog(@"%@", [myClass count]); // prints => 10
-// 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
-
-
-// Implement the methods in an implementation (MyClass.m) file:
-@implementation MyClass {
- long distance; // Private access instance variable.
-}
-
-// To access public variable from the interface file, use '_' followed by variable name:
-_count = 5; // References "int count" from MyClass interface.
-NSLog(@"%d", _count); // prints => 5
-// Access variables defined in implementation file:
-distance = 18; // References "long distance" from MyClass implementation.
-NSLog(@"%li", distance); // prints => 18
-
-// Call when the object is releasing
-- (void)dealloc
-{
-}
-
-// Constructors are a way of creating classes
-// This is a default constructor which is called when the object is creating
-- (id)init
-{
- if ((self = [super init]))
- {
- self.count = 1;
- }
- return self;
-}
-
-+ (NSString *)classMethod
-{
- return [[self alloc] init];
-}
-
-- (NSString *)instanceMethodWithParameter:(NSString *)string
-{
- return @"New string";
-}
-
-- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
-{
- return @42;
-}
-
-// Methods declared into MyProtocol
-- (void)myProtocolMethod
-{
- // statements
-}
-
-@end // States the end of the implementation.
-
-/*
- * 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.
- */
-@protocol MyProtocol
- - (void)myProtocolMethod;
-@end
-
-
-///////////////////////////////////////
-// 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.
-*/
-
-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.
-
-// @property can use retain or 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).
-
-// 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,
-// you must not use retain, relase, or autorelease.
-MyClass *arcMyClass = [[MyClass alloc] init]; // Without ARC, you will need to call: [arcMyClass release] after
-// you're done using arcMyClass. But with ARC, there is no need. It will insert this release statement for you.
-
-// As for the "assign" and "retain" @property attributes, with ARC you use "weak" and "strong".
-@property (weak) MyClass *weakVar; // weak does not take ownership of object. If original instance's reference count
-// 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.
-
-// For regular variables (not @property declared variables), use the following:
-__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.
-
-```
-## Further Reading
-
-[Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)
-
-[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
-
-[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)