TutorChase logo
Decorative notebook illustration
IB DP Computer Science Study Notes

D.3.1 Introduction to Fundamental Programming Constructs

In this exploration of programming fundamentals, we aim to clarify core concepts pivotal to object-oriented programming (OOP). These constructs are foundational for creating structured, efficient, and reusable code.


A class in programming embodies the concept of encapsulation, which is a fundamental tenet of OOP.

  • Definition: A class is akin to a blueprint for objects; it encapsulates data for the object and defines behaviour through methods.
  • Structure:
    • Attributes: Variables that hold the state of an object.
    • Methods: Functions that define what an object can do.
  • Example: Consider a `Vehicle` class, which may include attributes such as `speed` and `color`, and methods like `accelerate()` and `decelerate()`.


Identifiers are the human-readable names we assign to different parts of our code such as variables, methods, and classes.

  • Rules for Identifiers:
    • Begin with a letter, underscore, or currency character.
    • May include any combination of letters, digits, and underscore characters thereafter.
    • Must not match any reserved keywords in the programming language.
  • Good Practices:
    • Use meaningful names that convey purpose.
    • Follow naming conventions like camelCase for variables and methods, and PascalCase for class names.

Primitive Data Types

Primitives are the basic data types that are built into the language and are not objects.

  • Types and Uses:
    • int: An integral value commonly used for counting and indexing. For example, `int pageCount = 5;`.
    • long: A wider integer type when `int` is insufficient. Usage could be for time in milliseconds since the Unix epoch.
    • double: For decimal numbers, such as monetary values, `double price = 10.99;`.
    • char: Represents single characters like 'A' or '?'. For instance, `char grade = 'A';`.
    • Boolean: For true/false values, often used in control flow, e.g., `boolean isFinished = false;`.
  • Memory Considerations:
    • Primitive types are efficient in terms of memory usage and performance.
    • They have a fixed size: `int` is typically 4 bytes, `long` is 8 bytes, etc.

Instance Variable

Instance variables are the attributes that store the data specific to an object and are defined within a class.

  • Definition: Variables that store object-specific data, different for each instance of a class.
  • Accessibility: Typically made private to adhere to encapsulation, accessed via getters and setters.
  • Example: In a `Book` class, `private String title;` is an instance variable representing the book’s title.

Parameter Variable

Parameters are the variables listed as part of a method’s signature and are used to pass information into methods.

  • Scope: Their scope is confined to the method they are declared in.
  • Lifetime: They only exist during the method's execution.
  • Example: In a method `public void setAge(int age)`, `age` is a parameter variable.

Local Variable

Local variables are confined to the block of code where they are declared, such as a method or a loop.

  • Lifetime: They are created when the block is entered and destroyed upon exit.
  • Initialisation: Must be initialised before use, as they do not have default values.
  • Example: In a for-loop `for (int i = 0; i < 10; i++)`, `i` is a local variable.


Methods define the actions that an object can perform and are a way to interact with the object.

  • Structure:
    • Access Modifier: Defines the visibility (e.g., public, private).
    • Return Type: Specifies what type of data the method will return.
    • Method Name: Should be descriptive of its functionality.
    • Parameters: Inputs that the method uses.
  • Example: `public int multiply(int number1, int number2) { return number1 * number2; }`

Accessor (Getter)

Accessor methods provide read access to private instance variables, adhering to the principle of encapsulation.

  • Standard Form: `public returnType getVariableName() { return variableName; }`
  • Purpose: Allows reading of private variables without exposing the variables themselves.

Mutator (Setter)

Mutator methods provide a controlled way to modify the value of a private instance variable.

  • Standard Form: `public void setVariableName(returnType value) { this.variableName = value; }`
  • Purpose: Enables the setting of private variables while implementing checks or validation.


Constructors are special methods called when an object is instantiated and are used to initialize objects.

  • Characteristics:
    • Same name as the class.
    • No return type, not even void.
  • Overloading: A class can have multiple constructors with different parameters.


The signature of a method is its declaration that includes the method's name and the parameter types.

  • Uniqueness: No two methods can have the same signature within the same class.
  • Example: `public double calculateInterest(double amount, double rate)` has a unique signature.

Return Value

The data that a method sends back to the caller is known as its return value.

  • Compatibility: The type of return value must be compatible with the return type specified in the method's declaration.
  • Example: In a method `public String getName()`, the return value is the name of type String.

Reference Class String

The String class in Java is a reference type that encapsulates a sequence of characters and provides a multitude of operations for string manipulation.

  • Characteristics:
    • Immutable: Once created, cannot be altered.
    • Commonly used methods: `charAt(), substring(), indexOf(), length()`.
  • Memory: String objects are stored in a special area of memory called the String pool.

Primitive vs Reference Types

It is essential to distinguish between primitives and reference types for effective memory and resource management.

  • Key Differences:
    • Primitive types store actual values, whereas reference types store addresses to the objects in memory.
    • Reference types can be null, indicating they do not refer to any object.
    • Primitive types are generally faster and require less memory.


This detailed explanation of fundamental programming constructs equips students with the knowledge to write clear and effective code. By understanding these concepts, students can create programs that are not only functional but also adhere to professional coding standards and practices. Remember, a strong grasp of these basics is the cornerstone of all programming tasks and challenges you will encounter in your journey through computer science.


A constructor is a special type of method in object-oriented programming that is automatically called when an object is created. Unlike other methods, a constructor does not have a return type, not even void, and its name must exactly match the class name. Constructors are used to initialise an object's state by setting initial values for its attributes or by performing any setup required before the object is used. While other methods perform specific functions when called, the sole purpose of a constructor is object instantiation and initialisation.

A method's return value is essential as it determines what data is outputted from the method, allowing for information to be passed back to the calling code. This mechanism is a cornerstone of modular programming, enabling the building of complex systems by dividing them into smaller, manageable methods that can communicate with each other. The type and nature of the return value also dictate how the method can be used; for example, a method returning a boolean might be directly used in a conditional statement, whereas one returning an object could be used to manipulate that object further.

An instance variable is associated with a particular instance of a class; each object has its own copy of an instance variable. In contrast, a class variable, often declared with the static keyword, is shared across all instances of the class. While an instance variable can represent unique properties, such as a bank account balance, a class variable could be used for something that should be consistent across all instances, like the interest rate applied to all accounts. This distinction is crucial in ensuring that certain data remains common to all instances, while other data remains unique to each.

Primitive data types like int and double are considered 'primitive' because they represent the most basic forms of data with which one can construct algorithms. Unlike objects, primitives do not have methods or attributes; they simply hold values. For instance, an int in Java directly stores numerical data and occupies a fixed amount of memory, typically 32 bits. Primitives are operated on by the language's built-in operators and are processed very efficiently by the CPU, which is why they are the preferred choice for mathematical operations, especially in performance-critical applications.

A local variable is declared within a block of code and its scope is limited to that block, whereas a parameter variable is declared in the signature of a method and its scope is the entire method. Local variables are used for temporary storage inside methods during execution, and they must be initialised before use. Parameter variables, on the other hand, are initialised when the method is called and a value is passed to it. The primary role of parameter variables is to allow external values to influence the method's execution.

Practice Questions

Explain the significance of using accessors and mutators (getters and setters) in the encapsulation of a class.

Accessors and mutators are integral to encapsulation as they provide controlled access to an object's data. Encapsulation, a core principle of object-oriented programming, restricts direct access to some of an object’s components, which is vital for security and data integrity. Accessors allow reading of data values without exposing the data itself, ensuring that object manipulation is performed through methods that can include validation logic. Mutators permit the alteration of data under controlled conditions, preventing unauthorized or incorrect updates to the fields, thereby maintaining the integrity of the object's state.

Describe how a method's signature is used to differentiate between methods in a class.

A method's signature, which consists of the method's name and the parameter list, is fundamental in differentiating methods within a class. It allows the compiler to distinguish between methods, even if they share the same name (method overloading). The signature does not consider the return type; thus, two methods with the same name but different parameter lists or types are considered unique. This is crucial in object-oriented programming as it enables the creation of methods that perform similar tasks but with different input parameters, enhancing the class's functionality and flexibility.

Alfie avatar
Written by: Alfie
Cambridge University - BA Maths

A Cambridge alumnus, Alfie is a qualified teacher, and specialises creating educational materials for Computer Science for high school students.

Hire a tutor

Please fill out the form and we'll find a tutor for you.

1/2 About yourself
Still have questions?
Let's get in touch.