Contents : Language Concepts How Objective C works- Basics Data Types NSInteger NSNumber Operators Loop Inheritance Method Overloading Mutable and Immutable Strings Mutable and Immutable Arrays File Management

1. Introduction to Objective C
Contents :
⦁ Language Concepts
⦁ How Objective C works- Basics
⦁ Data Types
⦁ NSInteger
⦁ NSNumber
⦁ Operators
⦁ Loop
⦁ Inheritance
⦁ Method Overloading
⦁ Mutable and Immutable Strings
⦁ Mutable and Immutable Arrays
⦁ File Management

2. What Is Objective C ?
Objective-C is the primary programming language you use when writing
software for OS X and iOS. It’s a superset of the C programming language
and provides object-oriented capabilities and a dynamic runtime.
Objective-C inherits the syntax, primitive types, and flow control
statements of C and adds syntax for defining classes and methods.
Objective-C inherits the syntax, primitive types, and flow control
statements of C and adds syntax for defining classes and methods.

3. Objective – C
Characteristics
The class is defined in two different sections
namely @interface and @implementation.
Almost everything is in form of objects.
Objects receive messages and objects are often referred as receivers.
Objects contain instance variables.
Objects and instance variables have scope.
Classes hide an object's implementation.
Properties are used to provide access to class instance variables in
other classes.

4. Language Concepts:
Fully supports object-oriented programming, including the
four pillars of object-oriented development:
Encapsulation
Data hiding
Inheritance
Polymorphism

5. Data Encapsulation
Encapsulation is an Object-Oriented Programming concept that
binds together the data and functions that manipulate the data and
that keeps both safe from outside interference and misuse.
Data encapsulation is a mechanism of bundling the data and the
functions that use them.

6. Inheritance
Inheritance allows us to define a class in terms of another class which
makes it easier to create and maintain an application. This also provides an
opportunity to reuse the code functionality and fast implementation time.
This existing class is called the base class, and the new class is referred to as
the derived class.
Objective-C allows only multilevel inheritance, i.e., it can have only one
base class but allows multilevel inheritance. All classes in Objective-C is
derived from the superclass NSObject.

7. Program Structure
A Objective-C program basically consists of the following
parts:
Preprocessor Commands
Interface
Implementation
Method
Variables
Statements & Expressions
Comments

8. Sample Code:
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
(void)sampleMethod;
@end
@implementation SampleClass
- (void)sampleMethod
{
NSLog(@"Hello, World! n");
}
@end
int main()
{
/* my first program */SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
return 0;
}

9. Objective- C Basic Syntax
Tokens in Objective – C:
Token is either a keyword, an identifier, a constant, a string literal, or a symbol. For
Example:
NSLog(@"Hello, World! n”);
Semicolons:
The semicolon is a statement terminator. That is, each individual statement
must be ended with a semicolon. It indicates the end of one logical entity. For
Example:
NSLog(@"Hello, World! n");
return 0;
Comments:
Comments are like helping text in your Objective-C program and they are
ignored by the compiler. For example:
/* my first program in Objective-C */

10. Objective- C Data Types
Data types refer to an extensive system used for declaring variables or
functions of different types. The type of a variable determines how much space
it occupies in storage and how the bit pattern stored is interpreted.
Types And Descriptions:
Basic Types: They are arithmetic types and consist of the two types: (a)
integer types and (b) floating-point types.
Enumerated types: They are again arithmetic types and they are used to
define variables that can only be assigned certain discrete integer values
throughout the program.
The type void: The type specifier void indicates that no value is available.
Derived type: They include (a) Pointer types, (b) Array types, (c) Structure
types, (d) Union types and (e) Function types.

11. NSInteger & NSNumber
You usually want to use NSInteger when you don't know what kind of processor
architecture your code might run on, so you may for some reason want the largest
possible int type, which on 32 bit systems is just an int, while on a 64-bit system it's
a long.
The NSNumber class is a lightweight, object-oriented wrapper around C’s numeric
primitives. It’s main job is to store and retrieve primitive values, and it comes with
dedicated methods for each data type:
NSNumber *aBool = [NSNumber numberWithBool:NO];
NSNumber *aChar = [NSNumber numberWithChar:'z'];
NSNumber *aUChar = [NSNumber numberWithUnsignedChar:255];
NSLog(@"%@", [aBool boolValue] ? @"YES" : @"NO");
NSLog(@"%c", [aChar charValue]);

12. Objective-C Operators
An operator is a symbol that tells the compiler to perform specific
mathematical or logical manipulations. Objective-C language is rich in
built-in operators and provides following types of operators:
Arithmetic Operators – (+, -, *, /, %, ++, --)
Relational Operators – (=, !=, >, <, >=, <= )
Logical Operators – (&&, ||, ! )
Bitwise Operators – ( &, |, ^, <<, >>)
Assignment Operators – (=, +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |= )
Misc Operators – (sizeof, &, *, ?:)

13. Objective-C Loops
A loop statement allows us to execute a statement or group of statements
multiple times and following is the general form of a loop statement in
most of the programming languages:
while
for
do while
nested loops
Loop Control Statements:
break statement
control statement

14. Mutable and Immutable
Strings & Arrays:
A mutable string should be used when you are physically
changing the value of the existing string, without completely
discarding the old value.
Examples might include adding a character to the beginning or the
end, or changing a character in the middle.
NSString has methods such as stringByAppendingString:, which
does add a string to an existing one—but it returns a new string.

15. A mutable object can be mutated or changed. An immutable object cannot.
For example, while you can add or remove objects from an NSMutableArray,
you cannot do either with an NSArray.
Mutable objects can have elements changed, added to, or removed, which
cannot be achieved with immutable objects. Immutable objects are stuck with
whatever input you gave them in their [[object alloc] initWith...] initializer.
The advantages of your mutable objects is obvious, but they should only be
used when necessary (which is a lot less often than you think) as they take up
more memory than immutable objects.

16. Mutable objects can be modified, immutable objects can't.
Eg: NSMutableArray has addObject: removeObject: methods (and more), but
NSArray doesn't.
Modifying strings:
NSString *myString = @"hello";
myString = [myString stringByAppendingString:@" world"];
Vs
NSMutableString *myString = @"hello";
[myString appendString:@" world”];
• Mutable objects are particularly useful when dealing with arrays.
Eg: if you have an NSArray of NSMutableStrings you can do:
[myArray makeObjectsPerformSelector:@selector(appendString:)
withObject:@“!!!"];
which will add 3 ! to the end of each string in the array.
But if you have an NSArray of NSStrings (therefore immutable), you can't do
this (at least it's a lot harder, and more code, than using NSMutableString)

17. File Handling In Objective C
File handling is made available with the help of class NSFileManager.
Methods used in File Handling:
The list of the methods used for accessing and manipulating files is listed below.
Here, we have to replace the FilePath1, FilePath2 and FilePath strings to our
required full file paths to get the desired action.
>> Check if file exists at a path:
NSFileManager *fileManager = [NSFileManager defaultManager]; //Get documents directory
NSArray *directoryPaths = NSSearchPathForDirectoriesInDomains (NSDocumentDirectory,
NSUserDomainMask, YES);
NSString *documentsDirectoryPath = [directoryPaths objectAtIndex:0];
if ([fileManager fileExistsAtPath:@""]==YES)
{
NSLog(@"File exists");
}

18. Memory Management
It is the process by which the memory of objects are allocated when
they are required and deallocated when they are no longer required.
Managing object memory is a matter of performance; if an
application doesn't free unneeded objects, its memory footprint
grows and performance suffers.
Objective-C Memory management techniques can be broadly
classified into two types:
1."Manual Retain-Release" or MRR
2."Automatic Reference Counting" or ARC

19. In Automatic Reference Counting or ARC, the system uses the
same reference counting system as MRR, but it inserts the
appropriate memory management method calls for us at compile-
time.
Also, iOS objects never had garbage collection feature. And with
ARC, there is no use of garbage collection in OS-X too.

20. Objective- C Pointers
Every variable is a memory location and every memory location has its address
defined which can be accessed using ampersand (&) operator, which denotes an
address in memory. Consider the following example, which will print the address of
the variables defined:
What are Pointers?
A pointer is a variable whose value is the address of another variable, i.e., direct
address of the memory location. Like any variable or constant, you must declare a
pointer before you can use it to store any variable address. The general form of a
pointer variable declaration is:
type *var-name;

21. How to use Pointers?
There are few important operations, which we will do with
the help of pointers very frequently.
(a) we define a pointer variable,
(b) assign the address of a variable to a pointer, and
(c) finally access the value at the address available in the
pointer variable.

22. Objective-C Methods
Methods represent the actions that an object knows how to perform.
They’re the logical counterpart to properties, which represent an object’s
data.
You can think of methods as functions that are attached to an object
however, they have a very different syntax.
Naming Conventions:
Objective-C methods are designed to remove all ambiguities from an
API. Three simple rules for naming Objective-C methods:
1.Don’t abbreviate anything.
2.Explicitly state parameter names in the method itself.
3.Explicitly describe the return value of the method.

23. // Car.h
#import <Foundation/Foundation.h>
@interface Car : NSObject
// Accessors –
-(BOOL)isRunning;
- (void)setRunning:(BOOL)running;
- (NSString *)model;
- (void)setModel:(NSString *)model;
// Calculated values
- (double)maximumSpeed;
-(double)maximumSpeedUsingLocale:(NSLocale *)locale;
// Action methods
- (void)startEngine;
- (void)driveForDistance:(double)theDistance;

24. // Error handling methods
- (BOOL)loadPassenger:(id)aPassenger error:(NSError **)error;
// Constructor methods
- (id)initWithModel:(NSString *)aModel;
- (id)initWithModel:(NSString *)aModel mileage:(double)theMileage;
// Comparison methods
- (BOOL)isEqualToCar:(Car *)anotherCar;
- (Car *)fasterCar:(Car *)anotherCar;
- (Car *)slowerCar:(Car *)anotherCar;

25. Upcoming Topics:
Introduction to XCode
Introduction to iPhone Architecture
Essential COCOA Touch Classes
Nib File and Story Board
MVC Framework
Intro to .H and .M Files
THANK YOU