The purpose of this document is to give a quick overview of what
Object Oriented programming/design is about.
Programming languages usually implement an object as a class.
An object holds methods to do something
An object holds members (data about itself).
A person object has properties (or members) such as:
- Current thought
It can have methods such as
- Wake up
- Eat breakfast
- Eat lunch
- Go to bed
Encapsulation embodies an object's behaviour. For example the exercise
method could change the person's weight property. Also changing
a person's age property could also cause the IsRetired property
Encapsulation is the term used to describe that a class encapsulates
all aspects of an object. OO languages achieve this by way of methods
A class can inherit another "superclass". This allows
a class to use the functionality in another class, and add its own
bits on top. In this way we do not have to rewrite common code in
all our class descriptions.
class man extends person
The man class inherits all the person characteristics. The person
class is the topmost class in the inheritance hierarchy, and is
known as a base class (the person class does not inherit from any
The man class adds the following properties:
We can also add methods such as
class Woman extends person
Since man and woman both "extend" person, they inherit
all of a person's (base class) characteristics. They have an age,
height, and they can eat breakfast....
With inheritance it is possible to pass an object as an instance
of a superclass. For example, we could pass a woman object to another
object which expects a person object. Polymorphism allows the characteristics
of the super class to be overridden. For example:
A priest object has a method: marryCouple(person1, person2). Where
person1 happens to be a man, and person2 happens to be a woman.
The body of the priest's marry method does the following:
- calls marry on person1
- calls marry on person2
Through polymorphism, marry on the man calls the person's marry
method. Whereas on the woman's class it calls the woman's marry
method. In effect changing the woman's person title to Mrs. That's
polymorphism, the priest need not know the difference between a
man and a woman to call the marry method. The marry method called
is not the same one for the man and the woman.
An object, its members and its methods can be assigned some kind
of programming access. C++ and Java allow for public, protected
and private access controls. Be aware that the defaults are different
in both languages.
- public means that any class type can access the member/method/class
- protected means that the defining class and any classes which
inherit from the class can access the protected member
- private means that the member is not accessible from other class
types, even if they inherit it.
C++ adds friends. In essence a class can specify what friends (other
class types) can have access to its privates.
Java adds the package access control. Only classes defined in the
same package can access each other's members with a package access
Constructors & Destructors
When a class is instantiated, i.e. a variable of that class is
created, it is possible to write a method that does something, such
as connecting to a database. When a class variable is destroyed,
it is also possible to write a method to do something. This is a
neat way of making sure that:
- When an object is created, it is ready to be used. No additional
steps need to be taken to initialise the object.
- When an object is destroyed, the object cleans up any resources
it has taken up.
Abstract classes are classes where most, but not all of the implementation
is there. An abstract class cannot be created directly, it can only
be used via another class which inherits from the abstract class,
and which implements the abstract bits.
For example, we could define the marry method in person as abstract.
This means that a person object cannot be created, and that man
and woman should both implement a marry method.
An interface has no code implementation. It simply gives a list
of methods. Classes can implement an interface, and hence be passed
around as instances of the interface.
Interfaces are a powerful way of laying down a set of rules without
actually implementing them. They're a bit like abstract classes,
where all the methods are abstract.
Pattern based programming design and interfaces go hand in hand.
Using this technology we can expose a module of code using only
interfaces. All implementation is hidden. Hence we can change an
implementation at will without affecting other modules which only
use the interfaces to access the functionality. That is essentially
how, for example we could write code to access Oracle, Sybase,....
without needing to worry about which DBMS it actually is.