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

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.

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.

Language Concepts:Fully supports object-oriented programming, including the

four pillars of object-oriented development:

Encapsulation

Data hiding

Inheritance

Polymorphism

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.

InheritanceInheritance 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.

Program StructureA Objective-C program basically consists of the following parts:

Preprocessor CommandsInterfaceImplementationMethodVariablesStatements & ExpressionsComments

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; }

Objective- C Basic SyntaxTokens 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 */

Objective- C Data TypesData 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.

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]);

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, &, *, ?:)

Objective-C LoopsA 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

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.

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.

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"];VsNSMutableString *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)

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"); }

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

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.

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;

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. 

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.

// 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;

// 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;

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