> **DRAFT** — under teacher review. # Object Descriptions and Class Diagrams The Hamilton and Alexandra College · Year 12 · 2026 If your solution uses **objects and classes**, the fifth design tool is the **object description**. VCAA defines it as a tool that *"describes all of the relevant properties, methods and events in an object or class."* A **class diagram** is the standard way to draw a whole set of object descriptions at once and show how the classes relate. This is a **Level 7+** tool in C5-1, and at **Level 9** you are also expected to write pseudocode for the methods inside your classes. > [!NOTE] > **Only if you use OOP.** If your solution genuinely does not use classes and objects, you do not need object descriptions. But most SAT projects of any real size have at least a few classes — and a class diagram is the clearest way to show them. --- ## Reading a class diagram Each box is a **class**. The top section lists its **attributes** (properties), the bottom section lists its **methods** (actions), and the arrows show **relationships** between classes. ```mermaid --- title: Animal example --- classDiagram note "From Duck till Zebra" Animal <|-- Duck note for Duck "can fly<br>can swim<br>can dive<br>can help in debugging" Animal <|-- Fish Animal <|-- Zebra Animal : +int age Animal : +String gender Animal: +isMammal() Animal: +mate() class Duck{ +String beakColor +swim() +quack() } class Fish{ -int sizeInFeet -canEat() } class Zebra{ +bool is_wild +run() } ``` Read it like this: `Animal` is the **base class**. `Duck`, `Fish` and `Zebra` are all *a kind of* Animal, so each one **inherits** Animal's attributes (`age`, `gender`) and methods (`isMammal()`, `mate()`) and then adds its own. `Duck` adds `beakColor`, `swim()` and `quack()`; it doesn't have to redefine `age` because it already has it from `Animal`. --- ## The notation you need | Symbol | Meaning | |---|---| | `+` | **Public** — usable from outside the class | | `-` | **Private** — usable only inside the class | | `age : int` | An **attribute** and its **data type** | | `isMammal()` | A **method** (an action the object can perform) | | `isUpcoming() : bool` | A method and its **return type** | **Relationships** are shown with arrows between classes. The inheritance arrow `<|--` means *"is a kind of"* — writing `Animal <|-- Duck` says **Duck is a kind of Animal**, so Duck inherits all of Animal's attributes and methods and then adds its own. (Two others you may meet: *composition* `*--`, "is made of", and *association* `-->`, "uses".) > [!TIP] > Every attribute should have a **data type** and every method should show its **parameters and return type**. "`age`" alone is weak; "`+ age : int`" is design-ready. This is exactly the precision that lifts C5-1 from the middle bands into 7–9. --- ## Object descriptions — the written form A class diagram is the *picture*. An **object description** is the *written* version of the same information: a small table, one per class, listing each property and method (and, for interface objects, each event). VCAA accepts either form — most folios use both, the diagram for the overview and object descriptions for the detail. The video below builds two worked examples in a game engine. Watch how each class is captured by its properties and methods — and notice the idea of an **abstract class**: a base class that exists only as a *template* for others to inherit from, and is never created on its own (exactly like `Animal` in the diagram above — you never make a plain "Animal", only a Duck or a Dog). **🎯 Watch for:** two class families — `Animal → Dog`, and a `Skill` made of `SkillEffect`s — and how the base class declares a method that each child class then fills in. {{Video|src=https://www.youtube.com/watch?v=h21Lmg4o1Ks}} > [!NOTE] > This is a Godot (game-engine) tutorial, so the code is GDScript — but the *object-description skill* is identical to what VCAA asks for. Read it for the structure, not the language. ### Example 1 — Animal and Dog **`Animal`** — an abstract base class (a template; never created on its own) | Member | Kind | Returns / type | Description | |---|---|---|---| | `make_sound()` | Method (abstract) | `void` | The sound the animal makes. Declared here but **not** implemented — every subclass must define its own. | **`Dog`** — extends `Animal` | Member | Kind | Returns / type | Description | |---|---|---|---| | `make_sound()` | Method (override) | `void` | Implements the abstract method — outputs "woof". | ### Example 2 — a Skill made of effects ("object descriptions about skills") A `Skill` (think turn-based RPG) holds a list of effects. When you activate it, it loops through those effects and applies each one. The effects share an abstract base, `SkillEffect`, so new effects can be added without ever changing the `Skill` class. **`Skill`** | Member | Kind | Returns / type | Description | |---|---|---|---| | `effects` | Property | array of `SkillEffect` | The effects this skill applies. | | `activate(target)` | Method | `void` | Loops through `effects` and applies each one to the target. | **`SkillEffect`** — abstract base class (template only) | Member | Kind | Returns / type | Description | |---|---|---|---| | `apply(target)` | Method (abstract) | `void` | Applies this effect to the target. Each concrete effect defines its own. | **`ApplyDamage`** — extends `SkillEffect` | Member | Kind | Returns / type | Description | |---|---|---|---| | `damage_amount` | Property | `int` | How much damage to deal. | | `apply(target)` | Method (override) | `void` | Subtracts `damage_amount` from the target's health. | > [!TIP] > The same pattern runs through both examples: a **base class declares a method** (`make_sound`, `apply`) and each **child class fills it in**. Showing that in your object descriptions — the shared method on the parent, the specific version on each child — is exactly the inheritance evidence that scores at the top of C5-1. --- ## Properties, methods — *and events* A class diagram shows properties and methods well. But VCAA object descriptions also include **events** — especially for **GUI objects** (buttons, text fields, menus). An event is something the object *responds to*, like a click. For a login button you might describe the object like this: | Aspect | Example for `btnLogin` (a button) | |---|---| | **Properties** | `caption` = "Log in", `enabled` = true | | **Methods** | `setEnabled(state)` | | **Events** | `onClick` → runs the *Validate User* process | So: the class diagram carries your properties and methods; for interface objects, add a short note or table documenting the **events** as well. --- ## How it connects to your other design tools The object description is not an island — it ties the whole detailed design together: - **Properties ↔ data dictionary.** Every attribute is a field. `studentID : int` becomes a data-dictionary row with a type, size and format. See [Data Dictionary](/sd/C05/Data%20Dictionary). - **Methods ↔ pseudocode.** At Level 9 you write pseudocode for each method. The `is_passing()` example on the pseudocode page is exactly a method from a class diagram, written out. See [VCAA Pseudocode — Not Python](/sd/C05/VCAA%20Pseudocode%20Not%20Python). - **Classes ↔ mock-ups and IPO charts.** The objects are what sit *behind* your screens and processes. --- ## Common mistakes ### Mistake 1: An object description with no methods > ~~A box listing only attributes~~ That is just a data dictionary in disguise. An object description must include the **methods** (and, for GUI objects, the **events**) — that is what makes it an *object*. ### Mistake 2: No visibility or data types > ~~`beakColor`, `swim`~~ Show whether each member is public (`+`) or private (`-`), give every attribute a **type**, and give every method its **parameters and return type**. ### Mistake 3: Classes drawn with no relationships If `Teacher` is a kind of `Student`, draw the inheritance arrow. A diagram of disconnected boxes hides the design thinking the arrows are meant to show. ### Mistake 4 (Level 9): A class diagram but no method pseudocode At Level 9 the methods in your diagram must be backed by pseudocode. A diagram on its own caps you below the top band. --- ## Check Your Understanding 1. In the Animal diagram, name two things `Duck` inherits from `Animal`, and one thing `Duck` adds of its own. >| **Inherits** (any two): `age`, `gender`, `isMammal()`, `mate()`. **Adds** (any one): `beakColor`, `swim()`, `quack()`. 2. What do `+` and `-` mean in front of an attribute or method? >| `+` means **public** (accessible from outside the class); `-` means **private** (accessible only inside the class). 3. Which design tool turns the *methods* in your class diagram into step-by-step logic — and at which level is it required? >| **Pseudocode**, required at **Level 9** (pseudocode for the functions and methods within your classes). See [VCAA Pseudocode — Not Python](/sd/C05/VCAA%20Pseudocode%20Not%20Python). --- ## Credits - Class-diagram example adapted from the [Mermaid](https://mermaid.js.org/) documentation's *Animal* sample. --- ## See also - [VCAA Pseudocode — Not Python](/sd/C05/VCAA%20Pseudocode%20Not%20Python) — write the pseudocode for each method (Level 9) - [Data Dictionary](/sd/C05/Data%20Dictionary) — each attribute is a data-dictionary field - [Sketch vs Mock-up](/sd/C05/Sketch%20vs%20Mock-up) - [C05 Resources](/sd/Resources/C05-Resources) ← Back to [C05 Home](/sd/C05/C05-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)