The four pillars of object orientation - encapsulation with access modifiers, inheritance and class hierarchies, polymorphism through method overriding, and abstraction.

What this dot point is asking

CCEA expects you to explain the four pillars of the object oriented paradigm: encapsulation, inheritance, polymorphism and abstraction. For each you must give a precise definition, the mechanism that achieves it (access modifiers, class hierarchies, method overriding), and a benefit to the developer. These concepts recur throughout the course and are favourite extended-answer questions, so learn the keywords exactly.

The answer

Encapsulation

Access is controlled by access modifiers. A private member is reachable only from inside its own class; a public member is reachable from anywhere. Private attributes are read and written through public accessor (getter) and mutator (setter) methods, which can validate input before it is stored.

Inheritance

Inheritance lets a new class, the subclass (child), acquire the attributes and methods of an existing class, the superclass (parent), and then add or modify features of its own. This builds a class hierarchy in which shared behaviour lives near the top and specialised behaviour lower down. Its main benefit is code reuse: common features are written once and shared.

class Account                  // superclass
  attributes: balance
  methods: deposit(a), withdraw(a)

class SavingsAccount extends Account   // subclass
  attributes: interestRate
  methods: addInterest()               // new behaviour, plus all of Account's

Polymorphism and abstraction

Polymorphism ("many forms") means the same method name behaves differently depending on the object it is called on. It is achieved by method overriding: a subclass redefines an inherited method with the same name and parameters but a different body. A call such as shape.area() then runs the version belonging to the object's actual class.

Abstraction is the modelling of only the essential features of a thing while hiding unnecessary detail. A class is itself an abstraction: a Car class exposes accelerate() and brake() without the driver needing to know how the engine works. Abstraction reduces complexity and lets developers reason at a high level.

Worked example: a shape hierarchy using all four pillars

Examples in context

Example 1. A staff payroll system. A general Employee superclass holds name and salary (private) with a calculatePay() method. Manager and SalesRep subclasses inherit these and override calculatePay() to add a bonus or commission. A payroll loop calls calculatePay() on a list of Employee objects, and polymorphism runs the right rule for each, while encapsulation keeps salaries from being altered directly.

Example 2. A drawing application. Every tool (pen, brush, eraser) is a subclass of an abstract Tool with an overridden apply() method. The canvas keeps a list of Tool objects and calls apply() without caring which tool it is. Abstraction lets new tools be added later just by writing another subclass, with no change to the canvas code.

Try this

Q1. State what is meant by encapsulation and name the access modifier used to hide an attribute. [2 marks]

• Cue. Bundling attributes with their methods and hiding the attributes from outside code; the modifier is private.

Q2. A Vehicle class has a method move(). A Car subclass redefines move() with its own behaviour. Name this mechanism and the principle it supports. [2 marks]

• Cue. Method overriding; it supports polymorphism.

Q3. Give one benefit of abstraction to a developer working on a large system. [1 mark]

• Cue. It reduces complexity by exposing only essential features, so the developer can work at a high level without unnecessary detail.