OOP for a single class: classes, objects, UML, static members, encapsulation – IB Computer Science exam questions with mark scheme

1Core5 marks

Write a Python class Student with attributes name (a string) and marks (a list of integers), set when an object is created, and a method average() that returns the mean of the marks.

[5]

Class header class Student:(1)
Constructor __init__ with self and parameters for name and marks(1)
Assigns both attributes using self.name and self.marks(1)
Method average defined inside the class with self as its parameter(1)
Returns sum(self.marks) / len(self.marks) (or equivalent loop)(1)

Examiner tip: Attributes need the self. prefix; without it the values are lost when __init__ ends.

2Hard6 marks

A bank wants to encapsulate its account data. Write a Python class BankAccount that:

stores the balance as a private attribute set from an opening balance;
has a method get_balance();
has a method deposit(amount) that only accepts positive amounts;
has a method withdraw(amount) that does not allow the balance to go below zero.

Each method that changes the balance should return True if it succeeded and False otherwise.

[6]

Balance stored as a private attribute (name begins with double underscore, e.g. self.__balance; allow a single leading underscore if the class clearly treats it as non-public)(1)
Constructor takes the opening balance and assigns it(1)
get_balance returns the private attribute(1)
deposit checks amount > 0 before adding to the balance(1)
withdraw checks that the amount does not exceed the balance (balance would not go below zero) before subtracting (a check that the amount is positive is allowed but not required)(1)
Returns True on success and False on failure in both methods(1)

Answer:

class BankAccount:
    def __init__(self, opening):
        self.__balance = opening

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

Examiner tip: The attribute must be hidden (private) and changed only through validated methods; a public balance earns no encapsulation mark.

3Standard4 marks

A program models pets using a class Dog. The object rex = Dog("Rex", 3) is created, where "Rex" is the name and 3 is the age.

(a) Distinguish between a class and an object, using the Dog example. [2]

(b) State two benefits of using an object-oriented approach (classes and objects) when designing a large program. [2]

(a) A class is a template/blueprint that defines the attributes and methods (e.g. Dog defines name and age and behaviours)(1)
An object is a specific instance of a class with its own attribute values (e.g. rex with name 'Rex' and age 3)(1)
(b) Any one benefit from: reusability (a class is written once and used to create many objects or reused in other programs; allow code reuse through inheritance); modularity/easier maintenance (each class can be written, tested and changed separately); team working (different programmers can work on different classes); encapsulation protects an object's data from accidental change; classes model real-world entities, making the design easier to understand(1)
A second, different benefit from the list above (do not award the same idea twice, e.g. 'reuse' and 'less code to write')(1)
Answer: (a) class = blueprint defining attributes and methods; object (rex) = an instance with its own values (b) e.g. classes can be reused; modular code is easier to maintain / share across a team
Examiner tip: Use the Dog example (Dog vs rex) in (a); in (b) name two genuinely different benefits, as vague answers such as 'it is easier' or two versions of 'reuse' score only once or not at all.

Stuck on OOP for a single class: classes, objects, UML, static members, encapsulation?

Get it sorted in a free 30-minute session

We work through your weakest questions on this topic on Zoom. I reply the same day.

Free 30-min session on this topic Send me 5 questions a day

4Core5 marks

The UML class diagram shows the design of a class CinemaTicket used by a cinema booking system. Underlined members are static.

(a) Identify the constructor of the class. [1]

(b) State what the symbol - in front of seat indicates about how seat can be accessed. [1]

(d) State the data type of the value returned by applyDiscount. [1]

(a) CinemaTicket(seat : String, price : double); accept 'the method with the same name as the class'; the name alone is enough(1)
(b) seat is private: it can only be accessed (read or changed) by code inside the CinemaTicket class / not directly from outside the class; accept 'hidden from other classes'(1)
(c) ticketsSold(1)
(c) ticketsSold belongs to the class, so there is only one copy shared by all CinemaTicket objects, whereas each object has its own (separate) value of price; accept 'ticketsSold can be accessed without creating an object / using the class name'(1)
(d) boolean; accept bool; ignore 'True/False'(1)
Answer: (a) CinemaTicket(seat : String, price : double) (b) private: only accessible inside the class (c) ticketsSold; one shared copy for the whole class, whereas every object has its own price (d) boolean
Examiner tip: In UML, underlining marks a static member and the type after the colon on a method is its return type, not the type of its parameter.

5Standard4 marks

A football stadium counts the people entering through each of its turnstiles. The following Java code is used.

public class Turnstile {
    private static int totalEntries = 0;
    private int entries = 0;

    public void admit() {
        entries++;
        totalEntries++;
    }
    public int getEntries() { return entries; }
    public static int getTotalEntries() { return totalEntries; }
}

// in another class
Turnstile north = new Turnstile();
Turnstile south = new Turnstile();
north.admit();
north.admit();
south.admit();
Turnstile east = new Turnstile();
east.admit();
north.admit();
System.out.println(north.getEntries() + " " + south.getEntries() + " " + east.getEntries());
System.out.println(Turnstile.getTotalEntries());

(a) State the two lines of output produced. [2]

(b) Explain why getTotalEntries() can be called using the class name Turnstile, but getEntries() must be called on a particular object. [2]

(a) First line: 3 1 1(1)
(a) Second line: 5(1)
(b) getTotalEntries() is static: it belongs to the class (not to any one object) and only uses the static/class variable totalEntries, so no object is needed(1)
(b) getEntries() is an instance (non-static) method: it returns entries, an instance variable of which each object has its own copy, so it needs a specific object to know whose count to return(1)
Answer: (a) 3 1 1 then 5 (b) getTotalEntries is static and uses only the shared class variable; getEntries reads an instance variable that is different for each object.
Examiner tip: A static variable is shared: it was increased by every admit() call on every turnstile, so it is the sum of the instance counts, not the count for the last object used.

6Standard5 marks

A leisure centre is writing software to manage its lockers. The following design notes have been produced for a class Locker.

Each locker has a locker number (a whole number), a 4-digit PIN (stored as text) and a flag showing whether it is currently locked.
The PIN must not be readable or changeable directly by other classes.
A new locker is created with its number and PIN, and starts unlocked.
Users can lock the locker. To unlock it they must supply a PIN; the method reports whether unlocking succeeded.
Users can ask whether the locker is locked.
The class keeps one count of how many Locker objects have been created.

Construct a UML class diagram for the Locker class. [5]

Three compartments: class name Locker, then attributes, then methods (operations), in that order(1)
Attributes number : int, pin : String and locked : boolean (or similar names) with suitable data types(1)
Attributes shown as private (-), at least pin; and methods shown as public (+)(1)
Constructor Locker(number : int, pin : String) and methods lock(), unlock(pin : String) : boolean and isLocked() : boolean with parameters and return types; accept void for lock()(1)
A static (class) attribute such as lockerCount : int shown underlined (allow labelled 'static' / {static}); a static getter is not required(1)

Answer:

Locker
------------------------------
- lockerCount : int   (underlined)
- number : int
- pin : String
- locked : boolean
------------------------------
+ Locker(number : int, pin : String)
+ lock() : void
+ unlock(pin : String) : boolean
+ isLocked() : boolean

Examiner tip: Students drop the mark for return types and parameters: every method needs '(param : type) : returnType', and the static counter must be underlined.

7Standard5 marks

A smart-home system uses the following two Java classes.

public class Thermostat {
    private double target;
    private static final double MAX = 28.0;

    public Thermostat(double t) { target = t; }
    public void setTarget(double t) {
        if (t <= MAX) { target = t; }
    }
    public double getTarget() { return target; }
    public static double getMax() { return MAX; }
}

public class Home {
    public static void main(String[] args) {
        Thermostat hall = new Thermostat(19.5);          // line 1
        hall.target = 30.0;                              // line 2
        hall.setTarget(30.0);                            // line 3
        System.out.println(Thermostat.getTarget());      // line 4
        System.out.println(Thermostat.getMax());         // line 5
    }
}

(a) The class Home does not compile. Identify the two numbered lines that cause errors and explain the cause of each. [4]

(b) Line 2 is deleted and line 4 is replaced by System.out.println(hall.getTarget());. State the output of the program. [1]

(a) Line 2(1)
(a) target is private, so it cannot be accessed from outside the Thermostat class (from Home); accept 'should use setTarget'(1)
(a) Line 4(1)
(a) getTarget() is an instance (non-static) method, so it cannot be called using the class name / it must be called on an object such as hall; accept 'there is no object for target to belong to'(1)
(b) 19.5 then 28.0 (both lines, in this order); accept 19.5 and 28 if the values are clearly in order; setTarget(30.0) is rejected because 30.0 > MAX(1)
Answer: (a) Line 2: target is private; line 4: getTarget is non-static and called through the class. (b) 19.5 then 28.0
Examiner tip: setTarget(30.0) does not change the target, because 30.0 is above MAX: that validation is the reason the attribute is private.

8Hard7 marks

A courier company charges for parcels by weight. Each parcel is given a unique ID: the first parcel created has ID 1001, the next 1002, and so on.

The charge is £3.50 for a parcel weighing up to and including 2 kg, plus £1.20 for every extra kilogram or part of a kilogram above 2 kg.

(a) Construct a Python class Parcel that:

uses a static (class) variable to generate the IDs;
has a constructor that takes the weight in kg, stores it as a private attribute and gives the object the next ID;
has a method get_id() that returns the ID;
has a method cost() that returns the charge in pounds.

[5]

(b) The objects p1 = Parcel(1.5) and p2 = Parcel(4.2) are the first two parcels created. State the value returned by p2.get_id() and by p2.cost(). [2]

(a) Class variable next_id = 1001 (or similar) declared in the class body, outside any method(1)
(a) Constructor __init__(self, weight) stores the weight in a private attribute, e.g. self.__weight; allow a single underscore(1)
(a) Constructor copies the class variable into an instance attribute and then increments the class variable using the class name, e.g. Parcel.next_id += 1; self.next_id += 1 does not score (it creates an instance attribute and the IDs never change)(1)
(a) get_id returns the object's own ID(1)
(a) cost returns 3.50 when weight ≤ 2, otherwise 3.50 + 1.20 × (weight − 2) rounded up to a whole number of kg, e.g. using math.ceil; accept an equivalent loop or int-plus-one logic that handles exact whole numbers correctly(1)
(b) p2.get_id() returns 1002(1)
(b) p2.cost() returns 7.10 (3.50 + 3 × 1.20); accept 7.1 or £7.10(1)

Answer:

import math

class Parcel:
    next_id = 1001

    def __init__(self, weight):
        self.__weight = weight
        self.__id = Parcel.next_id
        Parcel.next_id += 1

    def get_id(self):
        return self.__id

    def cost(self):
        if self.__weight <= 2:
            return 3.50
        return 3.50 + 1.20 * math.ceil(self.__weight - 2)

(b) 1002 and 7.10

Examiner tip: The counter must be updated through the class name; writing self.next_id += 1 gives every parcel the same ID.

9Hard4 marks

Two programming tasks are being planned.

Task A: a 30-line script, written by one student and used once, that renames all the photos in a folder by adding the date to each file name.
Task B: a ticketing system for a theatre chain, developed by a team of eight programmers and maintained for several years. It must model seats, performances and customers.

Evaluate the use of an object-oriented approach for Task A and for Task B. [4]

Task B advantage: real-world entities (seats, performances, customers) map naturally onto classes, and each class can be developed and tested separately by different team members (modularity)(1)
Task B advantage: encapsulation hides each class's data behind methods, so one programmer can change how a class works internally without breaking other programmers' code / makes long-term maintenance easier; accept reuse of a class (e.g. many Seat objects from one class)(1)
Task A disadvantage: designing classes adds extra code, planning and complexity (overhead) that brings little benefit for a short, one-off script with no real objects to model; accept 'slower to write' / 'extra memory or processing overhead'(1)
Reasoned conclusion: OOP is well suited to Task B but unnecessary for Task A, where a simple procedural script is quicker and clearer(1)
Answer: OOP suits Task B (classes model the real entities, modularity for a team, encapsulation aids long-term maintenance) but is an unnecessary overhead for the short one-off Task A, where a procedural script is better.
Examiner tip: 'Evaluate' needs both sides and a judgement: listing OOP advantages without saying when it is NOT worth it caps the answer at 2.

10Stretch5 marks

A conference app should count how many visitor badges have been issued. A programmer writes this Python code.

class Badge:
    issued = 0

    def __init__(self, name):
        self.name = name
        self.issued += 1

a = Badge("Ana")
b = Badge("Ben")
print(a.issued, b.issued, Badge.issued)

(a) State the output of the program. [1]

(b) Explain why Badge.issued does not show the number of badges created. [2]

(d) State the output after the correction in (c). [1]

(a) 1 1 0(1)
(b) self.issued += 1 first reads issued through the object; there is no instance attribute yet, so the class variable's value (0) is read(1)
(b) the assignment then creates a new instance attribute issued (value 1) on that object, which hides/shadows the class variable; the class (static) variable itself is never changed, so it stays 0(1)
(c) Badge.issued += 1; accept type(self).issued += 1 or self.__class__.issued += 1(1)
(d) 2 2 2(1)
Answer: (a) 1 1 0 (b) the += reads the class value 0 but assigns to a new instance attribute, so the class variable is never updated (c) Badge.issued += 1 (d) 2 2 2
Examiner tip: In Python, assigning through self always creates or changes an instance attribute; a class (static) variable must be updated through the class name.

Stuck on this topic?

Book a free 30-minute session on WhatsApp and we'll find exactly which step is costing you the marks. Or build a timed paper on it.

Free 30-minute session