JETS | IB - Wyatt's Notes

The IB does not expect a specific standard of Java to be taught but a subset of Java called JETS for Students to present OOP concepts

OOP is like building with LEGO — objects are modular, reusable blocks that can be combined to create complex systems: Encapsulation, inheritance, and polymorphism allow programmers to model real-world entities and relationships in code

Why it matters: OOP is the dominant paradigm for building large, maintainable software systems

The key insight: Encapsulation, inheritance, and polymorphism allow programmers to model real-world entities and relationships in code

• Main class should be placed at the top
• Constructors should be place as the first method

• Arithmetic
• +
• -
• *
• /
• %
• Relational
• ==
• !=
• >
• <
• $\ge$
• $\le$
• Boolean
• !
• &&
• ||

Primitive data types are data types other data types are constructed with, these are normally Built-in as standard data types of programming languages, in JETS, these are: | type declaration | Size | range | Standard | Default init value | | :---------------- | :---------------------------------------: | :--------------------------------------------------: | :------------------------------------------------------: | :------------------: | | byte | 8 bits | $-128\le n \le 127$ | signed | 0 | | int | 32 bits | $-2^{31}\le n \le 2^{31}-1$ | signed | 0 | | long | 64 bits | $-2^{63}\le n \le 2^{63}-1$ | signed | 0 | | double | 64 bits | $-1.8\times 10^{308} \le n \le 1.8\times 10^{308}$ | IEEE 754-1984 (double precision binary Floating-point) | 0.0d | | char | 16 bits | $0 \le n \le 2^{16} -1$ | UTF-16 | "\u0000' 'a' | | boolean | 1 bit (logical) 1 byte (in-practice) | false |

byte b = 120 // byte is an 8-bit signed type with range -128 to 127
int i = 1243 // int is a 32-bit signed type with range -2^31 to 2^31-1
long
double
char
boolean

Java access modifiers used in JETS are:

class ClassIdentifier{
  public int n1 = 0; //Accessible by any class
  protected int n2 = 0; //Accessible by any extended class
  private int n3 = 0; //Only accessible by the class
}

Type casting refers to the converting of value to another type:

int n1 = (int)9.8 //9
double n2 = (double)6 //6.0f
byte n3 = (byte)1000 //Signed integer truncated to 8 bits: 1000%256-256 = -24
char n4 = (char)75 //K, from ascii mapping

Error handling refers to the handling of exceptions for functions that:

type funcIdentifier () throws IOException

try{ /*commands*/ }
  catch(Exception e){ /*Error condition handle*/ }

OOP is a programming paradigm that organises code around objects, which are instances of classes. JETS is designed to demonstrate these core principles.

Encapsulation is the bundling of data (attributes) and methods that operate on that data within a Single unit (class), while restricting direct access to some of the object’s components.

• Private attributes can only be accessed through public methods (getters and setters).
• This protects the internal state of an object from unauthorised or accidental modification.

class Student {
  private String name;
  private int grade;

  public Student(String name, int grade) {
    this.name = name;
    this.grade = grade;
  }

  // Getter
  public String getName() {
    return this.name;
  }

  // Setter with validation
  public void setGrade(int grade) {
    if (grade >= 0 && grade <= 100) {
      this.grade = grade;
    }
  }

  public int getGrade() {
    return this.grade;
  }
}

Exam tip: In IB exams, encapsulation questions often ask you to identify whether attributes Should be private and explain why. Always justify with data protection/validation.

Inheritance allows a class (subclass/child) to inherit attributes and methods from another class (superclass/parent). This promotes code reuse and establishes an “is-a” relationship.

class Animal {
  private String name;

  public Animal(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  public void speak() {
    // General behaviour
  }
}

class Dog extends Animal {
  private String breed;

  public Dog(String name, String breed) {
    super(name); // Call parent constructor
    this.breed = breed;
  }

  // Overriding the speak method
  public void speak() {
    System.out.println("Woof");
  }

  public String getBreed() {
    return this.breed;
  }
}

Key concepts:

• extends keyword creates the inheritance relationship.
• super() calls the parent class constructor.
• The subclass inherits all public and protected members of the superclass.
• private members are not directly accessible but can be accessed through inherited public methods.

Polymorphism means “many forms.” It allows objects of different classes to be treated through a Common interface.

Method overriding: A subclass provides a specific implementation of a method already defined in Its superclass.

class Shape {
  public double area() {
    return 0;
  }
}

class Circle extends Shape {
  private double radius;

  public Circle(double radius) {
    this.radius = radius;
  }

  public double area() {
    return 3.14159 * this.radius * this.radius;
  }
}

class Rectangle extends Shape {
  private double width;
  private double height;

  public Rectangle(double width, double height) {
    this.width = width;
    this.height = height;
  }

  public double area() {
    return this.width * this.height;
  }
}

Method overloading: Multiple methods with the same name but different parameter lists within the Same class.

class Calculator {
  public int add(int a, int b) {
    return a + b;
  }

  public double add(double a, double b) {
    return a + b;
  }

  public int add(int a, int b, int c) {
    return a + b + c;
  }
}

Abstraction hides complex implementation details and shows only the essential features of an object. In JETS, this is achieved through abstract classes and interfaces.

abstract class Vehicle {
  private String type;

  public Vehicle(String type) {
    this.type = type;
  }

  // Abstract method — no implementation
  public abstract void move();

  public String getType() {
    return this.type;
  }
}

class Car extends Vehicle {
  public Car() {
    super("Car");
  }

  public void move() {
    System.out.println("Driving on road");
  }
}

UML (Unified Modelling Language) class diagrams are a standard way to represent the structure of OOP Programs. IB exams frequently include UML diagrams and ask you to interpret or construct them.

+------------------+
|     Animal       |
+------------------+
| - name: String   |
+------------------+
| + getName(): Str |
| + speak(): void  |
+------------------+
         ^
         | (extends)
         |
+------------------+
|       Dog        |
+------------------+
| - breed: String  |
+------------------+
| + speak(): void  |
| + getBreed(): Str|
+------------------+

Design patterns are reusable solutions to common programming problems. While the IB does not require Deep knowledge of design patterns, understanding these concepts helps with exam questions.

Ensures a class has only one instance and provides a global point of access to it.

class DatabaseConnection {
  private static DatabaseConnection instance;
  private String status;

  private DatabaseConnection() {
    this.status = "Connected";
  }

  public static DatabaseConnection getInstance() {
    if (instance == null) {
      instance = new DatabaseConnection();
    }
    return instance;
  }

  public String getStatus() {
    return this.status;
  }
}

A one-to-many dependency: when one object (subject) changes state, all its dependents (observers) Are notified and updated automatically. This is relevant to event-driven programming in the IB Syllabus.

int[] numbers = new int[5]; // Declare array of 5 integers
int[] values = {1, 2, 3, 4, 5}; // Initialise with values

ArrayList is not part of the basic JETS subset but appears in IB exam questions:

import java.util.ArrayList;

ArrayList<String> names = new ArrayList<String>();
names.add("Alice");
names.add("Bob");
String first = names.get(0); // "Alice"
int size = names.size(); // 2
names.remove(0); // Removes "Alice"

int[][] matrix = new int[3][3];
matrix[0][0] = 1;
matrix[1][2] = 5;

// Iterating through a 2D array
for (int i = 0; i < matrix.length; i++) {
  for (int j = 0; j < matrix[i].length; j++) {
    System.out.println(matrix[i][j]);
  }
}

int score = 85;

if (score >= 90) {
  System.out.println("Grade A");
} else if (score >= 80) {
  System.out.println("Grade B");
} else if (score >= 70) {
  System.out.println("Grade C");
} else {
  System.out.println("Grade D");
}

// For loop
for (int i = 0; i < 10; i++) {
  System.out.println(i);
}

// While loop
int count = 0;
while (count < 10) {
  System.out.println(count);
  count++;
}

// Enhanced for loop (for-each)
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
  System.out.println(num);
}

Checks each element sequentially until the target is found.

int linearSearch(int[] arr, int target) {
  for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
      return i;
    }
  }
  return -1; // Not found
}

• Time complexity: $O(n)$ — worst case checks every element.
• Best for: Small or unsorted arrays.

Divides a sorted array in half repeatedly to find the target. The array must be sorted.

int binarySearch(int[] arr, int target) {
  int low = 0;
  int high = arr.length - 1;

  while (low <= high) {
    int mid = (low + high) / 2;
    if (arr[mid] == target) {
      return mid;
    } else if (arr[mid] < target) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return -1; // Not found
}

• Time complexity: $O(\log n)$ — much faster for large sorted arrays.
• Best for: Large, sorted arrays.

Repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the Wrong order.

void bubbleSort(int[] arr) {
  int n = arr.length;
  for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        // Swap
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

• Time complexity: $O(n^2)$ — slow for large arrays.
• Space complexity: $O(1)$ — sorts in place.

Finds the minimum element from the unsorted part and places it at the beginning.

void selectionSort(int[] arr) {
  int n = arr.length;
  for (int i = 0; i < n - 1; i++) {
    int minIdx = i;
    for (int j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) {
        minIdx = j;
      }
    }
    // Swap
    int temp = arr[minIdx];
    arr[minIdx] = arr[i];
    arr[i] = temp;
  }
}

1. Know the access modifiers: Understand when to use public``privateAnd protected. Most attributes should be private; most methods should be public.

2. Constructors come first: In JETS convention, constructors are placed as the first method in a class.

3. Use this keyword: When a parameter has the same name as an attribute, use this.attribute to distinguish them.

4. Read UML diagrams carefully: Identify the attributes (with types and access modifiers), methods, and relationships between classes.

5. Practise tracing code: IB exams often include code tracing questions where you must determine the output of a given program. Step through the code line by line.

6. Understand polymorphism: Be prepared to explain how method overriding works and why it is useful.

7. Be careful with array indices: Arrays in Java are zero-indexed. arr.length gives the number of elements, but the last valid index is arr.length - 1.

1. Forgetting edge cases in algorithm design (e.g., empty input, single element, already sorted data).

2. Confusing authentication (who you are) with authorisation (what you can do) in security contexts.

3. Confusing an algorithm with a program. An algorithm is a step-by-step procedure, not its implementation in code.

4. Mixing up Big O, Big $\Omega$, and Big $\Theta$ notation. Big O is an upper bound, not necessarily tight.

flowchart TD
    A[1_Object Oriented Programming] --> B[Key Concepts]
    A --> C[Core Principles]
    A --> D[Practical Applications]
    B --> E[Fundamental definitions]
    C --> F[Design patterns]
    D --> G[Real-world usage]

The key principles covered in this topic are linked in the sub-pages above. Focus on understanding the definitions, applying the formulas or frameworks, and evaluating strengths and limitations of each approach.

Worked examples demonstrating the application of key concepts are covered in the detailed sub-pages linked above.

• Object Oriented Programming
• IB Computer Science
• Programming Fundamentals