Show understanding of why user-defined types are necessary

Cambridge A‑Level Computer Science (9618) – Complete Revision Notes

1. Syllabus Overview

The Cambridge AS & A‑Level Computer Science syllabus is divided into two parts:

• AS‑level core (Units 1‑12) – fundamental concepts that appear in every exam.
• A‑level extensions (Units 13‑20) – deeper topics that build on the core and are examined in Paper 4 (practical).

Each unit is linked to the three Assessment Objectives (AO1–AO3):

2. AS‑level Core Topics (Units 1‑12)

3. A‑level Extensions (Units 13‑20)

4. In‑Depth: User‑Defined Data Types (Unit 13)

4.1 Why are user‑defined types necessary?

Primitive types (int, char, float…) store a single low‑level value. Real‑world entities, however, consist of several related attributes that must travel together through a program. User‑defined types provide:

• Abstraction – a complex concept is represented by a single, meaningful name.
• Encapsulation – related data are grouped, reducing the risk of mismatched or missing values.
• Reusability – the same definition can be instantiated many times.
• Readability & maintainability – code mirrors the problem domain (e.g., Student instead of a list of four variables).
• Type safety – the compiler can detect illegal operations at compile‑time.
• Extensibility – new fields can be added without rewriting every routine that uses the type.

4.2 Forms of user‑defined types

4.3 Composite vs. non‑composite user‑defined types

• Composite types contain other types as components (e.g., a struct holding an int and a float, a class that contains an array or another object).
• Non‑composite types are single‑valued but still defined by the programmer, such as an enum or a typedef alias.
• In languages that expose pointers/references, linked structures (lists, trees) are also considered user‑defined because they define new ways of organising data.

4.4 Language‑specific syntax (Java, Python, Visual Basic .NET)

public class Point {
public int x;
public int y;
public Point(int x, int y) { this.x = x; this.y = y; }
}

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])

Public Structure Point
Public X As Integer
Public Y As Integer
Public Sub New(x As Integer, y As Integer)
Me.X = x : Me.Y = y
End Sub
End Structure

public enum Year { FRESHMAN, SOPHOMORE, JUNIOR, SENIOR }

from enum import Enum
class Year(Enum):
FRESHMAN = 1
SOPHOMORE = 2
JUNIOR = 3
SENIOR = 4

Public Enum Year
Freshman = 0
Sophomore = 1
Junior = 2
Senior = 3
End Enum

public class Student {
private int id;
private String name;
private double gpa;
private Year year;
public Student(int id, String name, double gpa, Year year) {
this.id = id; this.name = name; this.gpa = gpa; this.year = year;
}
public int getId() { return id; }
public String getName() { return name; }
public double getGpa() { return gpa; }
public Year getYear() { return year; }
}

class Student:
def init(self, id: int, name: str, gpa: float, year: Year):
self._id = id
self._name = name
self._gpa = gpa
self._year = year
@property
def id(self): return self._id
@property
def name(self): return self._name
@property
def gpa(self): return self._gpa
@property
def year(self): return self._year

Public Class Student
Private _id As Integer
Private _name As String
Private _gpa As Double
Private _year As Year
Public Sub New(id As Integer, name As String, gpa As Double, year As Year)
id = id : name = name : gpa = gpa : year = year
End Sub
Public ReadOnly Property Id As Integer
Get : Return _id : End Get
End Property
' Additional read‑only properties omitted for brevity
End Class

4.5 Mathematical view of a composite type

Formally, a composite user‑defined type is the Cartesian product of its component types:

\[

T = T1 \times T2 \times \dots \times T_n

\]

Example – the Student class (Java version):

\[

\text{Student} = \text{int} \times \text{String} \times \text{double} \times \text{Year}

\]

4.6 When to introduce a user‑defined type (Checklist)

1. Several pieces of data always travel together (e.g. (x, y), a date, a bank‑account record).
2. The same collection of values is needed in more than one module or function.
3. Future extensions are likely – adding a field should not force a rewrite of existing code.
4. “Magic numbers” or loosely related variables can be replaced by a meaningful name.
5. Data hiding or validation is required (e.g. preventing a negative balance).
6. Behaviour belongs with the data (e.g. a Vector class that can add, scale, compute magnitude).

4.7 Practical tip – creating and testing a user‑defined type

public class PointTest {
@Test
void creation() {
Point p = new Point(3, 4);
assertEquals(3, p.x);
assertEquals(4, p.y);
}
}

import unittest
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
class TestPoint(unittest.TestCase):
def test_creation(self):
p = Point(3, 4)
self.assertEqual(p.x, 3)
self.assertEqual(p.y, 4)
if name == 'main':
unittest.main()

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Public Class PointTests
Public Sub TestCreation()
Dim p As New Point(3, 4)
Assert.AreEqual(3, p.X)
Assert.AreEqual(4, p.Y)
End Sub
End Class

4.8 Mapping to Assessment Objectives

4.9 Sample AO‑style questions

1. AO1 – Define an enum called Suit for a deck of cards and explain why using an enum is safer than an int.
2. AO2 – Write Java code to create an array of 10 Point objects, initialise them with coordinates (i, i²) and print the distance of each point from the origin.
3. AO3 – A traffic‑monitoring system records the vehicle type, speed, and timestamp. Design a suitable user‑defined type, justify your design, and draw a UML class diagram.

5. Quick Reference Tables (All Units)

5.1 Number‑base conversions

5.2 Common Big‑O patterns

5.3 OS scheduling algorithms

6. Key Take‑aways

• User‑defined types bridge the gap between low‑level primitives and high‑level problem domains, providing abstraction, encapsulation, reusability and type safety.
• Choose the form (record/struct, enum, class, ADT) that matches the language paradigm and the problem’s requirements.
• Master the exact syntax for Java, Python and Visual Basic .NET – the exam frequently asks for language‑specific declarations.
• Link every topic back to the three Assessment Objectives; practice AO‑style questions for each unit.
• Regularly design, code and unit‑test a small user‑defined type; this reinforces AO1 (knowledge), AO2 (application) and AO3 (design/evaluation) simultaneously.