Revision Library

revisionlibrary.co.uk

A-Level · Computer Science - Programming Paradigms and Object-Oriented Programming

A2.4 Programming Paradigms and OOP

OCR H446 · Calculators not allowed · about 100 minutes

Total Marks

Name: _______________________________ Date: ____ / ____ / ______

Answer ALL questions. Show all your working.

A programming paradigm is a general style or approach used to structure a solution to a problem. Different paradigms lead to programs being organised in very different ways, even when solving the same problem.

(a)Define what is meant by a 'programming paradigm'.(1)

(b)State one feature of procedural programming.(1)

(c)State one feature of object-oriented programming.(1)

(d)State one feature of functional programming.(1)

(Total for Question 1 is 4 marks)

A small program for a Bristol newsagent totals up the cost of a customer's magazines. It is written using OCR's Exam Reference Language conventions (assignment <-, iteration FOR ... NEXT, selection IF ... ENDIF).

PROCEDURE CalculateTotal(price, quantity)
  total <- price * quantity
  RETURN total
ENDPROCEDURE

PROCEDURE PrintReceipt(item, price, quantity)
  total <- CalculateTotal(price, quantity)
  OUTPUT item, " x ", quantity, " = GBP ", total
ENDPROCEDURE

CALL PrintReceipt("Weekly Puzzle Magazine", 2.50, 4)

(a)Identify the programming paradigm used in the code above.(1)

(b)Give two reasons for your answer to part (a), referring directly to the code.(2)

(c)State one change that would need to be made to this code for it to become object-oriented.(1)

(Total for Question 2 is 4 marks)

A school in Preston is building a simple pseudocode class to represent a student's exam mark. The starting point is shown below, using OCR's Exam Reference Language class conventions.

CLASS ExamResult
  PRIVATE mark : INTEGER

PUBLIC PROCEDURE NEW(startingMark)

    mark <- startingMark
  ENDPROCEDURE

PUBLIC FUNCTION GetMark() RETURNS INTEGER

    RETURN mark
  ENDFUNCTION
ENDCLASS

(a)Identify which attribute of ExamResult is encapsulated, and state the keyword in the code that enforces this.(2)

(b)Explain why mark is declared PRIVATE rather than PUBLIC in this class.(2)

(c)Complete the pseudocode for a public procedure SetMark(newMark) that only updates mark if newMark is between 0 and 100 inclusive; otherwise it should output an error message and leave mark unchanged.(2)

(Total for Question 3 is 6 marks)

A secondary school in Norwich wants a pseudocode class to represent a book held in its school library.

(a)Write pseudocode for a class LibraryBook with four private attributes: title (STRING), author (STRING), isbn (STRING) and isOnLoan (BOOLEAN); and a constructor PROCEDURE NEW(t, a, i) that sets title, author and isbn from its parameters and sets isOnLoan to FALSE.(3)

(b)Write a public procedure BorrowBook() for LibraryBook that sets isOnLoan to TRUE and outputs a confirmation message if the book is not already on loan; otherwise it should output a message stating the book is already on loan and leave isOnLoan unchanged.(3)

(Total for Question 4 is 6 marks)

A payroll system for a chain of shops in Glasgow uses a class Employee, shown below, and needs a subclass Teacher for staff at the company's in-house training academy.

CLASS Employee
  PRIVATE name : STRING
  PRIVATE salary : REAL

PUBLIC PROCEDURE NEW(n, s)

    name <- n
    salary <- s
  ENDPROCEDURE

PUBLIC FUNCTION GetDetails() RETURNS STRING

    RETURN name + ", salary GBP " + STR(salary)
  ENDFUNCTION
ENDCLASS

(a)Complete the class header line below so that Teacher inherits from Employee and adds one new private attribute subject (STRING).

CLASS Teacher ______
  PRIVATE subject : STRING
  ...
ENDCLASS

(2)

(b)Write pseudocode for Teacher's constructor PROCEDURE NEW(n, s, subj), which should call the Employee constructor to set name and salary, then set subject from its own parameter.(3)

(c)Explain what is meant by 'method overriding', using a version of GetDetails written for Teacher as your example.(2)

(Total for Question 5 is 7 marks)

A graphics package for a design studio in Manchester defines a superclass Shape and two subclasses, Circle and Rectangle, each overriding a function CalculateArea.

CLASS Shape
  PUBLIC FUNCTION CalculateArea() RETURNS REAL
    RETURN 0
  ENDFUNCTION
ENDCLASS

CLASS Circle INHERITS Shape
  PRIVATE radius : REAL
  PUBLIC PROCEDURE NEW(r)
    radius <- r
  ENDPROCEDURE
  PUBLIC FUNCTION CalculateArea() RETURNS REAL
    RETURN pi * radius ^ 2
  ENDFUNCTION
ENDCLASS

CLASS Rectangle INHERITS Shape
  PRIVATE width : REAL
  PRIVATE height : REAL
  PUBLIC PROCEDURE NEW(w, h)
    width <- w
    height <- h
  ENDPROCEDURE
  PUBLIC FUNCTION CalculateArea() RETURNS REAL
    RETURN width * height
  ENDFUNCTION
ENDCLASS

A list shapes contains a mixture of Circle and Rectangle objects. The following loop is used to print each shape's area:

FOR EACH s IN shapes
  OUTPUT s.CalculateArea()
NEXT s

(a)Explain what is meant by polymorphism in object-oriented programming, referring to the Shape, Circle and Rectangle classes above.(3)

(b)Using the loop given in the question, explain why the code that processes the shapes list does not need to know whether each item is a Circle or a Rectangle.(3)

(Total for Question 6 is 6 marks)

A vehicle-hire company in Oxford models its fleet using the classes below.

CLASS Vehicle
  PROTECTED make : STRING

PUBLIC PROCEDURE NEW(m)

    make <- m
  ENDPROCEDURE

PUBLIC FUNCTION Describe() RETURNS STRING

    RETURN make + ": generic vehicle"
  ENDFUNCTION
ENDCLASS

CLASS Car INHERITS Vehicle
  PUBLIC FUNCTION Describe() RETURNS STRING
    RETURN make + ": car, 4 wheels"
  ENDFUNCTION
ENDCLASS

CLASS Motorbike INHERITS Vehicle
  PUBLIC FUNCTION Describe() RETURNS STRING
    RETURN make + ": motorbike, 2 wheels"
  ENDFUNCTION
ENDCLASS

The following driver program is then run:

fleet <- []

fleet.APPEND(NEW Vehicle("Generic Co"))
fleet.APPEND(NEW Car("Skoda"))
fleet.APPEND(NEW Motorbike("Triumph"))

FOR EACH v IN fleet
  OUTPUT v.Describe()
NEXT v

(a)State the three lines of output produced by the driver program, in the order they are produced.(4)

(b)Explain why the second and third lines of output use the overridden versions of Describe() in Car and Motorbike, rather than the version defined in Vehicle, even though the loop only ever calls v.Describe().(4)

(Total for Question 7 is 8 marks)

A small business owner in Cardiff is developing a new student grade-tracking system for a secondary school. They are deciding whether to use the procedural paradigm or the object-oriented paradigm to build it. The system must store many students' names, subjects and marks, calculate averages and grade boundaries, and will be extended over several years by different developers as new features (e.g. attendance tracking) are added.

(a)Compare and contrast the procedural and object-oriented approaches for developing this grade-tracking system, discussing at least two relevant factors (for example: maintainability, code reuse, protection of data, or suitability for a system that will be extended by a team of developers over time).(8)

(Total for Question 8 is 8 marks)

A weather-logging tool for a network of stations across the UK uses functions to process a list of daily temperature readings (in degrees Celsius).

globalTotal <- 0

FUNCTION AddToGlobalTotal(x) RETURNS REAL
  globalTotal <- globalTotal + x
  RETURN globalTotal
ENDFUNCTION

FUNCTION CelsiusToFahrenheit(c) RETURNS REAL
  RETURN (c * 9 / 5) + 32
ENDFUNCTION

(a)Define what is meant by a 'pure function' in functional programming.(2)

(b)State one benefit of avoiding mutable/global state when writing functions.(2)

(c)Identify which of the two functions given in the question, AddToGlobalTotal or CelsiusToFahrenheit, is impure, and give a reason for your answer.(2)

(Total for Question 9 is 6 marks)

A car-leasing company in Leicester wants to model different types of vehicle and calculate their estimated annual running cost.

(a)Write pseudocode for a class Vehicle with one private attribute annualMileage (REAL), a constructor PROCEDURE NEW(miles) that sets annualMileage, and a public function CalculateRunningCost() RETURNS REAL that simply returns 0 (this will be overridden by every subclass).(4)

(b)Write pseudocode for a subclass ElectricCar that inherits from Vehicle, and overrides CalculateRunningCost() so that it returns annualMileage multiplied by a fixed cost of 0.04 (pounds per mile for electricity).(3)

(c)Write a procedure PrintTotalRunningCost(vehicles) that takes a list of Vehicle (and/or subclass) objects and outputs the total combined running cost of every vehicle in the list, using polymorphism so that it works correctly whatever mixture of vehicle subclasses the list contains.(3)

(Total for Question 10 is 10 marks)

A developer is designing a class hierarchy for a delivery-tracking system and is considering whether a DeliveryDriver class should inherit from both a Person class and a VehicleOperator class (multiple inheritance), or whether it would be better to keep the hierarchy simpler.

(a)Discuss one potential problem that can arise from using multiple inheritance (a class inheriting directly from two or more superclasses).(3)

(b)Discuss one potential problem that can arise from overusing deep inheritance hierarchies in general (a long chain of subclasses inheriting from subclasses), even without multiple inheritance.(3)

(Total for Question 11 is 6 marks)

A leisure centre in Swansea wants a new booking system for its fitness classes. Classes have different formats: some are individually instructed sessions (e.g. personal training), and some are group sessions (e.g. spin classes, yoga) with a fixed maximum number of participants. The centre expects to add further class formats in future years and wants the system to be easy to maintain and extend.

(a)Design an object-oriented model for this booking system. Your answer should describe (in words and/or pseudocode) at least: a base class shared by all class formats, two subclasses with genuinely different (polymorphic) behaviour, appropriate encapsulation with validated attributes, and a justification of why an object-oriented approach suits a system that will keep being extended with new class formats.(10)

(Total for Question 12 is 10 marks)

Mark scheme · A2.4 Programming Paradigms and OOP

Question 1

(a) B1 a fundamental style/approach/model of programming that determines how a solution is structured and how it is written (oe)
(a) Answer: A programming paradigm is a fundamental style or approach to structuring and writing a program, such as procedural, object-oriented or functional.
(b) B1 code is organised as a sequence of instructions grouped into procedures/functions that are called in turn (oe); accept: uses global/shared data that procedures act on
(b) Answer: Procedural programs are built from a sequence of procedures/functions that are called to carry out steps in order.
(c) B1 data and the methods that act on it are bundled together into objects (encapsulation); accept inheritance or polymorphism as an alternative feature (oe)
(c) Answer: Data and the methods that operate on it are bundled together into objects created from classes.
(d) B1 programs are built by applying/composing (pure) functions, avoiding changing state or mutable/global data (oe); accept reference to higher-order functions
(d) Answer: Functional programs are built by applying and combining functions, generally avoiding changing state or mutable data.

Question 2

(a) B1 procedural (programming) cao
(a) Answer: Procedural programming.
(b) B1 the code is organised as procedures (CalculateTotal, PrintReceipt) that are called in sequence/one from another (oe)
(b) B1 there are no classes or objects defined; data (price, quantity, total) is passed directly as parameters rather than being bundled with methods (oe)
(b) Answer: The code uses two procedures that call each other in sequence, and there are no classes or objects; data is simply passed between procedures as parameters.
(c) B1 define a class (e.g. Receipt or Item) that bundles the item's data (item, price, quantity) together with methods such as CalculateTotal and PrintReceipt (oe)
(c) Answer: Create a class, for example Receipt, whose attributes hold item, price and quantity, and whose methods include CalculateTotal and PrintReceipt.

Question 3

(a) B1 mark cao
(a) B1 PRIVATE cao
(a) Answer: The mark attribute; encapsulation is enforced by declaring it PRIVATE.
(b) B1 it prevents other parts of the program from directly accessing/changing mark from outside the class (oe)
(b) B1 access must instead go through the class's own methods (e.g. GetMark), which can validate/control how the attribute is read or changed, protecting the integrity of the data (oe)
(b) Answer: Declaring mark PRIVATE stops other code from reading or changing it directly; instead it can only be accessed through the class's own methods, which can validate any change and protect the data's integrity.
(c) M1 uses an IF statement to test newMark ≥ 0 AND newMark ≤ 100 (oe)
(c) A1 correctly assigns mark <- newMark only inside the TRUE branch, with an ELSE branch that outputs an error message and does not change mark

  IF newMark >= 0 AND newMark <= 100 THEN
    mark <- newMark
  ELSE
    OUTPUT "Error: mark must be between 0 and 100"
  ENDIF
ENDPROCEDURE

Question 4

(a) M1 declares all four attributes as PRIVATE with appropriate types (title, author, isbn as STRING; isOnLoan as BOOLEAN)
(a) M1 constructor correctly assigns the three parameters to title, author and isbn
(a) A1 constructor correctly initialises isOnLoan to FALSE; overall class syntax logically complete (ignore minor syntax errors)

(a) Answer:

CLASS LibraryBook
  PRIVATE title : STRING
  PRIVATE author : STRING
  PRIVATE isbn : STRING
  PRIVATE isOnLoan : BOOLEAN

PUBLIC PROCEDURE NEW(t, a, i)

    title <- t
    author <- a
    isbn <- i
    isOnLoan <- FALSE
  ENDPROCEDURE
ENDCLASS

(b) M1 uses an IF statement to test isOnLoan = FALSE (or NOT isOnLoan)
(b) M1 TRUE branch sets isOnLoan <- TRUE and outputs a confirmation message
(b) A1 ELSE branch outputs a message that the book is already on loan and does not change isOnLoan; overall logic complete (ignore minor syntax errors)

(b) Answer:PUBLIC PROCEDURE BorrowBook()

  IF isOnLoan = FALSE THEN
    isOnLoan <- TRUE
    OUTPUT "Book borrowed successfully"
  ELSE
    OUTPUT "This book is already on loan"
  ENDIF
ENDPROCEDURE

Question 5

(a) M1 uses an inheritance keyword linking Teacher to Employee (e.g. INHERITS)
(a) A1 CLASS Teacher INHERITS Employee cao
(a) Answer: CLASS Teacher INHERITS Employee
(b) M1 constructor header PUBLIC PROCEDURE NEW(n, s, subj) with three parameters
(b) M1 calls the superclass constructor, e.g. SUPER.NEW(n, s), to set name and salary
(b) A1 assigns subject <- subj after the SUPER call; overall logic complete (ignore minor syntax errors)
(b) Answer:PUBLIC PROCEDURE NEW(n, s, subj)
SUPER.NEW(n, s)
```
  subject <- subj
ENDPROCEDURE
```
(c) B1 method overriding is when a subclass defines its own version of a method that already exists in its superclass, replacing that inherited behaviour when called on an object of the subclass (oe)
(c) B1 e.g. Teacher could define its own GetDetails() that also includes subject in the returned string, so calling GetDetails() on a Teacher object uses Teacher's version rather than Employee's (oe)
(c) Answer: Method overriding is when a subclass provides its own implementation of a method inherited from its superclass, so that version runs instead. For example, Teacher could override GetDetails() to also include subject, so calling GetDetails() on a Teacher object returns extra information not present in Employee's version.

Question 6

(a) B1 polymorphism means objects of different classes can be treated through a common interface/superclass, while each responds to the same method call in its own way (oe)
(a) B1 here, Circle and Rectangle both inherit from Shape and both override CalculateArea, so both types of object can be treated as Shape objects (oe)
(a) B1 calling CalculateArea() on a Circle object runs Circle's version, and calling it on a Rectangle object runs Rectangle's version, even though the same method name/call is used (oe)
(a) Answer: Polymorphism means that objects of different classes can be treated through a shared superclass/interface, but each still responds to a call in its own way. Here, Circle and Rectangle both override CalculateArea from Shape, so calling CalculateArea() on either type of object uses that object's own version of the method, even though the same method name is used throughout.
(b) B1 every object in shapes is treated simply as a Shape, since Circle and Rectangle both inherit from Shape (oe)
(b) B1 the loop calls s.CalculateArea() the same way for every element, without checking or needing to know its exact class (oe)
(b) B1 because of polymorphism/dynamic (run-time) method binding, the correct overridden version of CalculateArea for that object's actual class is automatically called (oe)
(b) Answer: Because Circle and Rectangle both inherit from Shape, every element of shapes can be treated as a Shape and called in exactly the same way with s.CalculateArea(). The program does not need to check each object's exact class, because polymorphism (dynamic method binding) ensures the correct overridden version of CalculateArea runs automatically for whichever type of object it actually is.

Question 7

(a) B1 "Generic Co: generic vehicle"
(a) B1 "Skoda: car, 4 wheels"
(a) B1 "Triumph: motorbike, 2 wheels"
(a) B1 all three lines given in the correct order matching the order objects were appended to fleet
(a) Answer:Generic Co: generic vehicle
Skoda: car, 4 wheels
Triumph: motorbike, 2 wheels
(b) B1 each element of fleet is declared/stored as a Vehicle type but actually refers to an object of its real (sub)class, Car or Motorbike (oe)
(b) B1 when v.Describe() is called, the program does not simply use Vehicle's method because the object's actual class defines its own version (oe)
(b) B1 this is dynamic (run-time) method binding/dispatch, where the version of the method that is run is decided by the object's actual class at run time, not by the declared type used to store the reference (oe)
(b) B1 this is exactly what allows polymorphism: the same call v.Describe() behaves differently depending on which class of object v actually refers to at that point in the loop (oe)
(b) Answer: Each element of fleet is stored using the general Vehicle type, but it actually refers to an object of its true class, Car or Motorbike. When v.Describe() is called, dynamic (run-time) method binding means the version that runs is chosen according to the object's real class, not its declared type, so Car's and Motorbike's own overridden Describe() methods are used. This is exactly what allows the same call v.Describe() to behave differently for each object, which is polymorphism in action.

Question 8

(a) L1 (1-2): Basic, isolated points are made about procedural and/or object-oriented programming, with little or no reference to the grade-tracking scenario. The answer may simply define the paradigms with no comparison.
(a) L2 (3-5): Some relevant points of comparison are made between procedural and object-oriented approaches (e.g. data protection, code reuse), with limited application to the specific scenario of a school system extended over time by multiple developers.
(a) L3 (6-8): A clear, well-balanced comparison is given, correctly weighing at least two relevant factors (such as encapsulation/data protection, code reuse via inheritance, and maintainability by multiple developers over time), with a reasoned overall judgement clearly applied to the school grade-tracking scenario.
(a) Answer: Best answers weigh encapsulation/data protection and reuse via inheritance (favouring OOP for a multi-year, multi-developer school system) against the simplicity of procedural code for small one-off tasks, reaching a reasoned overall recommendation for this scenario.

Question 9

(a) B1 a function whose return value depends only on its input parameters/arguments (oe)
(a) B1 and which has no side effects, i.e. it does not change any state/data outside itself (e.g. global variables) (oe)
(a) Answer: A pure function is one whose result depends only on its input arguments, and which causes no side effects, meaning it does not change any variable or state outside the function.
(b) B1 the function's behaviour is easier to predict/test/debug, because calling it does not depend on, or change, any state elsewhere in the program (oe)
(b) B1 it makes the function safer to run in parallel/concurrently, since there is no shared state that could be altered by another process at the same time (oe)
(b) Answer: It makes functions easier to test and reason about, since their output only depends on their own inputs; it also makes them safer to run in parallel, since there is no shared state for two calls to interfere with.
(c) B1 AddToGlobalTotal cao
(c) B1 it reads and permanently changes the global variable globalTotal, which is a side effect outside the function, so the same call can return a different result each time depending on globalTotal's current value (oe)
(c) Answer: AddToGlobalTotal is impure, because it changes the external variable globalTotal each time it is called, so the value it returns depends on more than just its own parameter x, and it has a side effect outside the function.

Question 10

(a) M1 declares annualMileage as PRIVATE : REAL
(a) M1 constructor PROCEDURE NEW(miles) correctly assigns annualMileage <- miles
(a) M1 declares PUBLIC FUNCTION CalculateRunningCost() RETURNS REAL
(a) A1 function body correctly returns 0; overall class syntax logically complete (ignore minor syntax errors)