Computer Science 9618/32 — May/June 2022

Background Concept

An enumerated type is a user-defined type that can hold one value from a fixed list of named values. It is useful when only a small number of valid options are allowed.

For example, if a building can only be one of these categories:

• house
• bungalow
• apartment
• farm

then using an enumerated type is better than using a string, because it restricts the value to one of the valid choices.

This helps with validation, consistency and avoiding typing mistakes.

Understanding the Question

The question says that BuildingGroup is no longer going to be a STRING. Instead, it is being changed to an enumerated type called BuildingType with the four given values.

So before the field can use BuildingType, you must first declare what BuildingType is.

Approach

To declare an enumerated type in pseudocode:

1. Write TYPE
2. Give the new type name
3. Use =
4. Put the allowed values in brackets, separated by commas

The order should match the values given in the question.

Step-by-Step Reasoning

The new type name must be BuildingType because that is stated in the question.

The allowed values are exactly:

• house
• bungalow
• apartment
• farm

So the declaration is:

TYPE BuildingType = (house, bungalow, apartment, farm)

Notice that this is a type declaration, not a field declaration and not an assignment statement.

Key Takeaways

• An enumerated type defines a fixed set of named values.
• It is used when only certain values are valid.
• The type must be declared before it is used in a variable or field declaration.

Common Mistakes

• Writing a field declaration instead of a type declaration.
• Leaving out one of the permitted values.
• Changing the type name from BuildingType to something else.
• Treating the values as strings rather than enumeration items.

Things to Be Careful About

• Use the exact type name given: BuildingType.
• Include all four values and no extra ones.
• This part only asks for the type declaration, not the record field declaration.
• Keep the syntax as a single enumerated list in brackets after =.

Background Concept

Once a user-defined type has been declared, it can be used just like a built-in type in later declarations. For example:

• INTEGER
• STRING
• REAL
• BuildingType

In a record or class, each field is declared by giving the field name followed by its type.

Understanding the Question

This part asks for the new declaration of the BuildingGroup field after BuildingType has been introduced.

Originally, the field was:

DECLARE BuildingGroup : STRING

Now that BuildingGroup must use the new enumerated type, only the type part changes.

Approach

Keep the field name exactly the same and replace STRING with BuildingType.

Step-by-Step Reasoning

The field name is still BuildingGroup.

The new type is BuildingType.

So the declaration becomes:

DECLARE BuildingGroup : BuildingType

This means the field can now hold only one of the allowed enumeration values defined earlier.

Key Takeaways

• A field declaration names the field and gives its type.
• User-defined types can be used in exactly the same place as built-in types.
• Changing a field from STRING to an enumeration restricts it to valid values.

Common Mistakes

• Writing DECLARE BuildingType : BuildingGroup, which reverses the field name and type.
• Leaving the type as STRING.
• Writing the full enumeration list again instead of using the type name.

Things to Be Careful About

• The field name is BuildingGroup, not BuildingType.
• The type name must match the earlier declaration exactly.
• This is still a field declaration, so it begins with DECLARE.

Background Concept

After a field is changed from STRING to an enumerated type, values assigned to it are no longer ordinary text strings. Instead, they are enumeration values from the predefined list.

That changes how the assignment looks:

• string value: "house"
• enumerated value: house

The field is still accessed using dot notation because it is still inside the BuildingRegister record.

Understanding the Question

This part asks for the new assignment statement after the type of BuildingGroup has changed.

That means you must not simply repeat the answer from part (a). The key change is that house is now one of the values of BuildingType, not a string.

Approach

1. Access the same field using BuildingRegister.BuildingGroup
2. Use the assignment arrow ←
3. Assign the enumerated value house
4. Do not write it as a string literal

Step-by-Step Reasoning

The left-hand side stays the same because the record variable and field name have not changed:

BuildingRegister.BuildingGroup

The right-hand side changes because the field type is now BuildingType, an enumeration. So the value should be one of the named enumeration items.

Therefore the assignment is:

BuildingRegister.BuildingGroup ← house

There are no quotation marks because house is no longer a string.

Key Takeaways

• Changing a field's type can change how values are written in assignments.
• Enumeration values are written as named items, not string literals.
• Dot notation is still used to access the field inside the record.

Common Mistakes

• Writing BuildingRegister.BuildingGroup ← "house", which treats the value as a string instead of an enumeration value.
• Forgetting BuildingRegister. and writing only BuildingGroup ← house.
• Using = instead of ←.

Things to Be Careful About

• This answer is different from part (a) for an important reason: the type has changed.
• Use the exact enumerated value name given in the question.
• Do not invent capitals or quotes unless the pseudocode definition used them.

Background Concept

In object-oriented programming, a class contains properties and methods.

• Properties store the data for each object.
• Methods perform operations on that data.

An access modifier controls where a property can be accessed from.

• PRIVATE means the property can only be accessed from within the class itself.
• PUBLIC means it can be accessed from outside the class.

Using PRIVATE is part of encapsulation, where data is kept inside the class and controlled through methods.

Understanding the Question

The question says that the record is being rewritten as a class called BuildingClass, and that all the properties are set to PRIVATE. It then asks specifically for the declaration of OwnerName as PRIVATE.

So this is not asking for a method or a full class definition. It only wants the single property declaration line.

Approach

Take the property name OwnerName, keep its data type STRING, and place PRIVATE before it in the same style as the example shown for PriceLastSold.

Step-by-Step Reasoning

The property name is OwnerName.

From the original record definition, OwnerName has type STRING.

The question says it must be private.

So the declaration is:

PRIVATE OwnerName : STRING

This follows the exact same format as the example:

PRIVATE PriceLastSold : REAL

Key Takeaways

• A class property declaration includes an access modifier, a name and a type.
• PRIVATE limits direct access to the property.
• The data type of a property should match the original design unless the question changes it.

Common Mistakes

• Writing DECLARE OwnerName : STRING instead of using PRIVATE.
• Writing a method declaration instead of a property declaration.
• Changing the type from STRING to something else.

Things to Be Careful About

• The question asks for one line only, not the whole class.
• Keep the identifier exactly as OwnerName.
• Use the same declaration style as the example provided.

Background Concept

A major idea in object-oriented programming is encapsulation. Encapsulation means combining data and the operations on that data inside a class, while controlling outside access.

This is often described as data hiding.

If properties are PRIVATE:

• code outside the class cannot read or change them directly
• the class decides how they are accessed, usually through public methods such as setters and getters
• the class can validate values before storing them

This helps keep objects in a valid state.

Understanding the Question

The question asks why the properties have been set to PRIVATE in BuildingClass.

It is not enough just to say "because of OOP". You need to explain the benefit:

• preventing direct access from outside the class
• protecting the data by controlling how it is changed

These are the ideas the mark scheme is looking for.

Approach

Give two linked points:

1. PRIVATE blocks direct external access
2. this supports encapsulation/data hiding and allows controlled access through methods

That covers both the mechanism and the reason.

Step-by-Step Reasoning

When a property is declared PRIVATE, only code inside that class can access it directly. That means another part of the program cannot simply change a value whenever it wants.

For example, if PriceLastSold or BuildingID were public, external code could assign unsuitable or invalid values directly. With PRIVATE properties, the class can require outside code to use methods instead.

Those methods can:

• check whether the new value is valid
• reject incorrect values
• keep the internal structure hidden

So the explanation is:

• the properties cannot be accessed or altered directly from outside the class
• this gives encapsulation/data hiding and protects the data by forcing controlled access through methods

Key Takeaways

• PRIVATE is used to restrict access to class data.
• Encapsulation means keeping data and the methods that manage it together.
• Data hiding helps protect objects from invalid or uncontrolled changes.

Common Mistakes

• Saying only "for security" without explaining what kind of protection is meant.
• Naming "encapsulation" but not explaining that outside code cannot directly access the data.
• Confusing PRIVATE with encryption or password protection. This is about program design, not cryptography.

Things to Be Careful About

• The question asks why the properties are private, so focus on access control and protection of the object's data.
• Mentioning methods is helpful because it shows how access is controlled.
• Do not drift into unrelated OOP ideas like inheritance or polymorphism unless they directly support the point.