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.

---
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.

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.
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.
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

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().

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).

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.

Credits

Class-diagram example adapted from the Mermaid documentation's Animal sample.