title=Programming Concepts: Object-oriented programming (OOP)

From Wikibooks, open books for an open world
Jump to: navigation, search

PAPER 1 - ⇑ Fundamentals of programming ⇑

← Object-oriented programming Elements of Object-Oriented Programming Features of Object-Oriented Programming →

Key elements of OOP[edit]


There are four key elements when designing or writing a program using OOP:

  • Object
  • Class
  • Method
  • Attribute


In OOP, an Object is compound data: it combines other things together into a single bundle. As noted above, what makes the Object unique is that it combines data (e.g. integers, strings, references) with code (i.e. procedures).

In most languages, Objects do not exist in source code: you cannot directly "write down" an object. Instead you must create an Object piece-by-piece, filling-in the individual bits of data and code.

It is important to remember that not only does the Object contain data, but it is also data itself. Once the program starts running, you can freely change the value of any piece of data inside the Object, and in most languages you can also change the elements (data, code) of the Object itself.

Example: Objects

Typical Objects can be things that appear on the screen (e.g., pictures, textboxes, etc.) or things are part of the programming (e.g. actors, connections, particles, etc.).


To use any value (the number 7, the word Apple) we need a data-type. Numbers have a data-type e.g. "integer", and text has a data-type e.g. "string".

To define Objects and work with them in source-code, we need a data-type. Classes are the data-type for Objects. Each Class defines the specific set of data and the specific procedures that will make a particular Object.


Classes as templates[edit]

Because Objects are complex, with many different variables and procedures inside them, Classes are more complex than normal data-types. Most OOP languages give additional features to Classes to help us use them and create them.

Not only does a Class define a data-type for an Object, but it usually defines default values for new Objects. This allows us to use Classes like a template, or biscuit-cutter: a single Class can stamp-out many identical Objects. The Class can even make small changes to each Object as it is created, as we'll see later.

Since Objects are themselves data, each Object can be separately modified after it's created, even though they start out similar or the same.

Example: Classes and Objects
You can use the same class as a template to make (instantiate) many objects
Example: Classes and Objects

Let's take a look at the following example:

class car
  private maxSpeed as integer
  public fuel as integer
  public sub setSpeed(byVal s as integer)
    maxSpeed = s
  end sub
  public function getSpeed() as integer
    return maxSpeed
  end function
  public sub refuel(byVal x as integer)
    console.writeline("pumping gas!")
    fuel = fuel + x
  end sub
  public function getFuel() as integer
    return fuel
  end function
  public sub drive()
    fuel = fuel - 1
  end sub
end class

You can see that the class is called car and it has:

  • two attributes: maxSpeed, fuel
  • five methods
    • three procedures: setSpeed, refuel, drive
    • two functions: getSpeed, getFuel
CPT-OOP-objects and classes - attmeth.svg

Remember this is a class and therefore only a template, we need to 'create' it using an object


Procedures (and Functions) can be created anywhere, and used by any code at any time. In OOP, we want to restrict some Procedures (and Functions) so that they can only act upon the data inside the Object they are attached to. These restricted versions have a special name: Methods.

Every Method is a Procedure, with two special features:

  • We can restrict which source-code is allowed to access the Method, based on the Object the Method is attached to, and the Class that created that Object
  • Methods have access to a special variable that is the Object and/or Class they are attached to. Depending on language, this variable is usually named "self", "this" or "Me" ("self" is used in Delphi/Pascal, Ruby, and (conventionally) in Python, "this" is from Java and C#, "Me" is from VB.Net).


Data can be created anywhere, and used by any code at any time. In OOP, we want to restrict some data so that it can only be acted-upon by the Methods in the same Object. These restricted variables have a special name: Attributes.

Every Attribute is a Variable, with three special features:

  • The Class that creates the Object usually provides a default or starting value for each Attribute
  • Attributes can optionally be hidden from other code
  • Attributes can optionally be made visible to other code, but made uneditable (only the code (Methods) in the Attribute's Object can edit the Attribute)

NB: Attributes are further split into two types: Fields and Properties. All Fields and all Properties are Attributes, but with extra specialization. See the section on Encapsulation for the precise differences.

Example: Attributes

In the example above we store the fuel and maxSpeed.

Putting it together[edit]

Exercise: Object Orientation Intro
What is the difference between a class and an object?


  • A class is a template which cannot be executed
  • An object is an instance of a class which can be executed
  • one class can be used to make many objects
What are the main components of a class?


methods and attributes

What is the difference between a structure and a class


structures don't have methods