2025 CCEA AS-Level Software Systems Development CL4 模拟试题及答案详解

(i) A class is a blueprint, or template, that defines the fields (attributes) and methods (behaviour) that objects created from it will have.
(ii) An object is a specific instance of a class — an individual occurrence created from the class's blueprint, with its own particular values stored in the fields defined by the class.
(iii) A constructor is a special method, sharing the same name as its class, that is automatically called whenever a new object of that class is created; it is used to initialise the object's fields, often using values passed in as parameters.
Final answer: (i) a class is a blueprint defining fields/methods; (ii) an object is an instance created from a class; (iii) a constructor is the special method that initialises a new object's fields when it is created.

(i) Correct definition of class (blueprint/template defining fields and methods) [2]. (ii) Correct definition of object (an instance of a class, with its own field values) [2]. (iii) Correct definition of constructor (special method, same name as class, called on object creation, initialises fields) [2].

(a) The array is declared and created as: int[] borrowCounts = new int[10]; (identical in C# and Java).
(b) totalBorrows() loops through every element of the array, adding each value to a running total, then returns the total:
C#: public int totalBorrows(int[] borrowCounts) {
int total = 0;
for (int i = 0; i < borrowCounts.Length; i++) {
total = total + borrowCounts[i];
}
return total;
}
Java: public int totalBorrows(int[] borrowCounts) {
int total = 0;
for (int i = 0; i < borrowCounts.length; i++) {
total = total + borrowCounts[i];
}
return total;
}
(c) mostBorrowed() keeps track of the index of the largest value found so far (starting with index 0), updating it whenever a larger value is found later in the array, then returns that index:
C#: public int mostBorrowed(int[] borrowCounts) {
int maxIndex = 0;
for (int i = 1; i < borrowCounts.Length; i++) {
if (borrowCounts[i] > borrowCounts[maxIndex]) {
maxIndex = i;
}
}
return maxIndex;
}
Java: public int mostBorrowed(int[] borrowCounts) {
int maxIndex = 0;
for (int i = 1; i < borrowCounts.length; i++) {
if (borrowCounts[i] > borrowCounts[maxIndex]) {
maxIndex = i;
}
}
return maxIndex;
}
Traced check: for borrowCounts = {3,7,2,9,5,1,9,0,4,6}, totalBorrows returns 46 (the sum of all ten values) and mostBorrowed returns 3 (the first index holding the highest value, 9).
Final answer: (a) int[] borrowCounts = new int[10];; (b) a loop summing every element, returning the total; (c) a loop tracking and returning the index of the largest value found (initialised to index 0, updated whenever a strictly larger value is found).

(a) Correct array declaration and creation for 10 integers [2].
(b) Correct method header with int[] parameter and int return type [1]; correct initialisation of a running total to 0 [1]; correct loop structure iterating over the full array [2]; correct accumulation of each element into the total [1]; correct return statement [1] (max 6).
(c) Correct method header with int[] parameter and int return type [1]; correct initialisation of maxIndex to 0 [1]; correct loop structure iterating over the array (from index 1 onward, or 0 with equivalent correct logic) [2]; correct comparison to find a larger value [2]; correct update of maxIndex [2]; correct return statement [1] (max 9).

(a)(i)–(ii) Class definition:
C#: public class Book {
private string title;
private string author;
private string isbn;

public Book(string title, string author, string isbn) {
this.title = title;
this.author = author;
this.isbn = isbn;
}

public string getTitle() { return title; }
public string getAuthor() { return author; }
public string getIsbn() { return isbn; }
}
Java: public class Book {
private String title;
private String author;
private String isbn;

public Book(String title, String author, String isbn) {
this.title = title;
this.author = author;
this.isbn = isbn;
}

public String getTitle() { return title; }
public String getAuthor() { return author; }
public String getIsbn() { return isbn; }
}
(b) findByIsbn() loops through the catalogue array, comparing each Book's isbn field against the given isbn, and returns the matching Book as soon as it is found; if the loop finishes without a match, it returns null:
C#: public Book findByIsbn(Book[] catalogue, string isbn) {
for (int i = 0; i < catalogue.Length; i++) {
if (catalogue[i].getIsbn() == isbn) {
return catalogue[i];
}
}
return null;
}
Java: public Book findByIsbn(Book[] catalogue, String isbn) {
for (int i = 0; i < catalogue.length; i++) {
if (catalogue[i].getIsbn().equals(isbn)) {
return catalogue[i];
}
}
return null;
}
(Note: Java string comparison uses .equals(), not ==, since == compares object references in Java; C# overloads == for strings to compare their values.)
(c) This method performs a linear search, checking the array one element at a time from the start until a match is found or the end of the array is reached; in the worst case (the ISBN is not present, or is near the end), every element must be checked. As the catalogue grows very large, the number of comparisons needed grows in proportion to its size, making the search progressively slower. An alternative approach that would improve efficiency is to store the books in a hash table (dictionary) keyed on isbn, giving near-instant lookup regardless of size, or to keep the array sorted by isbn and use a binary search algorithm, which is much faster than linear search for a large, sorted collection since it repeatedly halves the portion of the array still to be searched.
Final answer: (a) constructor sets the three fields; get methods each return one field; (b) a linear-search loop comparing isbn values, returning the matching Book or null; (c) linear search may need to check every element as the catalogue grows, so a hash table/dictionary (or a sorted array with binary search) would search much more efficiently at scale.

(a)(i) Correct constructor header with three string parameters [1]; correct assignment of all three fields [2] (max 3). (a)(ii) Each of the three get methods correctly returning its field [1 mark each, max 3].
(b) Correct method header with Book[] and string parameters, returning Book [1]; correct loop over the full array [2]; correct language-appropriate comparison of isbn (.equals() in Java, or valid == in C#) [2]; correct return of the matching Book [2]; correct return of null if no match is found [1] (max 8).
(c) Correct explanation that linear search may need to check every element, and this gets slower as the array grows [3]; valid, correctly explained alternative (hash table/dictionary, or sorted array with binary search) [3] (max 6).

(a)(i) A run-time error that disrupts the normal flow of a program is called an exception. (ii) Code that might cause an error is placed inside a try block. (iii) If an error occurs, the program jumps to the matching catch block, where the error can be handled. (iv) The finally block, if present, contains code that runs whether or not an error occurred.
(b) The method performs the (integer) division inside a try block; because both numerator and denominator are declared as int, dividing by a denominator of zero causes a run-time exception (DivideByZeroException in C#, ArithmeticException in Java), which is caught in the matching catch block, where 0.0 is returned instead of allowing the program to crash:
C#: public double safeDivide(int numerator, int denominator) {
try {
int result = numerator / denominator;
return (double)result;
} catch (DivideByZeroException e) {
return 0.0;
}
}
Java: public double safeDivide(int numerator, int denominator) {
try {
int result = numerator / denominator;
return (double)result;
} catch (ArithmeticException e) {
return 0.0;
}
}
Final answer: (a) exception, try, catch, finally; (b) the integer division numerator / denominator is attempted inside a try block; if denominator is 0 this throws a division/arithmetic exception, which is caught and handled by returning 0.0 instead of crashing the program.

(a) Each correct word in the correct blank [1 mark each, max 4]: (i) exception, (ii) try, (iii) catch, (iv) finally.
(b) Correct method header with two int parameters and a double return type [2]; correct use of a try block containing the division [2]; correct integer division of numerator by denominator [2]; correct use of a matching catch block naming the correct/an acceptable exception type [3]; correct return of 0.0 within the catch block [2]; correct return of the division result (cast to double) when no exception occurs [2] (max 13).

(a) Serialization is the process of converting an object, along with its current field values, into a format (such as a byte stream or file) that can be saved or transmitted, and later reconstructed (deserialized) back into an equivalent object; this allows an object's data to persist beyond the lifetime of the running program, for example being saved to a file and reloaded the next time the program runs.
(b) In Java, a class must implement the Serializable interface (java.io.Serializable), which is a 'marker' interface with no methods that must be written; in C#, the class must instead be marked with the [Serializable] attribute above its class definition. This is necessary because it explicitly signals to the runtime/serialization mechanism that a class's objects are intended, and safe, to be converted into a storable format — not every object can safely be serialized (for example, one holding an open file handle or network connection), so the language requires this explicit declaration before allowing it.
Final answer: (a) serialization converts an object into a storable format that can later be reconstructed, letting its data persist beyond the running program; (b) in Java the class implements Serializable, in C# it is marked with the [Serializable] attribute, which is required to explicitly confirm the class's objects can safely be converted to that storable format.

(a) Correct explanation of serialization (converting an object to a storable format, later reconstructable) [1]; correct reference to allowing data to persist beyond the running program [1].
(b) Correct mechanism named for Java (implements Serializable) or C# ([Serializable] attribute) [2]; valid explanation of why this is necessary [1].

C#:
public class LibraryItem {
protected string title;
protected string itemId;

public LibraryItem(string title, string itemId) {
this.title = title;
this.itemId = itemId;
}

public virtual string getDetails() {
return title + " (" + itemId + ")";
}
}

public class Book : LibraryItem {
private string author;

public Book(string title, string itemId, string author) : base(title, itemId) {
this.author = author;
}

public override string getDetails() {
return base.getDetails() + " [" + author + "]";
}
}

public class DVD : LibraryItem {
private int runtimeMinutes;

public DVD(string title, string itemId, int runtimeMinutes) : base(title, itemId) {
this.runtimeMinutes = runtimeMinutes;
}

public override string getDetails() {
return base.getDetails() + " [" + runtimeMinutes + " mins]";
}
}

Java:
public class LibraryItem {
protected String title;
protected String itemId;

public LibraryItem(String title, String itemId) {
this.title = title;
this.itemId = itemId;
}

public String getDetails() {
return title + " (" + itemId + ")";
}
}

public class Book extends LibraryItem {
private String author;

public Book(String title, String itemId, String author) {
super(title, itemId);
this.author = author;
}

@Override
public String getDetails() {
return super.getDetails() + " [" + author + "]";
}
}

public class DVD extends LibraryItem {
private int runtimeMinutes;

public DVD(String title, String itemId, int runtimeMinutes) {
super(title, itemId);
this.runtimeMinutes = runtimeMinutes;
}

@Override
public String getDetails() {
return super.getDetails() + " [" + runtimeMinutes + " mins]";
}
}

Traced check: new Book("Frankenstein","BK001","Mary Shelley").getDetails() calls the base getDetails(), giving "Frankenstein (BK001)", then appends " [Mary Shelley]", giving "Frankenstein (BK001) [Mary Shelley]" — matching the example exactly. Similarly, new DVD("Inception","DV001",148).getDetails() gives "Inception (DV001)" then appends " [148 mins]", giving "Inception (DV001) [148 mins]" — matching the example exactly.
Final answer: LibraryItem defines the shared title/itemId fields and a base getDetails(); Book and DVD each inherit from it, pass title/itemId to the base constructor, and override getDetails() to call the base version and append their own extra field, exactly reproducing both example outputs.

(a) Correct fields declared as protected [1]; correct constructor header and correct assignment of both fields [2]; correct getDetails() method, correctly marked as overridable (virtual in C#; Java methods are overridable by default) and returning the correct concatenated string [3] (max 6).
(b)(i) Correct constructor header with three parameters [1]; correct call to the base class constructor passing title and itemId [2]; correct assignment of author [1] (max 4). (b)(ii) Correct override syntax (override in C#; @Override/re-declared method in Java) [1]; correct call to the base class's getDetails() [3]; correct concatenation of the author in square brackets in the specified format [2] (max 6).
(c)(i) Correct constructor header with three parameters (including an int for runtimeMinutes) [1]; correct call to the base class constructor [1]; correct assignment of runtimeMinutes [1] (max 3). (c)(ii) Correct override syntax [1]; correct call to the base class's getDetails() [3]; correct concatenation of the runtime in square brackets in the specified format [2] (max 6).

C#: public void printCatalogue(LibraryItem[] items) {
for (int i = 0; i < items.Length; i++) {
Console.WriteLine(items[i].getDetails());
}
}

Java: public void printCatalogue(LibraryItem[] items) {
for (int i = 0; i < items.length; i++) {
System.out.println(items[i].getDetails());
}
}

Although the array is declared to hold the base type LibraryItem, each element may actually be a Book or a DVD object at run time; because getDetails() is overridden in both Book and DVD, calling items[i].getDetails() automatically runs the correct, more specific version of the method for whatever type of object is actually stored at that position in the array (a Book's version if it is a Book, a DVD's version if it is a DVD), without printCatalogue() needing to know or check which specific type each item is. This is an example of polymorphism.
Final answer: a method with a LibraryItem[] parameter that loops through the array and prints items[i].getDetails() for each element — polymorphism ensures the correct overridden Book or DVD version of getDetails() runs automatically for each item, regardless of the array's declared base type.

Correct method header with a LibraryItem[] parameter and void return type [2]; correct loop structure iterating over the full array [3]; correct call to getDetails() on each array element [2]; correct output statement printing the result, one item per line [2]; explanation/evidence (through correct code) that the polymorphic call correctly resolves to each object's own overridden version [1] (max 10).