TYPE CarRecord 
    DECLARE VehicleID             : STRING
    DECLARE Registration          : STRING
    DECLARE DateOfRegistration    : DATE
    DECLARE EngineSize            : INTEGER
    DECLARE PurchasePrice         : CURRENCY
ENDTYPE

PROCEDURE UpdateRegistration(BYREF ThisCar : CarRecord, BYVALUE NewRegistration)
    ThisCar.Registration ← NewRegistration 
ENDPROCEDURE

• OOP goes one step further and groups together the data structure and the subroutines that operate on the data items in this data structure. Such a group is called an object.
• The data of an object are called attributes and the subroutines acting on the attributes are called methods.
• The idea behind OOP is that attributes can only be accessed through methods.The direct path to the data is unavailable. Attributes are referred to as ‘private’. The methods to access the data are made available to programmers, so these are ‘public’. The feature of data being combined with the subroutines acting on this data is known as encapsulation.
• To use an object, we first define an object type. An object type is called a class.
• Classes are templates for objects. When a class type has been defined it can be used to create one or more objects of this class type. Therefore, an object is an instance of a class.
• The first stage of writing an object-oriented program to solve a problem is to design the classes.

• Getter
  • Any data that is held about an object must be accessible, otherwise there is no point in storing it. We therefore need methods to access each one of these attributes. These methods are usually referred to as getters. They get an attribute of the object.
• Constructor
  • When we first set up an object of a particular class, we use a constructor. A constructor instantiates the object and assigns initial values to the attributes.
• Setter
  • Any attributes that might be updated after instantiation will need subroutines to update their values. These are referred to as setters.
• Property
  • A property combines the attribute with its associated setter and/or getter

Attributes should always be declared as ‘Private’. This means they can only be accessed through the class methods. So that the methods can be called from the main program, they have to be declared as ‘Public’. There are other modifiers (such as ‘Protected’), but they are beyond the scope of this book.

To use an object of a class type in a program the object must first be instantiated. This means the memory space must be reserved to store the attributes.

ThisCar = Car("ABC1234", 2500)

To call a method in program code, the object identifier is followed by the method identifier and the parameter list.

# sets the purchase price for an object ThisCar of class Car.
ThisCar.SetPurchasePrice(12000) 
ThisCar.PurchasePrice = 12000 # using properties
# gets and prints the vehicle ID for an object ThisCar of class Car.
print(ThisCar.GetVehicleID()) 
print(ThisCar.VehicleID) # using properties

The advantage of OOP is that we can design a class (a base class or a superclass) and then derive further classes (subclasses) from this base class. This means that we write the code for the base class only once and the subclasses make use of the attributes and methods of the base class, as well as having their own attributes and methods.

• A college library has items for loan.
• The items are currently books and CDs.
• Items can be borrowed for three weeks.
• If a book is on loan, it can be requested by another borrower.

ThisBook = Book(Title, Author, ItemID) 
ThisCD = CD(Title, Artist, ItemID)

To include the additional attributes from the subclass, we need to declare the method again. Although the method in the subclass will have the same identifier as in the base class, the method will actually behave differently. This is known as polymorphism.

When objects are created they occupy memory. When they are no longer needed, they should be made to release that memory, so it can be re-used. If objects do not let go of memory, we eventually end up with no free memory when we try and run a program. This is known as ‘memory leakage’.

Memory management involves a private heap containing all Python objects and data structures. The management of the Python heap is performed by the interpreter itself. The programmer does not need to do any housekeeping.