Object-Oriented Programming - Worksheets, Questions and Revision

12 original exam-style questions - 7 pages of questions with a full mark scheme - free printable PDF.

Download PDF Jump to mark scheme (page 8)Read the revision guide

Next in this strand

Revision Library

revisionlibrary.co.uk

A-Level · AQA

A1.9 Object-Oriented Programming

AQA 7517 · Calculators not allowed · about 150 minutes

Total Marks

Name: _______________________________ Date: ____ / ____ / ______

Answer ALL questions. Show all your working.

Object-oriented programming (OOP) uses a specific set of terms to describe how programs are structured. Define each of the following terms, giving a short example in each case.

(a)class(2)

(b)object(2)

(c)attribute(2)

(d)method(2)

(Total for Question 1 is 8 marks)

A programmer writes the following AQA-style pseudocode class definition for a simple Student record.

class Student
private studentName
private examScore

public new(name, score)

     studentName <- name
     examScore <- score
  endnew

public getScore()

     return examScore
  endgetScore

endclass

(a)Explain the purpose of the new() subroutine in the class above.(2)

(b)Write one line of pseudocode that creates a Student object called student1, representing a student named "Priya" with an exam score of 68.(2)

(c)State the value that would be returned by the call student1.getScore(), and identify the visibility keyword that would need to change if examScore was instead to be accessed directly as student1.examScore.(2)

(Total for Question 2 is 6 marks)

A class diagram for a BankAccount class is shown below.

BankAccount
-----------------------------------
- accountNumber : String
- balance : Real
-----------------------------------
+ new(accNum : String, openingBalance : Real)
+ deposit(amount : Real) : Void
+ withdraw(amount : Real) : Boolean
+ getBalance() : Real

(a)State what the "-" symbol before accountNumber and balance indicates, and explain why a programmer would choose this visibility for these attributes.(3)

(b)Using AQA pseudocode conventions, write the class definition for BankAccount, including the constructor new(), the deposit() method, and the getBalance() method. The deposit() method should add amount to balance, provided amount is greater than 0.(6)

(c)Using AQA pseudocode conventions, write the withdraw(amount) method. It should return TRUE and reduce balance by amount if there are sufficient funds (balance ≥ amount); otherwise it should return FALSE and leave balance unchanged.(4)

(d)A second programmer suggests making balance a public attribute so that other parts of the program can update it directly, instead of using deposit() and withdraw(). Explain two problems this could cause.(3)

(Total for Question 3 is 16 marks)

Explain how encapsulation is achieved in an object-oriented program, and discuss the benefits it brings to the development of a large software system.

(Total for Question 4 is 9 marks)

A programmer is designing a class hierarchy to represent different shapes. The superclass Shape stores a colour attribute, and every shape (whatever its type) should have a method area() that calculates its own area.

(a)Using AQA pseudocode conventions, write the superclass Shape. It should have a private attribute colour, a constructor new(col) that sets colour, a method getColour() that returns colour, and a method area() that returns 0 (to be overridden by subclasses).(5)

(b)Write the subclass Circle, which inherits from Shape. It should have an additional private attribute radius, a constructor that accepts a colour and a radius (calling the superclass constructor to set the colour), and an overridden method area() that returns π * radius ^ 2.(6)

(c)Write the subclass Rectangle, which inherits from Shape. It should have additional private attributes width and height, a constructor that accepts a colour, width and height, and an overridden area() method that returns width * height.(4)

(d)Explain what is meant by "overriding" a method, using area() in Circle and Rectangle as your example.(2)

(Total for Question 5 is 17 marks)

The program below creates an array of three Shape objects (using the classes from Question 5) and processes them in a loop.

shapes <- new Array(3)
shapes[0] <- new Circle("red", 3)
shapes[1] <- new Rectangle("blue", 4, 5)
shapes[2] <- new Circle("green", 2)
total <- 0
FOR i <- 0 TO 2
   total <- total + shapes[i].area()

ENDFOR

OUTPUT total

(a)Complete a trace table to show the value returned by shapes[i].area() and the running value of total on each pass of the loop, and state the value finally output. Use π = 3.14159 and give values to 2 decimal places.(6)

(b)Explain why the line shapes[i].area() calls a different version of the area() method depending on whether shapes[i] refers to a Circle object or a Rectangle object. Use the term polymorphism in your answer.(3)

(c)Explain why the FOR loop uses FOR i <- 0 TO 2 rather than FOR i <- 0 TO 3, given that the array shapes holds three elements.(2)

(Total for Question 6 is 11 marks)

A software developer is modelling a Car class. She considers two possible designs.

Design 1: Car has an attribute engine, which stores an Engine object (so Car contains an Engine).

Design 2: A class SportsCar inherits from Car.

(a)State the type of relationship shown in Design 1, and explain what it means for one class to be related to another in this way.(3)

(b)State the type of relationship shown in Design 2, and explain what it means for one class to be related to another in this way.(3)

(c)A SportsCar is a type of Car, but a Car is not a type of Engine. Explain why this means inheritance is an appropriate relationship between SportsCar and Car, but not between Car and Engine.(2)

(Total for Question 7 is 8 marks)

A junior programmer has written the following class, but has not applied good object-oriented design principles.

class Student
public studentName
public examScore

public new(name, score)

     studentName <- name
     examScore <- score
  endnew

endclass

Elsewhere in the program, another part of the code contains the line:

student1.examScore <- 150

(a)Identify two problems with this class and the line of code shown above.(4)

(b)Rewrite the class using AQA pseudocode conventions so that studentName and examScore are properly encapsulated. Include a constructor, a getExamScore() method, and a setExamScore(newScore) method that only updates examScore if newScore is between 0 and 100 inclusive.(6)

(Total for Question 8 is 10 marks)

A company is developing a large payroll system. It currently has a single class, Employee, which includes attributes and methods for all types of staff, including office workers, managers and factory workers, with many IF statements inside its methods to handle the different types of employee differently.

A programmer suggests refactoring the system to use inheritance, creating subclasses such as Manager and FactoryWorker that inherit from Employee.

Discuss the extent to which using inheritance would improve the design of this payroll system.

(Total for Question 9 is 9 marks)

A library system uses a superclass Book with a private attribute title and a private attribute author. It has a constructor new(t, a) and a method getDetails() that returns a string in the form "title by author".

Two subclasses are needed:

EBook, which adds a private attribute fileSizeMB, with a constructor that also accepts the file size, and overrides getDetails() so it returns the Book version's string followed by " (ebook, " then the file size then "MB)".

PrintBook, which adds a private attribute shelfCode, with a constructor that also accepts the shelf code, and overrides getDetails() so it returns the Book version's string followed by " [Shelf: " then the shelf code then "]".

(a)Write the superclass Book, using AQA pseudocode conventions.(4)

(b)Write the subclass EBook.(5)

(c)Write the subclass PrintBook.(5)

(Total for Question 10 is 14 marks)

The following program creates an array of Book objects (using the classes from Question 10) and outputs the details of each one in turn.

library <- new Array(3)
library[0] <- new Book("Harbour Lights", "Amara Osei")
library[1] <- new EBook("The Long Tide", "Fatima Chowdhury", 4)
library[2] <- new PrintBook("Northbound", "Callum Ferguson", "F-12")

FOR i <- 0 TO 2
   OUTPUT library[i].getDetails()

ENDFOR

(a)Complete a trace table to show the exact string output on each pass of the loop.(6)

(b)Explain why it is good practice for EBook's getDetails() method to call super.getDetails() rather than rewriting the "title by author" logic again from scratch.(2)

(c)A fourth element, library[3], containing an Audiobook object (a further subclass of Book, not shown here, which also overrides getDetails()), is added, and the loop is changed to FOR i <- 0 TO 3. State which version of getDetails() would run for this new element, and explain why the existing loop code does not need to change to support it.(2)

(Total for Question 11 is 10 marks)

A start-up company is building a simulation of a hospital, modelling wards, patients, doctors and equipment, each with related data and behaviour, and expects to keep extending the simulation with new features for several years.

Discuss whether an object-oriented programming language or a procedural programming language would be more suitable for this project.

(Total for Question 12 is 9 marks)

Mark scheme · A1.9 Object-Oriented Programming

Question 1

(a) B1 valid definition: a class is a template/blueprint that defines the attributes and methods that its objects will have (oe)
(a) B1 valid, clearly named example, e.g. a class called Car defining attributes such as colour and methods such as accelerate() (oe)
(a) Answer: A class is a template/blueprint that defines the attributes (data) and methods (behaviour) that objects created from it will have. Example: a class called Car defines that every Car object will have attributes such as colour and speed, and methods such as accelerate().
(b) B1 valid definition: an object is a specific instance of a class, created (instantiated) with its own values for the class's attributes (oe)
(b) B1 valid, clearly named example consistent with a class, e.g. myCar, a Car object with colour set to "red" (oe)
(b) Answer: An object is a specific instance of a class, created (instantiated) in memory, with its own set of values for the attributes defined by its class. Example: myCar, an object of the Car class, with colour = "red".
(c) B1 valid definition: a piece of data stored by a class/object describing one of its characteristics (oe)
(c) B1 valid example, e.g. colour or speed for a Car object (oe)
(c) Answer: An attribute (or property) is a piece of data stored by a class or object that describes one of its characteristics. Example: colour or speed for a Car object.
(d) B1 valid definition: a subroutine defined within a class describing an action/behaviour its objects can perform (oe)
(d) B1 valid example, e.g. accelerate() or deposit() (oe)
(d) Answer: A method is a subroutine (procedure or function) defined within a class that describes an action or behaviour that objects of that class can perform. Example: accelerate() for a Car object.

Question 2

(a) B1 new() is the constructor; it runs automatically whenever a Student object is instantiated (oe)
(a) B1 it initialises the object's attributes (studentName, examScore) using the values passed in as parameters
(a) Answer: new() is the constructor for the Student class. It is called automatically when a Student object is created, and it initialises the object's attributes (studentName and examScore) using the values passed in as parameters.
(b) M1 uses new Student(...) instantiation syntax assigned to student1 (oe)
(b) A1 correct arguments in the correct order: "Priya" then 68 cao
(b) Answer: student1 <- new Student("Priya", 68)
(c) B1 68 cao
(c) B1 private would need to change to public
(c) Answer: getScore() returns 68. The keyword private would need to change to public for examScore to be accessed directly from outside the class.

Question 3

(a) B1 "-" indicates the attribute is private
(a) B1 private attributes cannot be accessed or changed directly from outside the class
(a) B1 this protects the data (encapsulation): balance can only be changed via methods such as deposit()/withdraw(), which can validate the change, e.g. preventing an invalid negative balance being set directly (oe)
(a) Answer: The "-" symbol means the attribute is private. This means accountNumber and balance cannot be accessed or altered directly from outside the class. This protects the data (encapsulation): balance, for example, can only be changed through methods such as deposit() and withdraw(), which can check that a change is valid before applying it, rather than any other part of the program being able to set an invalid value directly.
(b) M1 class header class BankAccount with private accountNumber and private balance declared
(b) M1 constructor new(accNum, openingBalance) with both parameters correctly assigned to the attributes
(b) M1 deposit(amount) method header defined
(b) M1 IF amount > 0 THEN condition used to guard the update
(b) M1 balance <- balance + amount placed inside the IF
(b) M1 getBalance() method that returns balance cao

(b) Answer:class BankAccount
private accountNumber
private balance

public new(accNum, openingBalance)

     accountNumber <- accNum
     balance <- openingBalance
  endnew

public deposit(amount)

     IF amount > 0 THEN
        balance <- balance + amount
     ENDIF
  enddeposit

public getBalance()

     return balance
  endgetBalance

endclass

   IF balance >= amount THEN
      balance <- balance - amount
      return TRUE
   ELSE
      return FALSE
   ENDIF

endwithdraw

(d) B1 problem 1: no validation would occur, so balance could be set directly to an invalid value, e.g. a negative number, with nothing checking it
(d) B1 problem 2: it becomes harder to track down where/how balance changes in a large program, since any part of the code could alter it, not just deposit()/withdraw()
(d) B1 further valid development, e.g. it breaks encapsulation, tightly coupling other code to BankAccount's internal representation, making future changes to the class harder
(d) Answer: Problem 1: without deposit()/withdraw() enforcing rules, balance could be set directly to an invalid value (e.g. a negative number) with no validation. Problem 2: it becomes much harder to find and debug where balance is changed, since any part of the program could alter it directly rather than only through the class's own methods; this breaks encapsulation and makes the class harder to maintain in future.

Question 4

Level 3 (7-9): A detailed and accurate explanation of how encapsulation is achieved (private attributes accessed only through public methods, e.g. getters/setters, which can include validation) is combined with a well-reasoned discussion of at least two distinct benefits, supported by relevant examples. Technical terminology is used accurately and consistently, and the answer is coherently structured.
Level 2 (4-6): A reasonable explanation of encapsulation is given, with at least one benefit discussed. Technical terms are mostly used correctly, but the explanation and/or discussion may lack full development, examples, or precision.
Level 1 (1-3): A basic or partial explanation of encapsulation is given, with little or no discussion of benefits. Use of technical terms is limited, and points made are largely unsupported or generic.
Level 0 (0): No creditable content.
Indicative content:
- Attributes/data are declared private within a class, so they cannot be accessed directly from outside the class.
- Access is instead provided through public methods (e.g. getters and setters, or task-specific methods such as deposit()/withdraw()).
- These public methods can include validation logic to check that a new value is sensible before the internal state is actually changed.
- This hides (abstracts away) the internal implementation/data representation of the class from the rest of the program.
- Benefit: prevents other parts of the program from directly setting invalid or inconsistent data in an object.
- Benefit: the internal implementation of a class can later be changed without breaking other code that uses it, provided the public interface (method signatures) stays the same.
- Benefit: makes large systems easier to maintain and debug, since all changes to an attribute must go through a small, known set of methods rather than being scattered across the whole program.
- Benefit: reduces coupling between parts of a large system, allowing different programmers or teams to work on separate classes independently.

Question 5

(a) M1 class header class Shape with private colour declared
(a) M1 constructor new(col) that assigns colour <- col
(a) M1 getColour() method that returns colour
(a) M1 area() method header defined
(a) M1 return 0 inside area() cao

(a) Answer:class Shape
private colour

public new(col)

     colour <- col
  endnew

public getColour()

     return colour
  endgetColour

public area()

     return 0
  endarea

endclass

(b) M1 class Circle inherits Shape header with private radius declared
(b) M1 constructor new(col, rad) header defined
(b) M1 super.new(col) used to call the superclass constructor
(b) M1 radius <- rad assigned in the constructor
(b) M1 area() method header overriding the superclass version
(b) M1 return π * radius ^ 2 cao
(b) Answer:class Circle inherits Shape
private radius

public new(col, rad)
super.new(col)
```
     radius <- rad
  endnew
```
public area()
```
     return pi * radius ^ 2
  endarea
```
endclass
(c) M1 class Rectangle inherits Shape header with private width and private height declared
(c) M1 constructor new(col, w, h) calling super.new(col) and assigning width <- w and height <- h
(c) M1 area() method header overriding the superclass version
(c) M1 return width * height cao
(c) Answer:class Rectangle inherits Shape
private width
private height

public new(col, w, h)
super.new(col)
```
     width <- w
     height <- h
  endnew
```
public area()
```
     return width * height
  endarea
```
endclass
(d) B1 overriding means a subclass provides its own implementation of a method already defined in its superclass, replacing the inherited version for objects of that subclass
(d) B1 correct application: Circle and Rectangle both define their own area() with different logic to Shape's area() (which returns 0), so calling area() on a Circle object runs Circle's version, not Shape's
(d) Answer: Overriding means a subclass defines its own version of a method that already exists in its superclass, and this version is used instead of the superclass's version for objects of that subclass. Here, Circle and Rectangle each provide their own area() method, with different formulas to the area() in Shape (which just returns 0), so calling area() on a Circle object executes Circle's own area() method.

Question 6

(a) B1 i = 0: shapes[0].area() = 28.27 (Circle radius 3: π * 3²)
(a) B1 i = 1: shapes[1].area() = 20.00 (Rectangle 4 * 5)
(a) B1 i = 2: shapes[2].area() = 12.57 (Circle radius 2: π * 2²)
(a) B1 total after i = 0 is 28.27
(a) B1 total after i = 1 is 48.27
(a) B1 total (and final output) after i = 2 is 60.84 cao
(a) Answer:
i shapes[i].area() total
0 28.27 28.27
1 20.00 48.27
2 12.57 60.84

Output: 60.84
(b) B1 this is an example of polymorphism: objects of different classes (Circle, Rectangle) can be treated as objects of a common superclass (Shape) and stored together, e.g. in the same array
(b) B1 although the same method name area() is called each time, at run-time the actual object's own (overridden) version of area() executes rather than Shape's version - this is sometimes called dynamic/late binding
(b) B1 this means the same line of code shapes[i].area() works correctly for every subclass, without the programmer needing to write separate code to check the type of each shape
(b) Answer: This is an example of polymorphism. Circle and Rectangle are both subclasses of Shape, so their objects can be stored together in the same shapes array and processed with the same code. Even though every call looks identical (shapes[i].area()), at run-time each object runs its own overridden version of area() (Circle's or Rectangle's), not the version in Shape. This means the loop does not need any extra code to check what type of shape each element is.
(c) B1 array indices in this pseudocode start at 0 (zero-indexed), so the three elements are stored at indices 0, 1 and 2
(c) B1 using TO 3 would attempt to access shapes[3], which does not exist, causing a run-time (out-of-bounds/invalid index) error
(c) Answer: The array is zero-indexed, so its three elements are at indices 0, 1 and 2 - there is no index 3. If the loop used FOR i <- 0 TO 3, it would try to access shapes[3], which does not exist, causing a run-time error.

i	shapes[i].area()	total
0	28.27	28.27
1	20.00	48.27
2	12.57	60.84

Question 7

(a) B1 Design 1 shows containership, also called aggregation or composition - a "has-a" relationship
(a) B1 an object of the Car class stores a reference to (contains) an object of another class, Engine, as one of its attributes
(a) B1 Car can then use the Engine object's own methods/attributes (e.g. calling engine.start()) rather than reimplementing engine behaviour itself
(a) Answer: Design 1 shows containership (also called aggregation or composition) - a "has-a" relationship. A Car object stores a reference to an Engine object as one of its attributes. This lets Car make use of the Engine object's own methods (e.g. engine.start()) rather than Car having to implement that behaviour itself.
(b) B1 Design 2 shows inheritance - an "is-a" relationship
(b) B1 SportsCar (the subclass) automatically has all the attributes and methods of Car (the superclass), without them needing to be rewritten
(b) B1 SportsCar can also add its own extra attributes/methods and/or override existing ones inherited from Car
(b) Answer: Design 2 shows inheritance - an "is-a" relationship. SportsCar automatically has all of Car's attributes and methods without rewriting them, and can add its own extra attributes/methods (e.g. a turboBoost() method) or override existing ones from Car.
(c) B1 inheritance should be used for an "is-a" relationship; SportsCar is a Car, so it is appropriate for SportsCar to inherit Car's attributes/methods and be treated as a Car
(c) B1 a Car is not a kind of Engine, so making Car inherit from Engine would be logically incorrect (it would wrongly give Car all of Engine's own methods); containership better models Car simply having/using an Engine
(c) Answer: Inheritance models an "is-a" relationship, and a SportsCar genuinely is a type of Car, so it is appropriate for SportsCar to inherit from Car. A Car is not a type of Engine, however, so making Car inherit from Engine would be incorrect - it would give Car all of Engine's own methods and attributes, which does not reflect reality. Containership (Car simply storing an Engine object) models this has-a relationship correctly instead.

Question 8

(a) B1 problem 1 identified: both attributes are public, so they can be accessed and changed directly from anywhere in the program, breaking encapsulation
(a) B1 problem 1 developed: this allows the line student1.examScore <- 150 to set examScore directly with no check at all
(a) B1 problem 2 identified: the class has no validation logic (e.g. no setter method) to enforce rules on new values
(a) B1 problem 2 developed: so an invalid score, such as 150 (presumably above a maximum possible mark of 100), can be stored without being rejected
(a) Answer: Problem 1: studentName and examScore are declared public, so any part of the program can access or change them directly, breaking encapsulation - this is why the line student1.examScore <- 150 is allowed to run at all. Problem 2: the class has no method that validates a new exam score before storing it, so an invalid value such as 150 (assuming scores should be 0 to 100) is accepted with no check.
(b) M1 private studentName and private examScore declared
(b) M1 constructor new(name, score) correctly assigning both parameters to the attributes
(b) M1 getExamScore() method that returns examScore
(b) M1 setExamScore(newScore) method header defined
(b) M1 IF newScore ≥ 0 AND newScore ≤ 100 THEN condition used (oe, e.g. two nested IFs)
(b) M1 examScore <- newScore placed inside the IF, so an out-of-range value is simply not stored cao

(b) Answer:class Student
private studentName
private examScore

public new(name, score)

     studentName <- name
     examScore <- score
  endnew

public getExamScore()

     return examScore
  endgetExamScore

public setExamScore(newScore)

     IF newScore >= 0 AND newScore <= 100 THEN
        examScore <- newScore
     ENDIF
  endsetExamScore

endclass

Question 9

Level 3 (7-9): A well-argued discussion identifies several clear benefits of using inheritance in this specific scenario (e.g. removing repeated IF statements, allowing subclasses to override/extend shared behaviour, easing the addition of future employee types), and also considers at least one limitation or counterpoint (e.g. added design complexity, the risk of a poorly-planned hierarchy, or the cost/risk of refactoring existing code), reaching a supported conclusion.
Level 2 (4-6): Some relevant benefits of using inheritance are identified with partial application to the payroll scenario, but discussion of limitations or counterpoints is limited or missing, or the explanation lacks depth or scenario-specific detail.
Level 1 (1-3): Basic, largely generic statements about inheritance are made with little or no application to the payroll scenario described.
Level 0 (0): No creditable content.
Indicative content:
- Attributes/methods common to all staff (e.g. name, employee number, a method to calculate basic pay) would only need to be written once, in the Employee superclass.
- Manager and FactoryWorker subclasses would inherit these automatically, then add their own extra attributes/methods (e.g. Manager might add a teamSize attribute and a calculateBonus() method).
- Subclasses could override a method such as calculatePay(), replacing the current IF statements that check employee type, so each subclass's own logic is self-contained and easier to follow and maintain.
- Adding a new type of employee in future (e.g. Apprentice) would mean creating a new subclass, without needing to edit and re-test the existing Employee class or its other subclasses.
- Counterpoint: designing a good class hierarchy takes upfront planning; if roles do not fit neatly into an is-a hierarchy (e.g. an employee who is both a manager and a factory worker), inheritance alone may not model the situation well.
- Counterpoint: refactoring existing, working code carries risk and cost, and the benefits are most worthwhile if the system will genuinely be extended and maintained over a long period, which the scenario suggests is the case here.

Question 10

(a) M1 class header class Book with private title and private author declared
(a) M1 constructor new(t, a) correctly assigning both parameters to the attributes
(a) M1 getDetails() method header defined
(a) M1 return t + " by " + a (or return title + " by " + author) cao

(a) Answer:class Book
private title
private author

public new(t, a)

     title <- t
     author <- a
  endnew

public getDetails()

     return title + " by " + author
  endgetDetails

endclass

(b) M1 class EBook inherits Book header with private fileSizeMB declared
(b) M1 constructor new(t, a, size) header defined
(b) M1 super.new(t, a) used to call the superclass constructor, and fileSizeMB <- size assigned
(b) M1 getDetails() overridden and calls super.getDetails() to reuse the Book format
(b) M1 return details + " (ebook, " + fileSizeMB + "MB)" cao

(b) Answer:class EBook inherits Book
private fileSizeMB

public new(t, a, size)
super.new(t, a)

     fileSizeMB <- size
  endnew

public getDetails()

     details <- super.getDetails()
     return details + " (ebook, " + fileSizeMB + "MB)"
  endgetDetails

endclass

     shelfCode <- code
  endnew

public getDetails()

     details <- super.getDetails()
     return details + " [Shelf: " + shelfCode + "]"
  endgetDetails

endclass

Question 11

(a) B1 i = 0 output: Harbour Lights by Amara Osei
(a) B1 i = 1 base part correct: The Long Tide by Fatima Chowdhury
(a) B1 i = 1 suffix correct: (ebook, 4MB)
(a) B1 i = 2 base part correct: Northbound by Callum Ferguson
(a) B1 i = 2 suffix correct: [Shelf: F-12]
(a) B1 all three outputs given in the correct loop order cao
(a) Answer:i=0 output: Harbour Lights by Amara Osei
i=1 output: The Long Tide by Fatima Chowdhury (ebook, 4MB)
i=2 output: Northbound by Callum Ferguson [Shelf: F-12]
(b) B1 avoids duplicating code that already exists in the superclass Book, so if the format of getDetails() in Book ever changes, it only needs to be updated in one place
(b) B1 reduces the risk of errors/inconsistency between subclasses (e.g. EBook producing the base string in a slightly different way to Book or to PrintBook)
(b) Answer: Calling super.getDetails() reuses the logic already written in Book, so the "title by author" format only needs to be written and maintained in one place. This also avoids the risk of EBook (or PrintBook) accidentally producing a slightly different or inconsistent base string if the logic were rewritten separately in each subclass.
(c) B1 Audiobook's own overridden version of getDetails() would run, not Book's, because of polymorphism/dynamic method dispatch: an object always uses its own class's version of an overridden method
(c) B1 the loop code library[i].getDetails() does not need to know which specific subclass each element is, so it works for Audiobook without any change
(c) Answer: Audiobook's own overridden getDetails() method would run, not Book's, because of polymorphism - each object always uses its own class's version of an overridden method. The existing loop simply calls library[i].getDetails() for whatever object is stored at that index, so it automatically works correctly for the new Audiobook subclass without any modification.