Classes & Objects

A class consists of a collection of states (a.k.a. attributes or properties) and behaviours (a.k.a. methods).

An object is an instance of a class. The attributes of an object are stored using variables for storing data and the behaviour/methods of an object are implemented as functions or procedures and can be used to perform operations on the data.

Constructor

Superhero Class

Superhero Class

• name (String)
• superpower (String)
• strength (Integer)

Some of the methods of a superhero are:

• init() – This is the constructor which may take some parameters used to initialise the default values of the superhero to be created.
• walk()
• run()
• jump()

The diagram on the right represents the Superhero Class with its attributes and its methods. Note that we do not need to represent the constructor on this diagram as it is assumed that all classes have a constructor. (In Python the constructor of a class is the __init__() function.)

Instantiating Objects from the Superhero Class

spiderman = new Superhero("Spiderman","Wrist web-shooters to shoot spider web material",10)
batman = new Superhero("Batman","Night vision",10)
superman = new Superhero("Superman","Can fly",20)

Naming Convention

Inheritance

For instance, let’s consider an online shop that sells different types of products (items) such as DVDs, Books, and Mp3s.

Item Class

• Attributes: name, description, price
• Methods: viewFullDescription(), addToShoppingBasket(), removeFromShoppingBasket()

Sub-classes can then be defined with additional attributes and methods which are more specific. For instance:

MP3 Class:
• Attributes: artist, duration
• Methods: play(), download()

DVD Class:

• Attributes: certificate, duration, actors
• Methods: viewTrailer()

Book Class:

• Attributes: author, genre, numberOfPages
• Methods: previewContent()

The MP3, DVD and Book sub-classes will inherit the properties and methods of the parent class (Item) as represented in green below.

MP3 Class:
• Attributes: name, description, price, artist, duration
• Methods: viewFullDescription(), addToShoppingBasket(), removeFromShoppingBasket(), play(), download()

DVD Class:

• Attributes: name, description, price, certificate, duration, actors
• Methods: viewFullDescription(), addToShoppingBasket(), removeFromShoppingBasket(), viewTrailer()

Book Class:

• Attributes: name, description, priceg, author, genre, numberOfPages
• Methods: viewFullDescription(), addToShoppingBasket(), removeFromShoppingBasket(), previewContent()

Class Diagram

Terminology

Multiple Inheritance

For example we could have a class representing hybrid cars, that would inherit the properties and method of both electric cars and petrol cars.

Encapsulation

Private vs. Public

A private attribute or a private method can only be accessed from methods of the class. They cannot be directly accessed from outside the class.

A public attribute or a public method can be accessed from anywhere (other methods of the class or from outside the class).

For instance, let’s consider a Car class with the following attributes and methods:

In our car racing game, we would instantiate an object called playerCar from this Car class.

playerCar = new Car("Mini","Cooper")

If all methods and properties are declared as public, then we would be able to access them from anywhere in the code. e.g.

playerCar.speed = 70
playerCar.fuelLevel = 45
playerCar.accelerate(5) # increase speed by 5mph
playerCar.drive(10) # drive 10 miles
PRINT("Your current fuel level is:"
PRINT playerCar.fuelLevel

However, it is considered good practice to “hide” some properties or methods from the “outside world” by making these private. In this case these private properties and methods cannot be accessed from outside the class.

For instance, in the example above, we may decide that both attributes speed and fuelLevel should be set at private. In this case none of the following three lines would compile and hence these would have to be removed:

playerCar.speed = 70
playerCar.fuelLevel = 45
PRINT playerCar.fuelLevel

We could still alter the content of the fuelLevel and the speed of the car in the code of the fillUp(), accelerate(), slowDown() and drive() methods of the car.

playerCar.fillUp(45) # Add 45 litres of petrol in the tank
playerCar.accelerate(50) # increase speed by 50mph
playerCar.drive(10) # drive 10 miles

Getters and Setters

For instance, to retrieve the fuelLevel of the player car we could have a new public method called getFuelLevel() and use it to inform the user of how much petrol they have left in their tank.

PRINT "Your current fuel level is:"
PRINT player.getFuelLevel()

We may also define a setter for this property in case we want to give an option for the player to reset their tank to a specific value or to empty it. e.g.

player.setFuelLevel(0) # Emptying the fuel tank

Note that using setters is also useful to prevent direct access to a property and implement validation checks within the setter methods.

For instance if the fuelLevel was a public property then the following code would be accepted even though a car cannot have 999 litres of petrol (999 > tankCapacity)!

playerCar.fuelLevel = 999

By making the fuelLevel property private and forcing the use of a setFuelLevel() public method (setter), we can implement in the code of the setFuelLevel() method a validatiom check that cannot be bypassed to ensure that the parameter given is a positive number, lower or equal to the tankCapacity. e.g.

FUNCTION setFuelLevel(quantity)
    IF quantity<0 THEN
        fuelLevel = 0
    ELSE IF quantity > tankCapacity THEN
        fuelLevel = tankCapacity
    ELSE
        fuelLevel = quantity
    END IF
END FUNCTION

The setter could then be used in our code as follows:

playerCar.setFuelLevel(45) # reset fuel level to 45 litres

Polymorphism

Over-Riding Polymorphism

On occasions, as this is the case in our example, the drive() method of the Car class is only defined but not implemented at all (an empty function, without code) in the Car class. It will be overwritten and properly implemented in the sub classes instead.

Over-Loading Polymorphism

For instance, let’s consider our Superhero class to which we would like to add a method to set the Date of Birth (DoB) of a superhero. We could write this same method several times to accept different parameters such as:

The method could accept a date parameter as a string in the “DD/MM/YYYY” format.

PROCEDURE setDoB(string:date) # date in DD/MM/YYYY format

e.g.

spiderman.setDob("15/08/1962")

The same method can be implemented a second time, taking three parameters as follows:

PROCEDURE setDoB(integer:day, integer:month, integer:year)

e.g.

spiderman.setDob(15,08,1962)

Having multiple implementations of the same method to accept different parameters (different number of parameters or parameter of different data types) is called over-loading polymorphism.

Abstract Classes

For instance, let’s revisit the online shopping system where we are selling three types of items: MP3s, DVDs and Books. The MP3 class, DVD class and Book class inherit from the parent Item class. Objects will be instantiated from the MP3 class, DVD class or Book class. We will never instantiate an object directly from the Item class. This is why the Item class is called an abstract class.

So to sum up, an abstract class:

• Cannot be instantiated directly.
• Can only be used through inheritance.