Object-Oriented Pseudocode Basics

You'll encounter plenty of object-oriented programming questions in your exams, and they're actually more straightforward than they look. The key is understanding that classes are like blueprints for creating objects.

Think of a class as a template - just like how architects use building plans to create different houses. Each class declaration contains attributes (the properties) and methods (the actions the object can perform).

Exam Tip: Always check your spelling carefully in pseudocode - marks are often lost for simple typos like "numberFl00" instead of "numberFloors"!

Building Class Structure

Let's break down a typical class building example that appears frequently in exams. You'll need to complete missing statements in class declarations - this tests whether you understand the basic structure.

The private attributes like numberFloors, width, and height store the object's data. Remember that private means only the class itself can directly access these values.

Public methods are your gateway to interact with the object. The new() procedure is the constructor - it sets up initial values when you create an object. Functions like getNumberFloors() retrieve data, whilst setNumberFloors() validates and updates it.

Quick Check: If a setter method needs to return true for successful changes and false otherwise, don't forget that validation step!

Inheritance in Action

Inheritance is where object-oriented programming gets really powerful. When you write class house inherits building, you're saying that a house is a type of building with extra features.

The house class gets all the attributes and methods from building, plus its own specific ones like bedrooms and bathrooms. This saves you from rewriting common code.

Notice how the constructor works here - super.new() calls the parent class constructor first, then you add the house-specific setup. This pattern appears in loads of exam questions.

Memory Aid: Think "super" as calling up to the parent class - it handles the building basics before you add house-specific details.

Arrays and Object Management

Real programs need to store multiple objects, which is where array management comes in. The houseRoad class demonstrates how to store objects in arrays properly.

The newBuilding() method shows a classic pattern - use an index variable (numberBuildings) to track where the next object should go. Then increment that counter after adding the object.

When creating objects, you'll often see questions asking you to declare objects and add them to collections. The syntax limeAvenue = new houseRoad() creates the container, then methods like newBuilding() populate it.

Exam Success: Always increment your counter after adding to arrays - forgetting this step means objects will overwrite each other!

Constructor Purpose and Class Relationships

The constructor method serves one crucial purpose - to create an object from a class. This simple definition is worth remembering because it's a common short-answer question.

Complex class hierarchies like building, office, and house show how object-oriented design mirrors real-world relationships. Each subclass inherits common building features whilst adding specific attributes.

Understanding these relationships helps you tackle inheritance questions confidently. Whether it's numDesks for offices or bedrooms for houses, each class extends the base building concept logically.

Final Tip: Constructors always have the same job regardless of the class - they initialize objects with starting values and set up the object's initial state.