25-Comp-B11 Advanced Software Design · Undated paper
Question 14 of 28: Class-Inheritance-Based vs. Object-Composition-Based GoF Patterns
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 14: Class-Inheritance-Based vs. Object-Composition-Based GoF Patterns (Part III)
Class-inheritance-based patterns fix relationships between classes STATICALLY, at compile time, via subclassing — a subclass specializes or completes a fixed structure defined by its superclass, and that relationship cannot change once the program is compiled. Object-composition-based patterns instead build behaviour by having one object hold a REFERENCE to another (typically through an interface) and delegate to it at runtime — the referenced object can be swapped for a different implementation while the program is running.
Class-inheritance-based example: Template Method. A base class defines a fixed algorithm skeleton as a sequence of steps, some of which are abstract; concrete subclasses override just those steps. This is inheritance-based because the subclass IS the customization — which steps run in which order is fixed permanently by the base class's own code, and a subclass cannot be substituted for another subclass's step implementation at runtime without actually being a different compiled class.
Object-composition-based example: Strategy. A context class holds a reference to a Strategy interface object and delegates the actual algorithm to it. This is composition-based because the concrete strategy is supplied to the context (typically via constructor or setter) and can be swapped for a different Strategy implementation at runtime, with no recompilation and no inheritance relationship between the context and the strategies at all.
