IT tutorials

iPhone SDK 3 : Objective-C and Cocoa - Classes

1/15/2013 11:01:50 AM
- How To Install Windows Server 2012 On VirtualBox
- How To Bypass Torrent Connection Blocking By Your ISP
- How To Install Actual Facebook App On Kindle Fire

In object-oriented languages, an object encapsulates attributes and provides methods. These methods can be used by the outside world (i.e., other objects) to change the object's state as well as to interact with the object. All this can be achieved without opening the actual implementation of the object's behavior to the outside world.

In Objective-C, in order to create a new class, you first need to declare it using an interface and then define it using an implementation. The declaration and the definition are usually written in two separate files. The declaration part (described more fully in the following sections) is customarily done in a .h file having the same name as the class, while the implementation, which also has the same name as the class, is in a .m file. Both the declaration and the definition parts use compiler directives. A compiler directive is an instruction to the Objective-C compiler prefixed by the @ sign. The declaration is signaled to the compiler using the @interface directive, while the actual definition is signaled using the @implementation directive.

1. Class declaration

To declare a class, MyClassName, as a subclass of class MyParentName, you simply write:

@interface  MyClassName : MyParentName{
   // attribute declarations 
   // method declarations 

Here, we are telling the compiler that a new class type, MyClassName, is being declared. MyClass-Name is a subclass of MyParentName class. In addition, we list the definition of all instance variables between the curly brackets. The methods are declared between the end of the curly bracket and the @end compiler directive.

There are a few important aspects of the @interface declaration:

  • The attributes declared between the curly brackets are instance variables. At runtime, every class has a unique class object and zero or more instances of the class. Every instance (object) of MyClassName has its own values for these attributes. The unique class object has no access to these instance variables.

  • Methods declared can be either instance methods or class methods. An instance method is called by sending a message to an actual instance (i.e., an object) of the class. A class method does not require a class instance. You call a class method by sending a message to the unique class object. In Objective-C, every class has exactly one class object during the runtime of the program. An instance method is declared/defined by a "-" prefix, while a class method is declared/defined by a "+"prefix.

    For example:

    -(Address *) getAddress;

    is an instance method, while

    +(id) getANewInstance;

    is a class method.

  • Objective-C does not support class variables. However, you can use the familiar static keyword in an implementation file of a given class. This will allow instance methods (i.e., those with a "-" prefix in their definition) to have access to the single value of this variable shared by all instances of that declared class. If you define a static variable inside a method, then that method is the only method that has access to that variable. If you put the definition of the static variable outside the class implementation, then all methods have access to that variable.

2. How do I use other declarations?

As a Cocoa developer, you will need to be able to use classes that other developers have written. In addition, if the declaration and the definition of your classes are in separate files, you will need to inform the compiler about the location of the class declaration in the implementation file.

If you use the name of a class without accessing its methods or instance variables, you can just use the @class directive. This gives the compiler enough information to successfully compile the code. Usually the @class directive is used in class declarations. For example, consider the following declaration:

@class Address;
@interface Person{
    Address *address;

Here, we have a Person class declaration that uses the Address class. The compiler only needs to know that the Address is a class type. No details about the actual methods and attributes are needed since we just use the type.

If, on the other hand, you use the methods and/or the attributes of a given class, then you need to point the compiler to the location of the file that contains the declaration. There are two ways to do that: (1) using #include, and (2) using #import. #include and #import are almost identical, except that #import loads the given file only once during the compilation process. The #import directive is much simpler, fully supported by Apple, and produces potentially fewer problems. Bottom line: use #import.

3. Class definition

To actually define a class, you need to specify the actual implementation of the class/instance methods declared in the @interface part. To define the class, you write:

#import  "MyClassName.h"
@implementation  MyClassName
   // method definitions 

Notice that we needed to import the declaration file. This import allowed us to skip repeating the parent's class name as well as the instance variables. Both can be deduced by the compiler so there is no need to repeat them.

4. Method invocation and definition

Method invocation in Objective-C addresses a problem that those of you who have used Java will be familiar with. In Java, a method is invoked using its name followed by a pair of left and right parentheses. If the method requires parameters, the values of these parameters are inserted inside the parentheses and separated by commas. For example, if aPoint is a Java object representing a point in 3D, setLocation (float x, float y, float z) can represent a method for changing the location of this point object. aPoint.setlocation(3, 6, 9) asks the aPoint object to change its location to (3, 6, 9). One problem with this notation is readability. If you come across such a statement written by another programmer, you cannot know for sure what these values represent. You have to go to the interface of this class and read about what each position in the parameters list represents.

Because Objective-C is an object-oriented language, it, too, provides data encapsulation. With data encapsulation, the outside world interacts with an object by sending messages to that object. To send an object (aObject) a message (aMessage) you use square brackets and write [aObject aMessage]. A message is composed of two parts: (1) keywords, and (2) parameters. Every message has at least one keyword. A keyword is an identifier followed by a colon.

Let's make these definitions concrete by writing the setlocation method invocation in Objective-C. In Objective-C, you write something like:

[aPoint setLocationX:3 andY:6 andZ:9];

Notice the improved readability of the invocation of the method. Just by looking at it, we know that 6 is used to change the y-coordinate. This message has three keywords: setlocationX:, andY:, andZ:. The method is represented by setLocationX:andY:andZ:. This representation is called a selector. A selector is a unique name (within a class) of a method used by the runtime to locate the code implementing that method. The method is declared in the interface as:

-(void)setLocationX:(float) x andY:(float) y andZ:(float) z;

The statement [aPoint setLocationX:3 andY:6 andZ:9] as a whole is called a message expression. If this expression evaluates to an object, then it, too, can receive a message. Objective-C allows nested message invocation. For example, you can write:

[[addressBook getEntryAtIndex:0] printYourself];

First, the message getEntryAtIndex:0 is sent to the addressBook object. The method identified by the selector getEntryAtIndex: returns an object. This object is then sent a printYourself message.

It's worth noting that if a method has zero parameters, you should not use the ":" when the method is invoked. This notation can be difficult to deal with at first, but after a time it becomes natural.

Methods in Objective-C are always public. There is no such thing as a private method. Instance variables are defaulted to protected, a setting that works well for you most of the time.

5. Important types

We mentioned before that every class in a Cocoa application has a singleton class object. The type of this class object is Class. A null class pointer is of type Nill. Nill is basically (Class)0. We also learned that a class can be instantiated. An instance of a class A is declared as:

A *anObject;

There is, however, a defined type in Cocoa that represents an arbitrary object. This type is named id. If anObject does not point to any object, its value is nil. A nil is basically (id)0.

SEL is a defined type that represents a selector. To obtain the SEL of a method, aMethod:, use the directive @selector as follows.

SEL mySelector = @selector (aMethod:);

If you want mySelector to point to a null selector, assign it NULL.

You can also obtain the SEL of a method from a string representation of its name. The function to use is NSSelectorFromString() which is declared as:

SEL NSSelectorFromString (NSString *aSelectorName);

NSSelectorFromString will always return a SEL named by a non-nil aSelectorName even if the selector is not found. If there is no selector with the name aSelectorName, a new selector is registered with this name and returned. If the parameter aSelectorName is nil or the function faces memory problems, it will return NULL (basically (SEL)0).

6. Important Cocoa classes

There are several important Cocoa classes that you will often use in your iPhone application.

  • NSObject. This is the base class of most Cocoa classes. An object is not considered a Cocoa object if it is not an instance of NSObject or any class that inherits from NSObject. This class defines the runtime methods required for allocating and deallocating objects.

  • NSString. This is the main class representing strings in Cocoa. Using this class, you can store an arbitrary text. However, once you store a value in an object of this type, you cannot change it. This kind of class is referred to as immutable. To be able to change a string's value (e.g., append text to it, etc.), you need the mutable string class NSMutableString. You can create a constant string using the "@" sign. For example, @"Plano" represents an NSString instance.

  • NSArray. Instances of this class represents Cocoa array objects. The mutable version of this class is NSMutableArray.

  • NSSet. Instances of this class represents Cocoa set objects. The mutable version is NSMutableSet. 

- iPhone SDK 3 : Creating Interfaces
- IPad : Your Calendar - Manage Your Busy Life on Your iPad
- IPad : Working with Contacts - Showing Your Contacts Addresses on the Map, Changing your Contact Sort Order and Display Order
- BlackBerry Development : The BlackBerry Mobile Data System - MDS Components, MDS Functions
- BlackBerry Development : The BlackBerry Mobile Data System - The BlackBerry Enterprise Server, BlackBerry MDS Overview
- Enter Java ME on Symbian OS : Exposing the Power of Symbian OS
- Enter Java ME on Symbian OS : Proprietary JAD Attributes, Computing Capabilities of Java ME on Symbian OS
- iphone Programming : Distributing Your Application - Submitting to the App Store, Reasons for Rejection
- iphone Programming : Distributing Your Application - Building and Signing
- Windows Phone 7 Advanced Programming Model : Working with Video and Audio Media
Top 10
- Microsoft Visio 2013 : Adding Structure to Your Diagrams - Finding containers and lists in Visio (part 2) - Wireframes,Legends
- Microsoft Visio 2013 : Adding Structure to Your Diagrams - Finding containers and lists in Visio (part 1) - Swimlanes
- Microsoft Visio 2013 : Adding Structure to Your Diagrams - Formatting and sizing lists
- Microsoft Visio 2013 : Adding Structure to Your Diagrams - Adding shapes to lists
- Microsoft Visio 2013 : Adding Structure to Your Diagrams - Sizing containers
- Microsoft Access 2010 : Control Properties and Why to Use Them (part 3) - The Other Properties of a Control
- Microsoft Access 2010 : Control Properties and Why to Use Them (part 2) - The Data Properties of a Control
- Microsoft Access 2010 : Control Properties and Why to Use Them (part 1) - The Format Properties of a Control
- Microsoft Access 2010 : Form Properties and Why Should You Use Them - Working with the Properties Window
- Microsoft Visio 2013 : Using the Organization Chart Wizard with new data
programming4us programming4us
Popular tags
Video Tutorail Microsoft Access Microsoft Excel Microsoft OneNote Microsoft PowerPoint Microsoft Project Microsoft Visio Microsoft Word Active Directory Biztalk Exchange Server Microsoft LynC Server Microsoft Dynamic Sharepoint Sql Server Windows Server 2008 Windows Server 2012 Windows 7 Windows 8 Adobe Indesign Adobe Flash Professional Dreamweaver Adobe Illustrator Adobe After Effects Adobe Photoshop Adobe Fireworks Adobe Flash Catalyst Corel Painter X CorelDRAW X5 CorelDraw 10 QuarkXPress 8 windows Phone 7 windows Phone 8 BlackBerry Android Ipad Iphone iOS