• Not running State: The app has not been launched or was running but was terminated by the system.
• Inactive state: The app is running in the foreground but is currently not receiving events. (It may be executing other code though.) An app usually stays in this state only briefly as it transitions to a different state. The only time it stays inactive for any period of time is when the user locks the screen or the system prompts the user to respond to some event, such as an incoming phone call or SMS message.
• Active state: The app is running in the foreground and is receiving events. This is the normal mode for foreground apps.
• Background state: The app is in the background and executing code. Most apps enter this state briefly on their way to being suspended. However, an app that requests extra execution time may remain in this state for a period of time. In addition, an app being launched directly into the background enters this state instead of the inactive state. For information about how to execute code while in the background, see “Background Execution and Multitasking.”
• Suspended state:The app is in the background but is not executing code. The system moves apps to this state automatically and does not notify them before doing so. While suspended, an app remains in memory but does not execute any code. When a low-memory condition occurs, the system may purge suspended apps without notice to make more space for the foreground app.

256bytes.

Assign creates a reference from one object to another without increasing the source’s retain count.

if (_variable != object)

{

[_variable release];

_variable = nil;

_variable = object;

}

Retain creates a reference from one object to another and increases the retain count of the source object.

if (_variable != object)

{ [_variable release];

_variable = nil;

_variable = [object retain];

}

Before the launch of an app, it is said to be in not running state.
When an app is launched, it moves to the active or background state, after transitioning briefly through the inactive state.

During app launching, the system creates a main thread for the app and calls the app’s main function on that main thread. The Xcode project’s default main function hands over control to the UIKit framework, which takes care of initializing the app before it is run.

Controller object UIApplication is used without subclassing to manage the application event loop.
It coordinates other high-level app behaviors.
It works along with the app delegate object which contains app-level logic.

The app delegate object is created by UIApplicationMain function at app launch time. The app delegate object’s main job is to handle state transitions within the app.

App delegate is declared as a subclass of UIResponder by Xcode project templates.

In such case the event will be dispatched to your app delegate for processing.

Data model objects are app specific objects and store app’s content. Apps can also use document objects to manage some or all of their data model objects.

Document objects are not required but are very useful in grouping data that belongs in a single file or file package.

View controller objects takes care of the presentation of app’s content on the screen. A view controller is used to manage a single view along with the collection of subviews. It makes its views visible by installing them in the app’s window.

UIViewController class. The functionality for loading views, presenting them, rotating them in response to device rotations, and several other standard system behaviors are provided by UIViewController class.

The presentation of one or more views on a screen is coordinated by UIWindow object.

To change the content of your app, you use a view controller to change the views displayed in the corresponding window. Remember, window itself is never replaced.

Views along with controls are used to provide visual representation of the app content. View is an object that draws content in a designated rectangular area and it responds to events within that area.

Apart from incorporating views and controls, an app can also incorporate Core Animation layers into its view and control hierarchies.

68-What is App Bundle?

When you build your iOS app, Xcode packages it as a bundle. Abundle is a directory in the file system that groups related resources together in one place. An iOS app bundle contains the app executable file and supporting resource files such as app icons, image files, and localized content.

Instance methods are essentially code routines that perform tasks so instances of clases we create methods to get and set the instance variables and to display the current values of these variables.

Declaration of instance method :

– (void)click me: (id)sender;

Void is return type which does not giving any thing here.

Click me is method name.

Id is data type which returns any type of object.

Class methods work at the class level and are common to all instance of a class these methods are specific to the class overall as opposed to working on different instance data encapsulated in each class instance.

@interface class name :ns object

+(class name *)new alloc:

-(int)total open

Data is contained within objects and is not accessible by any other than via methods defined on the class is called data encapsulation.

Accessor methods are methods belonging to a class that allow to get and set the values of instance valuables contained within the class.

Objective-c provides a mechanism that automates the creation of accessor methods that are called synthesized accessor methods that are implemented through use of the @property and @synthesized.

(a)Data encapsulation encourages the use of methods to +get and set the values of instance variables in a class.

(b)But the developer to want to directly access an instance variable without having to go through an accessor method.

(c) In objective-c syntax for an instance variable is as follow [class instance variable name]

Dot notation features introduced into version 2.0 of objective-c. Dot notation involves accessing an instance variable by specifying a class “instance” followed by a “dot” followed in turn by the name of instance variable or property to be accessed.

Class extensions are similar to categories. The main difference is that with an extension, the compiler will expect you to implement the methods within your main @implementation, whereas with a category you have a separate @implementation block. So you should pretty much only use an extension at the top of your main .m file (the only place you should care about ivars, incidentally) — it’s meant to be just that, an extension.

KVC:Normally instance variables are accessed through properties or accessors but KVC gives another way to access variables in form of strings. In this way your class acts like a dictionary and your property name for example “age” becomes key and value that property holds becomes value for that key. For example, you have employee class with name property.

You access property like

NSString age = emp.age;

setting property value.

emp.age = @”20″;

Now how KVC works is like this

[emp valueForKey:@"age"];

[emp setValue:@"25" forKey:@"age"];

KVO :The mechanism through which objects are notified when there is change in any of property is called KVO.

For example, person object is interested in getting notification when accountBalance property is changed in BankAccount object.To achieve this, Person Object must register as an observer of the BankAccount’s accountBalance property by sending an addObserver:forKeyPath:options:context: message.

Yes, we can use two tableviews on the same view controllers and you can differentiate between two by assigning them tags…or you can also check them by comparing their memory addresses.

int x=10;?int y=5;?x=x+y;?NSLog(@”x==> %d”,x);

y=x-y;?NSLog(@”Y Value=http://www.mamicode.com/=> %d”,y);

x=x-y;?NSLog(@”x Value=http://www.mamicode.com/=> %d”,x);

Cocoa is an application environment for both the Mac OS X operating system and iOS. It consists of a suite of object-oriented software libraries, a runtime system, and an integrated development environment. Carbon is an alternative environment in Mac OS X, but it is a compatibility framework with procedural programmatic interfaces intended to support existing Mac OS X code bases.

Appkit (Application Kit)

Foundation

Objective-C is a very dynamic language. Its dynamism frees a program from compile-time and link-time constraints and shifts much of the responsibility for symbol resolution to runtime, when the user is in control. Objective-C is more dynamic than other programming languages because its dynamism springs from three sources:

Dynamic typing—determining the class of an object at runtime

Dynamic binding—determining the method to invoke at runtime

Dynamic loading—adding new modules to a program at runtime

· The Objective-C class allows a method and a variable with the exact same name. In C++, they must be different.

· Objective-C does not have a constructor or destructor. Instead it has init and dealloc methods, which must be called explicitly.

· Objective-C uses + and – to differentiate between factory and instance methods, C++ uses static to specify a factory method.

· Multiple inheritance is not allowed in Obj-C, however we can use protocol to some extent.

· Obj-C has runtime binding leading to dynamic linking.

· Obj-C has got categories.

· Objective-C has a work-around for method overloading, but none for operator overloading.

· Objective-C also does not allow stack based objects. Each object must be a pointer to a block of memory.

· In Objective-C the message overloading is faked by naming the parameters. C++ actually does the same thing but the compiler does the name mangling for us. In Objective-C, we have to mangle the names manually.

· One of C++’s advantages and disadvantages is automatic type coercion.

· Another feature C++ has that is missing in Objective-C is references. Because pointers can be used wherever a reference is used, there isn’t much need for references in general.

· Templates are another feature that C++ has that Objective-C doesn’t. Templates are needed because C++ has strong typing and static binding that prevent generic classes, such as List and Array.

The Application Kit is a framework containing all the objects you need to implement your graphical, event-driven user interface: windows, panels, buttons, menus, scrollers, and text fields. The Application Kit handles all the details for you as it efficiently draws on the screen, communicates with hardware devices and screen buffers, clears areas of the screen before drawing, and clips views.

You also have the choice at which level you use the Application Kit:

· Use Interface Builder to create connections from user interface objects to your application objects.

· Control the user interface programmatically, which requires more familiarity with AppKit classes and protocols.

· Implement your own objects by subclassing NSView or other classes.

The Foundation framework defines a base layer of Objective-C classes. In addition to providing a set of useful primitive object classes, it introduces several paradigms that define functionality not covered by the Objective-C language. The Foundation framework is designed with these goals in mind:

· Provide a small set of basic utility classes.

· Make software development easier by introducing consistent conventions for things such as deallocation.

· Support Unicode strings, object persistence, and object distribution.

· Provide a level of OS independence, to enhance portability.

Static typed languages are those in which type checking is done at compile-time, whereas dynamic typed languages are those in which type checking is done at run-time.

Objective-C is a dynamically-typed language, meaning that you don’t have to tell the compiler what type of object you’re working with at compile time. Declaring a type for a varible is merely a promise which can be broken at runtime if the code leaves room for such a thing. You can declare your variables as type id, which is suitable for any Objective-C object.

In Objective-C, selector has two meanings. It can be used to refer simply to the name of a method when it’s used in a source-code message to an object. It also, though, refers to the unique identifier that replaces the name when the source code is compiled. Compiled selectors are of type SEL. All methods with the same name have the same selector. You can use a selector to invoke a method on an object—this provides the basis for the implementation of the target-action design pattern in Cocoa.

[friend performSelector:@selector(gossipAbout:) withObject:aNeighbor];

is equivalent to:

[friend gossipAbout:aNeighbor];

· Determine whether an objective-C object is an instance of a class

[obj isMemberOfClass:someClass];

· Determine whether an objective-C object is an instance of a class or its descendants

[obj isKindOfClass:someClass];

· The version of a class

[MyString version]

· Find the class of an Objective-C object

Class c = [obj1 class]; Class c = [NSString class];

· Verify 2 Objective-C objects are of the same class

[obj1 class] == [obj2 class]

As long as there aren’t any extra instance variables, any subclass can proxy itself as its superclass with a single call. Each class that inherits from the superclass, no matter where it comes from, will now inherit from the proxied subclass. Calling a method in the superclass will actually call the method in the subclass. For libraries where many objects inherit from a base class, proxying the superclass can be all that is needed.