NivaarExam PrepOfficial exam papers ↗

25-Comp-B11 Advanced Software Design · Undated paper

Question 28 of 28: Implementing Public/Private Module Relationships in C++ and Java

Nivaar worked solution (AI-drafted; not reviewed by a licensed engineer)

Notes on this paper

17-Comp-B11 Advanced Software Design — National Exams, May 2019. 3 hours, closed book exam with two aid sheets allowed (written on both sides), no calculator permitted. The paper is organized into five parts, and candidates were instructed to answer any five (5) questions in Part I, any three (3) in Part II, any four (4) in Part III, any two (2) in Part IV, and any five (5) in Part V — only the first questions answered, in each part, as they appear in the answer book are marked. All questions carry equal weight, so the 19 questions actually marked (5+3+4+2+5 of 28) each count for 100/19 ≈ 5.26% of the paper. All 28 questions are answered below for completeness.

Reference texts: Sommerville, Software Engineering (10th ed., Pearson) — software processes, requirements engineering, design principles, testing, dependability, reuse; Pressman, Software Engineering: A Practitioner's Approach (9th ed.) — supplementary process/metrics/quality coverage; Gamma, Helm, Johnson & Vlissides (GoF), Design Patterns: Elements of Reusable Object-Oriented Software — pattern-language structure, the GoF pattern catalogue, and the "favor object composition over class inheritance" / "program to an interface, not an implementation" principles; Sebesta, Concepts of Programming Languages (12th ed.) — polymorphism, dynamic binding, visibility, encapsulation, interfaces; Bertrand Meyer, Object-Oriented Software Construction — design by contract, preconditions/postconditions/class invariants; Barbara Liskov's 1987 substitutability paper for Question 12; Stroustrup, The C++ Programming Language, for friend/access-control semantics (Question 25).

Question 12 prints “Liskpv substitution principle”, a typo in the paper; it is answered as the Liskov substitution principle.

PART I — General Principles (answer any 5 of 7)

Question 28: Implementing Public/Private Module Relationships in C++ and Java (Part V)

Question text not reproduced: the examination questions are © Engineers and Geoscientists BC. Open the official past paper (linked at the top of this page) to read the question, then follow the worked solution below.

A software MODULE's public part is the set of operations other modules are permitted to call; its private part is its internal representation and helper logic, which must remain unreachable from outside so the module can change its internals freely (Question 23). In both C++ and Java, a class IS the module boundary: public members form the module's public part, private members form its private part, and inter-module dependency/coupling is expressed entirely through calls to public members.

// Java: AddressBookManager module depends on the Contact module's PUBLIC part only
class Contact {
    private String name, phone;               // private part
    public Contact(String n, String p) { name = n; phone = p; }
    public String getName() { return name; }   // public part
    public String getPhone() { return phone; }
}
class AddressBookManager {                      // a separate module
    public String summarize(Contact c) {
        return c.getName() + ": " + c.getPhone();  // depends only on Contact's public part
    }
}

An association relationship is a module holding a long-lived reference to another module's object (e.g. an AddressBookManager field List<Contact> contacts), still used only through that object's public part. Java groups related classes into a larger module with packages (and, since Java 9, module-info.java modules that export only chosen packages): a class or member with no access modifier is package-private, so helper classes stay invisible outside the package. C++ additionally lets a class group multiple related classes/functions into a namespace to express a module boundary larger than one class, and can further restrict linkage of helper functions to a single translation unit (an anonymous namespace or static function) so they are entirely invisible to other modules — a finer-grained private part than Java's per-class privacy alone provides. In both languages, AddressBookManager's dependency on Contact is expressed by the method calls getName()/getPhone(); its coupling is deliberately kept to only those two calls rather than reaching into Contact's private fields, so a change to how Contact stores its data internally (e.g. splitting name into first/last) does not force any change to AddressBookManager as long as the public accessors are preserved.

Back to the paper →