There are a number of key Objective-C concepts that have close relations to the practice of object-oriented programming in general. For the moment, we won't look at exact syntax until later.
- If you have previous experience in object-oriented programming, you may wish to skip these sections and examine the Summary section
What is object-oriented programming?
Object-oriented programming (often just shortened to OO or OOP), is a programming paradigm where code is written in units called classes. For example, ANSI C has data in structs, and similarly, an OO language stores data in classes or objects.
For example, if you are creating a word processor, you might represent the document by an object that has text as its data, and associate with it different tasks to perform upon the document's data, such as "spell check".
The word processor then would be a small program that might draw the window and show the document's text. A spell check button would perform the "spell check" task upon that document's object.
However, if we were editing two documents at once, they would differ probably in the contents of the documents- the data. But all the documents would be more or less the same: Each document contains a space for its text, and has a couple of defined tasks that operate on the text. Each document object has essentially the same form. We call this form the class of the object, and we often give it a name. Let's call the document class Document (Style note: we often capitalize names of classes).
Now, each document object has the form of the Document. We say that each document object is an instance of Document. So, for example, our word processor operates on instances of the Document class. Sometimes we may call an instance of the Document class just "a Document".
Remember that each object has some data. For example, with the Document class, each Document has data to hold the text of the document. We call the data that each object holds instance variables. So, a Document may specify an instance variable to hold the text, or an instance variable to hold the word count, or the author, or any other data we may want to specify. Each Document has instance variables that are separate from the instance variables of any other Document that may exist.
Each object also has a number of tasks that it can perform on its instance variables. In Objective-C, we call these tasks methods. The object's methods operate on the object's instance variables.
However, there's more to objects than just this. With Objective-C, we can do a lot of interesting things with objects.
Working with objects
Let's stick with the example of our word processor. Say we want to create a new instance of Document so we can work with it. This process is called instantiation.
Now that we have an active instance of an object, we can work with it, by using the object's methods. We'll look at defining and working with methods later. Each method merely acts like a function in C, and in Objective-C, there is only a minor syntax change.
When we're completely done with the object and want to get rid of it (so it stops taking up memory), we do what is known as destruction or deallocation of the object. This is like free'ing a malloc'd array, for example, in C. However, if, in the process of using the object's methods, we allocate some extra memory for its instance variables, we must free that memory too.
When we're creating new classes, we may want to base the new object's behaviour on a class, which we have previously created. For example, if we want to create a document class that has details of style information, we may wish to base that class on the `Document` class, which we have previously created.
This is a common enough feature that it is included in object-oriented systems, and it is given the name of inheritance. When a class inherits from another, the new class takes on the form of the old class and can add extra instance variables and methods.
So, if we wanted to create a `StyledDocument` class, we would inherit from the `Document` class. In Objective-C, a class only inherits from one other class. This is known as single inheritance.
Interfaces and implementation
As in the real world, there is a separation between how objects are used, and how objects work. For example, with our word processor, there is a consistent interface to the spellchecker (how it is used), such as buttons to jump to the next misspelt word, to go back, and to correct. But, behind the scenes, the way the spellchecker works (the implementation) can be done in many different ways.
In Objective-C, the interface and implementation are kept separate. This allows different objects to work and link together in a well-defined manner. To change channels on your television, for example, you use the interface of the buttons on the television set instead of opening it and fiddling around with the electronics.
Keeping the implementation separate from the interface means that we can change anything in the implementation (even substituting it with another implementation) and everything should still work, because objects (buttons etc) interact with each other only through their interfaces.
So, before we get to learning Objective-C syntax, let's recap:
- An object is an instance of a class
- which has defined upon it tasks known as methods
- and data known as instance variables
- which has defined upon it tasks known as methods
- A class can inherit from one (and only one) other class (single inheritance)