Objective C Class and Its Property Attributes

Objective C

Corporation it was designed to enable power full feature of objective oriented programming it works as a power full set of extension to the c-language.

objective C takes best feature from c and small talk it is easy to learn and has full objective oriented capabilities apple has selected objective c has primary programming language for an MVC and I phone.

It is a power full language easy to learn and objective oriented version of C it is a provides dynamic binding.

Easy to understand code and when organized language that why objective c is selected for coco of frame work.

Main Topics of objective C

Properties:

Classes/interface

Protocol

Exception handling

Memory management

Messaging

Categories

Id/dynamic binding/enema

Over loading / overriding.

Threading.

Keywords:

Objective c has same additional keywords to avoid conflict with keyword in other languages it uses @ at the being of the key words

@ Interface

@implementation

@end

@syn the size

@protocol

@property

Access specifies:

@private

@protected

@public

Exception handling directives:

@try

@catch

@finally

@throws

Directives used for particular purpose:

@class

@selector

@string

@synchronized

Keywords for memory management:

alloc

init

retain

release

auto release

some other keywords:

BooL

Self

Super

Pre processor directives:

#import, #define

Class

A class is nothing but a collection of variables and function it is a blue print for creating objects

Class consists of state and behavior.

State is nothing but variable and behavior is functions or method.

In objective c class is declaring by using @ interface directive

Class is written h file the definition of h file is m file.

The variable declared in a class can be accessed entire class function.

Declare in an instance variable as property provides external class with access.

Property Attributes

1) Atomic:

In objective c by default property attribute is atomic in atomic multiple threads are created for setting and getting the values for creating thread extra code will be generated and it leads to performance issue

2) Non-atomic:

By using this attribute we tell the compiler that it doesn’t to generate extra code for thread creation. It is a thread safety.

If we doesn’t specify non-atomic the compiler will generate extra code, and property can accessed from single threads with improves to performance.

3) Read-only:

This attribute tells the compiler that the property can declare be read but not be said the compiler will be only generate.

getter method not setter method if we attend to write code that assign a value to the property then compile will generate a warning.

4) Retain:

This is specifies that you are instead in putting ownership claim on the object if the caller releases this object it does not deal located because you retained.

5) Copy:

This attribute creates copy of the object can we called setter method, and then you become owner of the new object.

Accessory Methods:

1) Setter methods: This is use per setting a value to the property

2) Getter method: This is used per getting a value to the property

3) @synthesize: If you use this directive in a program for property then no need to write accessory methods to the property.

Syntax:- @synthesize str;

Realizing a property:

Syntax:- [str release];

These statements written in deal loc method.

Subroutines

Subroutines are generally called methods in objective c they are divided in to 2 types

Class methods

Instance methods

→ A class method is noted with a + in declaration and documentation.

→ An instance method is marked with in (-) sign

→ Every method can be called by class or instance of the class

Syntax of objective C methods:

+ (return type) method name———–instant class method

_ (return type)method name————instance method.

Eg:-.hfile:-

#import <UIKIT/UIKIT .h>

@interface auto view controller . UI view controller

{

}

//instance methods

– (void) addition;

– (void) subtraction : (int)a b : (int)b;

//class methods

+ (void) divisions;

+ (void) multiplication;

@end

.m file:-

#import “auto view Controller.h”

@implementation auto view controller

//instance methods

– (void) addition

{

//calling instance method

[Self Subtraction: 10 B: 20]

//Calling Class method

[Auto view controller division];

}

– (void) subtraction: (int)a b:int)b

{

}

//class method

+ (void) division

{

}

+ (void)multiplication

{

}

@end

Note:-

àHow to print an message in the command prompt

printf (“hello”);

NSLog(@”type message in here”);

àHow to print objects in the command prompt

printf (“%d %f”, a, b);

NSLog (@”%d%@”,a, any object);

Categories:

Categories are one of the most use full features in objective c.

Categories allow you add method to an existing class with out sub classing.

This is particular useful because you can add methods to built in objects.

If we want add a method to all instance of NS object class in your application you just add a category there is a need to get everything to use a custom sub class [category in that declaration no curly back]

Eg:–

.h file:-

#import <foundation / foundation .h>

@ Interface NS object (algebra)

– (void) addition;

– (void)subtraction;

@end

.m file:-

#import NS object + algebra .h”

@implementation NS object(algebra)

-(void)addition

{

}

-(void)subtraction

{

}

@end

→ Unlike subclass category can’t add instance method.

→ You can however use category to over side existing methods in sub classes.

Note: When we make changes a class using a category it affects all instances of that class throughout the application.

Id: Id is a generally type assigning any type of object regards less of class by default all c functions return integer type in objective c it returns id type

Ex:-

NS string *str = @ “Hai”; // str is string object

Id str = str;

// id as return type

-(id)addition

{

Return some obj;

}

// id as argument

– (void)addition;(id)str bLid)str2

{

}

Dynamic Binding:

It difference between function call’s and messages is that in a function call which are arguments are join to gather on the compilation code but in case of messages not link until program is run [ linking and runtime]

Ex:- void view did load

{

[Self addition];

}

Binding on run time so this is calling as dynamic binding it

It is a not a compile time error

-(void)additions;

NOTE:

The extra method that is involved to respond a message can only determined at runtime.