ISEAI Programming 2

This is the course material for ISEAI Programming 2, a course offered by the University of Jyväskylä.

About the Course

In this course, you will learn:

• the fundamentals and principles of object-oriented programming,
• how to develop small and medium-sized object-oriented programs,
• graphical user interface design and development,
• software testing,
• various programming tools and techniques.

News

Navigating This Material

Here are a few quick tips for navigating this course material.

• You can open and close the table of contents using the sidebar icon .
• You can navigate forwards and backwards through the material using the arrow icons on the left and right sides of the page (or at the bottom of the page when using a mobile device) .
• You can open the search function by clicking the magnifying glass icon in the upper-right corner or by pressing the S key on your keyboard .

Authors and License

Programming 2 course material © 2025 by Denis Zhidkikh, Sami Sarsa, Antti-Jussi Lakanen, Rauli Ruokokoski, Karri Sormunen and Ville Rantala.

Special thanks to Jonne Itkonen for feedback and improvement suggestions.

This material is published under the CC BY-SA 4.0 license. For more information, see the material's GitHub page.

Tool Instructions

On the Programming 2 course, we use the following tools:

• Java Development Kit (JDK), a software development kit that includes, among other things, the Java compiler and the Java Virtual Machine for running Java programs.

• Git, a version control system (VCS) that enables source code versioning and collaboration between developers.

• IntelliJ IDEA, an integrated development environment (IDE) for developing and debugging Java programs and more. We use the free Community Edition of IntelliJ IDEA.

• SceneBuilder, a helper tool for creating JavaFX user interfaces.

The above programs are pre-installed in the Agora computer classrooms. If you have your own computer, we strongly recommend installing them there as well. In particular, completing the project work is much easier when all required tools are available on your own computer.

The officially supported operating systems for this course are Windows, macOS, and Linux. Installing the tools on ChromeOS may be possible, but unfortunately we cannot provide support for that operating system. For this reason, we do not recommend using ChromeOS.

Select your operating system below.

winver

Prerequisites

xcode-select --install

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Press RETURN/ENTER to continue or any other key to abort:

BREW_PREFIX=$( [[ $(uname -m) == arm64 ]] && echo /opt/homebrew || echo /usr/local )
echo >> ~/.zprofile
echo "eval \"\$(${BREW_PREFIX}/bin/brew shellenv)\"" >> ~/.zprofile
eval "$(${BREW_PREFIX}/bin/brew shellenv)"

brew --version

Homebrew X.X.X

Git

git --version

winget install -e --id=Git.Git --custom '/COMPONENTS="ext,ext\shellhere,ext\guihere"'

Do you agree to all the source agreements terms?
[Y] Yes [N] No:

Successfully installed

git --version

git version X.XX.XX

Search → Git Bash → Git Bash

git --version

git --version

git version X.XX.XX

git --version

git --version

git version X.XX.XX

IntelliJ IDEA

winget install --interactive -e --id=JetBrains.IntelliJIDEA.Community

Settings
→ Editor
→ General
→ Inline Completion

Enable local Full Line completion suggestions

brew install --cask intellij-idea-ce

Settings
→ Editor
→ General
→ Inline Completion

Enable local Full Line completion suggestions

pacman -S intellij-idea-community-edition

snap install intellij-idea-community --classic

Settings
→ Editor
→ General
→ Inline Completion

Enable local Full Line completion suggestions

Disabling IntelliJ IDEA AI Assistance

IntelliJ IDEA includes two AI-powered code completion features: AI Assistant and Inline Completion. These attempt to automatically complete code as you write.

You can disable these features as follows.

1. Disabling AI Assistant

• Settings → Plugins
• Select the Installed tab
• Find JetBrains AI Assistant
• Disable the plugin or uninstall it completely

2. Disabling Inline Completion

• Open IntelliJ IDEA to the Welcome to IntelliJ IDEA screen

• Select Configure → Settings in the lower-left corner

• Navigate to:

  Editor
  → General
  → Code Completion
  → Inline
  

• Uncheck:

  Enable inline completion using language models
  

• Save the settings.

Java Development Kit (JDK)

• Open IntelliJ IDEA and wait until the Welcome to IntelliJ IDEA screen appears.

• Click New Project in the middle or upper part of the window.

• In the dialog that opens, click the JDK drop-down menu and select Download JDK....

• Configure the download as follows:

  • Version: 25
  • Vendor: Microsoft OpenJDK Do not change the path shown in the Location field. Finally, click Select.

• Leave the remaining project settings unchanged.

• Click Create in the lower-right corner and allow the project to load.

  This opens the IntelliJ IDEA development environment.

  Downloading the JDK may take some time. Wait patiently until all errors and red text disappear.

• When the project has loaded successfully and no errors are visible, run the project using the Play button in the upper-right corner.

• Wait for the project to compile.

  If everything works correctly, a console window should appear at the bottom with output similar to:

Hello and welcome!

i = 1
i = 2
i = 3
i = 4
i = 5

• You may now close IntelliJ IDEA.

SceneBuilder

What Next?

Congratulations!

You now have all the tools required for the course and can continue to the course materials.

Common Problems and Solutions

Project Assignment

The course includes a project assignment in which you implement a graphical Java application using the JavaFX library. The exact assessment requirements for the project are listed below.

You may either implement one of the predefined project specifications or come up with your own topic. Descriptions and requirements for all topics are provided below.

The project is completed incrementally during Parts 9–12. Each part contains guidance intended to help you progress, but you may also implement the requirements in another way as long as they are fulfilled.

We strongly recommend completing and studying the Todo application developed in Parts 7–8 before starting the project. It will provide significant assistance when implementing your own application.

You must demonstrate your final project, meeting all requirements, to your course instructor before submitting Part 12, either remotely or during in-person guidance. Once the instructor has approved the work, they will record the approval in TIM.

Pair Projects

The project may be completed individually or as a pair. In pair projects, the application must contain at least three domain entities (individual projects require two; Requirement 1.1) and three views (individual projects require two; Requirement 4.1). All other requirements remain the same as for individual work.

Both students must participate as equally as possible in the development of the project. When presenting the assignment, both students must be able to demonstrate to the instructor that they personally know how to implement the project requirements. For example, it is not acceptable for one student to focus solely on the user interface while the other handles all coding and data-model implementation.

Groups larger than two students are not permitted.

Topic

You may choose one of the predefined topics below or come up with your own topic that satisfies the requirements. Requirements marked as bonus () features are optional.

Technical Requirements and Assessment

The requirements below are used when evaluating the project. The project is graded on a pass/fail basis. A failed project may be revised based on feedback from the instructor.

In principle, the project must satisfy all of the requirements below. Individual requirements may be interpreted more flexibly if the project is otherwise particularly extensive or well executed, or if the project topic specifically requires it.

The final decision is made by the instructor on a case-by-case basis.

Basic Principles of Java Programming language

Learning objectives

• Get familiar with the syntax, variables and control-structures
• Lean how Java differs from Python
• Learn to write simple Java programs and understand how code is compiled and executed

Hello, Java!

Learning Objectives

• You will become familiar with the basics of the Java language.
• You will know how to compile and run a Java program.
• You will know what the (J)VM is and how compilation differs from interpretation.
• You will be familiar with Java equivalents of the most common I/O operations.

In the Programming 2 course, we use the Java programming language. Java is a general-purpose language that supports object-oriented programming and is designed for writing platform-independent programs. Java consistently ranks among the most popular programming languages (See for example TIOBE index, StackOverflow 2025 developer survey, Most popular languages in GitHub).

Basics of the Java Language

Let's begin with the traditional "Hello, world!" example in Java:

/* 1 */ void main() {
/* 2 */     IO.println("Hello, world!");
/* 3 */ }

Let's examine the program line by line:

1. Execution of a Java program begins from a method named main. The keyword void means that the method does not return any value. Since this main program does not take parameters, the parentheses following the word main can be left empty. The method body begins with an opening brace {.

2. Printing text to the command-line window is done using the IO.println method. In Java, statements usually end with a semicolon ;, as in this example.

3. The method body is terminated with a closing brace }. Program execution ends automatically when the main method has finished.

Although the program is very simple, it is still a fully valid Java program. Throughout the course, we will write many programs that output to and read from the command-line window. In the latter half of the course, the focus shifts toward graphical user interfaces.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Differences Between Java and Python

We can already observe several important differences between Java and Python. Some of these differences are syntactic, while others are related to the languages' semantics and type systems.

Syntactic Differences

In Python, indentation is used to mark the bodies of functions, loops, conditional statements and other control structures.

def weird(n: int) -> list:
    # The function body is indented using four spaces.
    sequence = [n]

    while n != 1:
        if n % 2 == 0:
            # The body of the if-statement is indented further.
            n /= 2
        else:
            # The body of the else-statement is indented further.
            n = n * 3 + 1

        # The body of the while-loop is indented using eight spaces.
        sequence.append(n)

    return sequence

In Java, code blocks are enclosed within curly braces { and }. These braces mark the beginning and end of method bodies, loops, conditional statements and other language constructs.

Although indentation is not required by the Java compiler, it is still used to improve readability and make program structure easier for humans to understand.

Another notable difference is that Java statements are typically terminated with a semicolon ;.

Typing System

As you learned in Programming 1, Python supports type hints, which can make programs easier to read and understand.

def square(n: float) -> float:
    return n * n

However, Python is a dynamically typed language, meaning that type hints are optional and are generally not enforced by the interpreter.

Java, on the other hand, is a statically typed language. As a result, type information is required when defining methods and variables.

The equivalent Java method would be:

double square(double n) {
    return n * n;
}

void main() {
    IO.println(square(10));
}

In Java, we must explicitly specify the return type of the method, which in this example is double. We must also specify the type of each parameter. Here the method has a single parameter named n, whose type is also double.

Static typing allows the compiler to detect many programming errors before the program is executed.

In the next section, we will examine Java's primitive data types in more detail.

Methods and Functions

In Python, reusable pieces of code are usually called functions.

In Java, similar constructs are typically called methods, because they are usually associated with a class. Since we have not yet introduced classes, we may occasionally use the terms function and method interchangeably in the first chapters.

Later in the course, we will see why Java programmers usually prefer the term method.

Java Coding Conventions

Most programming languages have a set of coding conventions established for that language. Java is no exception. We will become familiar with various conventions as this material progresses. It is worth mentioning that Java coding conventions differ slightly from those used in Python, particularly in naming and code formatting.

The most important Java conventions to keep in mind at this stage are:

• The opening brace { that starts a method body is usually placed on the same line as the method declaration. The same applies to other constructs that use braces, such as if, for, while, and do-while statements.

• Variables and methods use the camelCase naming style, where the first letter is lowercase and subsequent words begin with an uppercase letter. For example: thisIsAFunctionName.

• Files and classes use the PascalCase naming style, where the first letter is uppercase and each subsequent word also begins with an uppercase letter: HelloWorld.java, public class Student, and so on. PascalCase is similarly used for many other structures that we will learn later, such as interfaces and enumerations.

Guide: Compiling and Running Java Programs

Although many small programs like the one above could technically be created in a web browser, it is much more practical to use a dedicated development environment. In this material, we use the IntelliJ IDEA development environment for creating, running, and debugging Java programs.

Create a New Project

Next, let's create a simple project in IDEA. A project is IDEA's way of grouping source code files, tests, libraries, and other resources into a single entity.

Do the following:

1. Open IntelliJ IDEA and open the new project dialog.

• If you see Welcome to IntelliJ IDEA, select New Project.

• If an existing Java project is open, select File → New → Project from the menu bar.

• The menu options may be hidden behind a hamburger menu button depending on your configuration.

2. In the new project dialog:

• Select Empty Project from the list on the left.

• Enter HelloWorld into the Name field. Project names are usually written without spaces.

• Set the project location in the Location field. Click the folder icon on the right side of the field and choose a suitable directory. Choose a location that you will be able to find easily later.

• Clear the Create Git repository checkbox. We do not need version control yet.

  

3. After making these choices, click Create. IDEA will then create a new project in the selected directory.

Let's briefly review the most important parts of IDEA:

1. Code editor: displays the contents of opened files. Each opened file appears in its own tab.
2. Project explorer: displays folders and files belonging to the project. Files and directories can be added, removed, moved, and renamed here.
3. Run and debug controls: displays the program to be run, together with the run and debug buttons.
4. Views and tool windows: IDEA includes various views that are hidden by default. The sidebar can be used to open and hide them as needed. For example, the project explorer can be hidden by clicking its folder icon.

Create a Java Module

By default, a new project is empty. In IDEA, program code is written inside modules. Several modules can be added to the same project and developed or executed independently. For example, you might create a single project for all exercises of a given week and add each exercise as its own module.

Next, create a module named HelloProgram, add a new program to it, and run it.

Do the following:

1. Right-click the project name (HelloWorld) in the project view and select New → Module.

2. In the New Module dialog:

• Select Java as the module type.

• Enter HelloProgram into the Name field.

• Leave the Location field unchanged. IDEA automatically selects the correct location.

• Select IntelliJ as the Build system.

• Make sure the JDK field contains the same JDK version that you installed.

• Clear the Add sample code checkbox. We will create the source file ourselves.

  

  Finally, click Create. This creates a new HelloProgram directory containing a src directory.

Create a Source Code File

In an IntelliJ project, code belonging to a module is placed in the src directory. If a project contains multiple modules, each module has its own src directory.

Next, create a Java source code file:

1. Expand the HelloProgram module in the project explorer.
2. Right-click the src directory and select New → Java Compact File.
3. Enter the name Program and press Enter.

IDEA creates a new file named Program.java inside the src directory. IDEA also automatically inserts a main method skeleton into the source file and opens the file in the editor. You can later reopen the file by double-clicking it.

Write the Program

Next, write a simple "Hello, world!" program from scratch into the newly created Program.java file.

Do the following:

1. Delete all code currently in the file. IDEA usually inserts a default template into new source-code files. For this exercise, however, we will write the code ourselves.

2. Type the following code into Program.java:

   void main() {
       IO.println("Hello, world!");
   }
   

   Avoid copying and pasting the code. Typing it yourself often helps you remember where important programming symbols such as braces, parentheses, and semicolons are located.

Running the Program

Source files containing a main method can be executed. Execution can be started using the run button () located next to the main method or from IDEA's toolbar.

Do the following:

1. Click the run button to the left of the main method ().

   IDEA first compiles the program. Once compilation is complete, IDEA executes the program and opens the Run window below the editor. The first line shows the command IDEA used to execute the compiled file. The next line contains the output produced by our program: Hello, world! The final line indicates that the program terminated successfully.

2. Try running the program again using the created run configuration.

   The first time you run a source file, IDEA creates a run configuration. A run configuration is a small configuration file that stores execution-related settings such as: the JDK version to use, possible command-line parameters and the working directory By default, this configuration is stored in .idea workspace.xml.

   Once the run configuration has been created, you can run the program in the future directly using the run button in IDEA's toolbar. This makes it easy to execute programs without opening the source file separately.

   IDEA's toolbar should now display the name of the Program run configuration together with a run button. Try closing Program.java and running the program from the toolbar.

   Run configurations make it possible to execute programs located in different modules. Later in the material, we will also become familiar with the Gradle build tool, which allows us to create separate configurations for running, testing, and building projects.

tip

Become Familiar with Common Keyboard Shortcuts

Keyboard shortcuts speed up the use of the development environment, and with some practice it is possible to program almost entirely without using the mouse. Keyboard shortcuts depend on the operating system and selected keymap settings. However, IDEA displays shortcut keys in menus and tooltips, making them easier to learn.

You can modify keyboard shortcuts in File → Settings → Keymap You can also install keymaps from other development environments, such as Visual Studio Code, through: File → Plugins.

Compiling and Running from the Command Line

Before IDEA actually runs a program, it first compiles it into an executable form. Within IDEA this happens automatically when you press the run button, the debug button, or use commands from the Build menu. However, Java source code can also be compiled and executed manually from the command line. Understanding how this works helps you understand what IDEA is doing behind the scenes.

Let's now explore how a program is compiled and executed from the command line.

Get-ChildItem -Path "$env:USERPROFILE\.jdks" -Directory | Sort-Object Name -Descending | Select-Object -First 1 |
ForEach-Object { $env:JAVA_HOME = $_.FullName; $env:PATH = "$_.FullName)\bin;$env:PATH" }

export JAVA_HOME=$(/usr/libexec/java_home) && export PATH="$JAVA_HOME/bin:$PATH"

export JAVA_HOME=$(printf "%s\n" ~/.jdks/* | sort -V | tail -n 1) && export PATH="$JAVA_HOME/bin:$PATH"

Next, move into the project directory and examine its contents.

Because we are using an IntelliJ project, only a few important files and directories are present:

• HelloWorld.iml is the project settings file used by IDEA to recognize the directory as a Java project.
• HelloProgram is the source-code module directory.
• out contains compiled programs.

Next, move into the HelloProgram directory and inspect its contents.

A single module contains the following files and directories:

• HelloProgram.iml is the module settings file used by IDEA to recognize the directory as a Java module.
• src is the source-code directory containing the program's source code.

Move into the src directory and inspect its contents.

Files ending with .java are Java source code files. They contain the program as text and cannot yet be executed directly.

To run a program, it must first be compiled. As mentioned earlier, IDEA performs this automatically when running a program, but source code can also be compiled using the javac compiler included with the JDK. Let's compile Program.java. javac Program.java

If compilation succeeds, the javac command produces no output by default. Examine the directory contents again using ls.

As a result of compilation, a file with the .class extension is created. This file contains so-called bytecode. Bytecode is the compiled form of the program. It is not directly executable by the processor. Instead, it is an intermediate representation. Bytecode can be executed by the Java Virtual Machine (JVM), which is a separate program capable of interpreting and executing Java bytecode. Although this may sound complicated, the benefit is that a program compiled into Java bytecode can run on different platforms (Windows, macOS, Linux and others). provided that a JVM exists for that platform.

The JVM can then optimize the bytecode for the specific processor and operating system. Java's famous slogan: ”Write Once, Run Anywhere” refers to this principle.

The JDK also includes the Java Runtime Environment (JRE) and the JVM itself. A bytecode file can be executed using the java command: java Program

Notice that when using the java command, the .class extension is omitted. Later in the course we will learn about Gradle, which can compile multiple source files into a single .jar file containing everything needed to run the application. .jar files can also be executed using the java command.

Printing Text and Reading Input in the Command-Line Window

Later on it will often be useful to print information to the terminal and read information from it. Java's IO class provides three basic operations for console output and input:

Let's see how these work together.

You can freely modify the example below and experiment with different kinds of output:

void main() {
    String name = IO.readln("Enter your name: > ");
    IO.println();

    IO.println("Hello, " + name + "!");

    IO.print("This text");
    IO.print(" goes on the");
    IO.print(" same line");

    IO.println(); // Try removing this and see what happens

    IO.println("Welcome to the Programming 2 course!");
}

Variables and Data Types

Learning objectives

• You remember what variables and constants are.
• You remember what strings and lists are.
• You know Java's primitive data types.
• You know how strings, arrays, and lists are used in Java.

Programs process data stored in memory. In high-level programming languages, such as Java, human-readable names are used to refer to data stored in memory. Such a name that refers to data in memory is called a variable.

The programmer only needs to remember the name; the operating system and the computer's internal logic take care of the actual location of the data in memory.

Before a variable can be used, it must be declared:

type variableName;

The variable's type is written before its name and indicates what kind of data the variable can contain, such as an integer, a decimal number, or a boolean value.

The variable name is an identifier chosen by the programmer and used to refer to the variable.

A name may contain letters and underscores. However, a variable name cannot be a reserved Java keyword, nor may it begin with a number.

After a variable has been declared, values can be assigned to it:

variableName = expression;

The value of the expression on the right-hand side of the equals sign is stored in the variable named on the left-hand side.

If the variable previously contained another value, it is replaced by the new one.

void main() {
    double interestRate; // Variable declaration, double = decimal number
    double principal;    // Variable declaration

    interestRate = 0.05; // Assign a value to the variable
    principal = 150.0;   // Assign a value to the variable
 IO.println("interestRate = " + interestRate);
 IO.println("principal = " + principal);
}

A variable cannot be used until a value has been assigned to it at least once.

For this purpose, Java allows a combined declaration and assignment statement:

double principal = 0.05;

// Equivalent to:
double principal;
principal = 0.05;

A variable can also be part of an expression, allowing its value to be used as part of a larger computation.

void main() {
    double interestRate = 0.05;
    double principal = 150.0;

    double principalWithInterest = (1 + interestRate) * principal;
 IO.println("interestRate = " + interestRate);
 IO.println("principal = " + principal);
 IO.println("principalWithInterest = " + principalWithInterest);
}

In programming, an assignment is a statement, meaning a single executable instruction.

For example, the statement

double principal = 150.0;

can be understood as:

"Store the number 150.0 in memory at a location that will be referred to from now on as principal."

A variable's value remains unchanged until another statement modifies it.

Java data types can be divided into two main categories: primitive data types and reference data types

All information in a computer is stored in memory as binary numbers (sequences of zeros and ones). Data types differ in how much memory they occupy, what kind of data they represent, and what rules govern their use.

Primitive types contain simple values such as integers and boolean values, whereas reference types contain more complex structures such as objects, arrays, and strings.

Primitive Data Types

Java provides eight built-in primitive data types. These can be roughly divided into four categories: integers, floating-point numbers, characters, and boolean values.

Integers

There are four integer types, which differ in their range and memory consumption. The most commonly used integer type is int.

void main() {
    int largeNumber = 2000000000;
    IO.println("largeNumber = " + largeNumber);

    largeNumber += 1000000000;
    IO.println("largeNumber = " + largeNumber);
}

Floating-Point Numbers

Floating-point types are used to represent decimal numbers. The most common one is double.

void main() {

    // Rounding errors may occur
    double roundingError = 0.1 + 0.2;
    IO.println("roundingError = " + roundingError);

    // Division by zero is defined
    double negativeInfinity = -1.0 / 0.0;
    IO.println("negativeInfinity = " + negativeInfinity);

    double positiveInfinity = 1.0 / 0.0;
    IO.println("positiveInfinity = " + positiveInfinity);

    // 0/0 does not throw an exception
    double nan = 0.0 / 0.0;
    IO.println("nan = " + nan);
}

Characters

A single character is stored in a char variable, which uses 2 bytes of memory.

Boolean Values

Java provides the boolean type for truth values. It has only two possible values: true or false.

Reference Data Types

Unlike primitive types, a reference-type variable does not contain the actual data itself. Instead, it contains a small fixed-size value called a reference. Through this reference, a program can access the actual data, whose size or contents might not be known until runtime.

In practice, almost every Java type other than the primitive types is a reference type. For example String is a reference type and likewise arrays and lists. Starting from Chapter 2, we will explore object-oriented programming. In Java, all objects are reference types.

All reference-type variables can be assigned the special value null. A null reference indicates that the variable does not currently refer to any data. Attempting to read or modify a variable whose value is null usually causes a runtime error:

String text = null;
String upperCaseText = text.toUpperCase();
IO.println(upperCaseText);

java.lang.NullPointerException: Cannot invoke "String.toUpperCase()" because "<local1>" is null
	at main.main(main.java:3)

Since this error occurs only during execution, it is generally the programmer's responsibility to ensure that variables and method parameters do not contain null references. Such checks can be implemented using conditional statements, which are introduced in the next section.

Animal pet = new Dog();
pet = new Cat();

Literals

A literal is a fixed value written directly into source code. Each data type has its own syntax for literals.

• Characters (char): Character literals are enclosed in single quotation marks: 'A', '*' ,'x'. Special characters begin with a backslash: '\n' (new line), '\u03A9' (Greek capital omega Ω) and '\t' (tab character)

• Integers (byte, short, int, long): Integer literals are written directly as numbers: 42, -7 and 0. A long literal must end with either an uppercase or lowercase L or l: 12345678901L.

• Floating-Point Numbers (float, double): Floating-point literals are written using a decimal point: 3.14, -0.001 and 2.0. Scientific notation may also be used: 1.5e3 (1.5 × 10³ = 1500) and 2.0E-4 (2.0 × 10⁻⁴ = 0.0002). By default, decimal-number literals are of type double. To create a float literal, append F or f. For example 3.14f.

• Boolean Values (boolean): Boolean literals are written using the keywords: true and false.

void main() {
    char character = 'A';
     IO.println("character = " + character);

    int number = 123;
     IO.println("number = " + number);
    long largeNumber = 12345678901L;
     IO.println("largeNumber = " + largeNumber);

    double decimalNumber = -2.0;
     IO.println("decimalNumber = " + decimalNumber);
    float smallDecimal = 2.0f;
     IO.println("smallDecimal = " + smallDecimal);
    double scientificNotation = 1.5e-2;
     IO.println("scientificNotation = " + scientificNotation);

    boolean truthValue = true;
     IO.println("truthValue = " + truthValue);
}

Wrapper Classes

Each primitive type in Java has a corresponding wrapper class. A wrapper class wraps a primitive value inside an object, allowing primitive values to be treated as objects. For example: for primitive type int the wrapper class is Integer. Wrapper classes provide useful methods and constants such as toString() and MAX_VALUE. The following table shows the relationship between primitive types and wrapper classes:

The following example demonstrates the use of wrapper-class constants, methods and overflowing of range

void main() {
    byte oneByte = Byte.MAX_VALUE;
    short twoBytes = Short.MAX_VALUE;
    IO.println(oneByte);
    IO.println(twoBytes);
    IO.println(Short.toString(twoBytes).charAt(0));

    int maximum = Integer.MAX_VALUE;
    IO.println( maximum + " is the largest value that can be stored in an int variable");
    int overflow = Integer.MAX_VALUE + 1;
    IO.println("Overflowing the range:");
    IO.println(overflow);
}

Strings

In Java, strings are not considered primitive data types. However, Java provides special syntax for creating strings. A string can be created by enclosing characters in double quotation marks :

void main() {
    String text = "I am studying programming!";
    IO.println("text = " + text);
}

Strings in Java are immutable. If you perform an operation on a string, you receive a new string as the result. The original string remains unchanged. For example:

void main() {

    String immutable = "This string is immutable.";
    IO.println("immutable = " + immutable);

    immutable.concat(" Or is it?");
    IO.println("immutable = " + immutable);
}

The new string returned by concat() is not stored anywhere, so it is discarded and the original string remains unmodified. To modify the value stored in a string variable, you must assign the new string back to the variable:

void main() {
String immutable = "This string is immutable.";
IO.Printlnt("immutable = " + immutable);

// HIGHLIGHT_GREEN_BEGIN
immutable = immutable.concat(" Or is it?");
// HIGHLIGHT_GREEN_END
 IO.println("immutable = " + immutable);
}

String contains numerous useful methods. Some of the most commonly used ones are listed below.

Complete documentation for all methods can be found in the JavaDocs documentation (see Class String).

The following example demonstrates the use of some of these methods:

void main() {
    String text = "I am studying programming using Java.";
    IO.println("text = " + text);
    IO.println("First character: " + text.charAt(0));
    IO.println("Length of string: " + text.length());

    IO.println(); // Prints additional newline

    // Concatenation using +
    text = text + " Hello world!";
    IO.println("text (after addition) = " + text);

    // Replacing text
    text = text.replace("Java", "JAVA");
    IO.println("text (after replacement) = " + text);
    IO.println();

    // Split the string at periods
    // HOX! In split method the characters \^$.|?*+()[]{}
    // So for example if you would like to split at period, you need to write
    // text.split("\\.") and not text.split(".").
    // The last one is so called regular expression
    // which would split text at every character.
    String[] sentences = text.split("\\.");
    IO.println("sentences = " + Arrays.toString(sentences));

    IO.println();

    // Find position of a substring
    int programmingIndex = text.indexOf("programming");
    IO.println("programmingIndex = " + programmingIndex);

    // Extract a substring using the index
    String substring = text.substring(programmingIndex, programmingIndex + 11);
    IO.println("substring = " + substring);

    IO.println();

    // Operation "String + expression" converts the expression value into a string
    String anotherString = "1/2 = " + (1.0 / 2);
    IO.println("anotherString = \"" + anotherString + "\"");
}

Parsing Numbers from Strings

A string can be converted into a numeric value using the wrapper classes parsing methods. For example: Integer.parseInt() converts a string to an integer and Double.parseDouble() converts a string to a floating-point number.

void main() {
    String integerString = "42";
    int integerValue = Integer.parseInt(integerString);
    IO.println("integerValue = " + integerValue);

    String decimalString = "3.14";
    double decimalValue = Double.parseDouble(decimalString);
    IO.println("decimalValue = " + decimalValue);
}

StringBuilder

Use the StringBuilder class whenever you need a mutable string. StringBuilder provides methods for modifying text without creating a new string object after every operation, resulting in better memory efficiency.

Some useful methods are listed below.

A complete description of all methods can be found in the JavaDocs documentation (see Class StringBuilder).

Example how to use StringBuilder methods

void main() {

    StringBuilder mutable = new StringBuilder("This is mutable");
    IO.println("mutable = " + mutable);
    IO.println("mutable.length() = " + mutable.length());

    IO.println();

    mutable.append(" string.");
    IO.println("mutable = " + mutable);
    IO.println("mutable.length() = " + mutable.length());

    IO.println();

    String immutableCopy = mutable.toString();
    IO.println("immutableCopy = " + immutableCopy);
}

Arrays

Arrays are used to store a collection of elements of the same type in a single variable. This makes data organization simpler and more efficient.

A new array can be declared and created in Java as follows:

Type[] name = new Type[size];

Here, new Type[size] creates an array containing size elements of type Type. After creating the array, values can be assigned using assignment statements:

void main() {
int[] grades = new int[4];
grades[0] = 4;
grades[1] = 2;
grades[2] = 2;
grades[3] = 5;
IO.println( "grades = " + Arrays.toString(grades));
}

In the expression [number], the number refers to the element's position, or index, within the array. Java uses zero-based indexing: so first element is at index 0, second one is at index 1 and so on. The index of the last element is always array.length - 1.

If the values are already known when the array is created, initialization can be written as:

void main() {
int[] grades = new int[] {4, 2, 2, 5};
    IO.println( "grades = " + Arrays.toString(grades));
}

The new Type[] portion may be omitted when declaration and initialization occur on the same line:

void main() {
int[] grades = {4, 2, 2, 5};
IO.println( "grades = " + Arrays.toString(grades));
}

In Java, the size of an array cannot be changed after it has been created. Attempting to access or assign an element outside the valid index range causes a runtime error:

int[] grades = new int[]{4, 2, 2, 5};
grades[5] = 3;

java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4
	at main.main(main.java:3)

The length of an array can always be checked using the length attribute. An array can be printed using Arrays.toString() (see JavaDocs )

void main() {
    int[] grades = {4, 2, 2, 5};
    IO.println( "Array length: " + grades.length);
    IO.println( "Array contents: " + Arrays.toString(grades));
}

Multidimensional Arrays

Unlike languages such as C#, Java does not provide a separate multidimensional array type. Instead, Java allows arrays whose elements are themselves arrays. In other words, a two-dimensional array has the type Type[][]:

void main() {
int[][] array2D = new int[][] {
    new int[] {1, 2, 3},
    new int[] {4, 5, 6, 7},
    new int[] {8, 9, 0},
};

// The length of the array is the number of arrays it contains,
// that is, the number of "rows".
IO.println( "The array contains " + array2D.length + " arrays.");

// Indexing works as normal -> each element is now an entire array
IO.println( "array2D[0] is an array: " + Arrays.toString(array2D[0]));
IO.println( "array2D[1] is an array: " + Arrays.toString(array2D[1]));
IO.println( "array2D[2] is an array: " + Arrays.toString(array2D[2]));

// Indexing individual elements also works normally,
// but do note the syntax!
int firstElement = array2D[0][0];
IO.println( "The first element of the first row: " + firstElement);

IO.println( "The third element (index 2) of row 2 (index 1) is: " + array2D[1][2]);
}

Notice that in the example above, array2D[0][0] refers to the first arrays (array2D[0]) first element within that array (array2D[0])[0] The structure can be visualized as follows:

Notice especially that the "row arrays" do not need to have the same length.

Constants

A variable whose value can only be assigned during initialization is declared using the final keyword. According to Java coding conventions, final variables are written using uppercase letters with words separated by underscores.

Java allows final to be used with both primitive and reference types. However, when used with a reference type, final means that the reference itself cannot be changed to point to a different object. The data referenced by the variable may still be modified if the type allows it.

final int DAYS_IN_WEEK = 7;

final int[] DAYS_PER_MONTH_LEAP_YEAR = new int[] {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

// DAYS_IN_WEEK = 8; // This would cause a compilation error
DAYS_PER_MONTH_LEAP_YEAR[0] = 30; // This is allowed

Constants are used, among other things, to improve code readability, reduce code duplication, increase reliability, and improve performance.

Lists

A list is a data structure that can grow and shrink as needed. Like an array, a list can contain only elements of a single type. Unlike arrays, the size of a list is not fixed, making lists more flexible when the number of elements is not known beforehand. Java lists correspond roughly to arrays in JavaScript.

The most commonly used list implementation in Java is ArrayList<T>, where T represents the type of elements stored in the list. To use lists, the appropriate classes must first be imported:

import java.util.*;

// Program code
void main() ...

The import statement tells the compiler that the program uses types from the java.util package. Briefly, a package is Java's way of organizing related classes.

If you have previously used Python, Java packages can be thought of equivalent of a Python package. import java.util.ArrayList; is conceptually similiar to from collections import deque in Python. Packages will be discussed in greater detail later. For now, it is sufficient to know that the compiler may not be aware of certain types unless they are imported.

Once the java.util package has been imported, lists can be initialized as follows:

import java.util.*;

void main() {
    // Method 1: Empty list without elements
    List<Integer> grades = new ArrayList<Integer>();

    // Add the elements one by one.
    grades.add(4);
    grades.add(2);
    grades.add(2);
    grades.add(5);
    IO.println("grades = " + grades);

    // Method 2: Initialized list where the elements are given
    List<Integer> predefinedGrades = new ArrayList<Integer>( List.of(4, 2, 2, 5));
    IO.println( "predefinedGrades = " + predefinedGrades);
}

Because of limitations in Java's generic type system, the element type of a list must always be a reference type. Therefore, the following is not allowed:

List<int> list = new ArrayList<int>();

error: unexpected type
List<int> lista = new ArrayList<int>();
     ^
  required: reference
  found:    int

If you need a list containing primitive values, use the corresponding wrapper classes, which works the same as the primitive values, but are reference type. In other words ArrayList<Integer> is allowed, whereas ArrayList<int> is not. Likewise, ArrayList<String> is valid because String is a reference type.

void main() {
ArrayList<String> names = new ArrayList<String>(List.of("Matti", "Teppo"));
IO.println("names = " + names);
}

void main() {
List<String> names = new ArrayList<String>(List.of("Matti", "Teppo"));
IO.println("names = " + names);
}

void main() {
// The compiler infers that ArrayList<> must be ArraList<String>
// based on the declared variable type
List<String> names = new ArrayList<>(List.of("Matti", "Teppo"));
IO.println("names = " + names);
}

Let's now look at some useful methods provided by lists.

Additional methods can be found in the JavaDocs documentation (see Class ArrayList<E>).

import java.util.*;

void main() {
    // Create an empty list of strings
    List<String> names = new ArrayList<>();
    // Add elements to the list
    names.add("Matti");
    names.add("Teppo");
    names.add("Liisa");

    // Print the size of the list
    IO.println("List size: " + names.size());
    IO.println("------");
    // Retrieve the element at index 1 (the second element)
    String second = names.get(1);
    IO.println("Second element: " + second);
    IO.println("------");

    // Remove the element at index 0 (the first element)
    names.remove(0);
    IO.println("Removed the first element.");
    IO.println("------");
    // Print all elements
    IO.println("names = " + names);
    IO.println("------");

    // Print the size of the list
    IO.println("List size: " + names.size());

    // Two examples of creating lists with predefined contents
    List<String> animals = new ArrayList<>(List.of("dog", "cat", "fish"));
    List<String> colors = Arrays.asList("red", "blue", "yellow");
    IO.println("animals = " + animals);
    IO.println("colors = " + colors);
}

Notice at least the following differences between Java, C#, and Python when working with lists. The variable i refers to a list index.

Java's Type System

Java is a statically typed language, which means that variable types are determined at compile time rather than during program execution. If you attempt to assign a value of the wrong type to a variable, the program will fail to compile and the compiler will report an error.

In practice, different data types cannot generally be used interchangeably unless Java explicitly allows it. For example a boolean value cannot be used as a numeric value and a reference value cannot be treated as an integer. If a programmer attempts to violate these rules, a compilation error occurs.

void main() {
    boolean truthValue = false;
    truthValue = 1;
}

error: incompatible types: int cannot be converted to boolean
    truthValue = 1;
                 ^
1 error

The compiler error above indicates that an integer (int) cannot be converted into a boolean (boolean). This is a clear difference compared to dynamically typed languages such as Python and JavaScript, where a variable's type is determined at runtime and variables may store values of different types during execution.

For example, the following code is valid in JavaScript:

let truthValue = true;
console.log(`truthValue = ${truthValue}`);
truthValue = 1;
console.log(`truthValue = ${truthValue}`);

However, it is inevitable that programs must work with values of different types. To support this, Java provides a number of automatic conversion rules that allow the compiler to perform implicit type conversions in assignments and expressions.

For example:

• An integer (int) can be automatically converted into a floating-point number (double).
• Smaller integer types (such as 8-bit byte) can be automatically widened into larger integer types (such as 32-bit int).

There are many such conversion rules. As a general principle, if a conversion does not result in information loss, Java usually provides an implicit conversion for it.

void main() {
    int integerValue = 23;
    IO.println("integerValue = " + integerValue);
    double decimalValue = integerValue; // OK: implicit int -> double conversion
    IO.println( "decimalValue = " + decimalValue);

    // NOTICE:
    // division is int / int => decimal part lost
    double halfIncorrect = 1 / 2;
    IO.println( "halfIncorrect = " + halfIncorrect);

    // CORRECT:
    // division int / double => double division
    double halfCorrect = 1 / 2.0;
    IO.println( "halfCorrect = " + halfCorrect);
}

In addition, the programmer may explicitly force a conversion using the syntax (newType)variable. This is known as an explicit type conversion or cast. Explicit conversions are used when the desired conversion is not allowed implicitly.

void main() {
    long hugeNumber = 40000000000L; // long = 64-bit integer
    IO.println("Large long value: " + hugeNumber);

    // long -> int is not implicit, but can be done explicitly
    int truncated = (int) hugeNumber; // int = 32-bit integer
    IO.println("int after explicit conversion: " + truncated);
}

In practice, static typing means that Java attempts to prevent type-related errors before the program is executed. The compiler acts as a safety net that ensures values, variables, and operations are compatible with one another before the program is run.

Control Structures and Basic Data Structures

Programming is rarely just about executing lines of code sequentially. To make programs useful, they must be able to make decisions, repeat actions, and manage data in a sensible way. In this section, we will cover Java's control flow mechanisms, iteration structures, and two ways of storing data: traditional arrays and flexible lists.

Comparison Operators

Before we can teach a program to make choices ("if this, then that"), we need to understand how a computer sees the world. Computer logic is binary: statements are either true (true) or false (false). Comparison operators can be thought of as questions that return a Boolean value. Below are the most common comparison operators in Java.

Often, decisions depend on more than one condition. For example:

"I will go outside IF it is not raining AND I have free time."

For this purpose, we use logical operators to combine conditions.

• && (AND): The expression is true only if both conditions are true.
• || (OR): The expression is true if at least one of the conditions is true.
• ! (NOT): Reverses a Boolean value (true becomes false, false becomes true).

Comparing Reference-Type Variables

Unlike primitive types (int, double, etc.), the == operator in Java compares references when used with reference types rather than the contents of the objects themselves. For this reason, the equals() method should be used when comparing the contents of strings and other reference-type variables.

void main() {
    String string1 = "Slush";
    String string2 = new String("Slush"); // Force creation of a new String object

    // INCORRECT: Compares references -> prints false
    IO.println(string1 == string2);

    // CORRECT: Compares contents -> prints true
    IO.println(string1.equals(string2));
}

Comparing Against null

Checking for a null reference can, however, be done with the == operator, because in this case we specifically want to compare references.

void main() {
    String string = null;
    IO.println(string == null);
}

Methods often use a null reference to represent the absence of a value. For example, IO.readln() may return null if input could not be read (see JavaDoc documentation). This may occur if the user terminates the program unexpectedly. In such situations, it can be sensible to verify that a variable is not null before using it.

void main() {
    String input = IO.readln("Enter input");

    if (input == null) {
        // Do something if no input was provided
        // For example: exit the program
        return;
    }

    // Here we know that input contains at least some string
    IO.println("Text in uppercase: " + input.toUpperCase());
}

Conditional Statements

Conditional statements control the flow of a program. Constructing a conditional statement always requires one or more Boolean expressions.

The if Statement

The basic conditional statement is if. The code block inside it is executed only if the Boolean expression inside the parentheses evaluates to true. Often, we also need alternative branches, in which case we use else if and else structures.

The syntax for the if statements is the following:

if (points >= 90) {
    IO.println("Grade: 5");
} else if (points >= 50) {
    IO.println("Grade: Pass");
} else {
    // Executed if none of the above conditions were met
    IO.println("Grade: Fail");
}

The switch Statement

When you want to compare the value of a single variable against several specific values (for example, a menu selection), a switch statement may be clearer than a long if-else chain.

int choice = 2;

switch (choice) {
    case 1:
        IO.println("You selected option 1");
        break; // Important: stops execution within this switch block
    case 2:
        IO.println("You selected option 2");
        break;
    default:
        IO.println("Unknown selection");
}

In addition to the traditional switch statement, modern versions of Java (Java 14+) support a more concise arrow syntax using -> operator.

void main() {
int choice = 2;

switch (choice) {
    case 1 -> IO.println("You selected option 1");
    case 2 -> IO.println("You selected option 2");
    case 6,7 -> IO.println("Six or Seven");
    default -> IO.println("Unknown selection");
}
}

The Ternary Operator

In simple either-or situations where you want to assign a value to a variable based on a condition, you can use the ternary operator (?:).

Syntax: (condition) ? valueIfTrue : valueIfFalse;

Example:

void main() {
    int number1 = 5;
    int number2 = 8;

    // Read as:
    // If number1 is greater than number2,
    // assign number1 to larger, otherwise assign number2
    int larger = (number1 > number2) ? number1 : number2;

    IO.println("The larger number is: " + larger);
}

Loops

Loops are needed when you want to perform actions repeatedly. Java provides four main ways to create loops: for, for-each, while and do-while.

for

Use a for loop when you know in advance how many repetitions are needed or when you need an index (position number) during the iteration. The structure is as follows:

for (initialization; condition; update) {
    // loop body
}

Below is an example of calculating a sum with a for loop.

void main() {
int[] numbers = {1, 2, 3, 4};
int sum = 0;

// Traverse the array using indices 0, 1, 2, and 3
for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}

IO.println("The sum is: " + sum);
}

The initialization, condition, and update expressions can technically be left empty, but the semicolons must remain in place. An infinite loop can be created by leaving the condition empty, although this is rarely desirable.

for-each

A for-each loop is often the most readable and safest way to iterate through an entire data structure. If you do not need the index and do not intend to modify the size of the structure, use a for-each loop.

The for-each loop has some limitations: You do not know the index of the current element and you cannot modify the structure by adding or removing elements.

void main() {
    int[] numbers = {1, 2, 3, 4};
    int sum = 0;

    // "For each number in the numbers array..."
    for (int number : numbers) {
        sum += number;
    }

    IO.println(sum);
}

while

A while loop is a good choice when you do not know beforehand how many times an action must be repeated. The loop continues as long as the condition remains true. Typical examples include reading a file line by line or running a game loop.

void main() {
    String input = "";

    IO.println("Welcome to the game! (Type 'quit' to exit)");

    // Note the "!" (NOT operator) and .equals() for strings
    // The loop continues as long as
    // input is NOT missing (i.e., not null)
    // AND input is NOT "quit"
    while (input != null && !input.equals("quit")) {
        input = IO.readln("> "); // Stops to wait user input

        IO.println("Echo: " + input);
    }

    IO.println("Game ended.");
}

do-while

This loop works like a while loop, but with one important difference: the loop body is always executed at least once because the condition is checked only at the end.

do-while is the only loop whose closing line ends with a semicolon.

The following pseudocode example repeatedly generates a new location for an apple if it is too close to the player.

void main() {
    Vector2D playerPosition = new Vector2D(0, 0);
    Vector2D applePosition = new Vector2D(0, 0);

    do {
        // Generate a new position for the apple
        applePosition.x = Math.random() * 10;
        applePosition.y = Math.random() * 10;
        // If the apple is too close to the player, generate a new position
    } while (applePosition.distanceTo(playerPosition) < 2.0);
}

Controlling Loop Execution

When necessary, loop execution can be controlled using the following statements:

• break: Terminates the loop and continues execution with the code following the loop.
• continue: Ends the current iteration and proceeds directly to the loop's update expression and condition check.

In the example below, the numbers 1, 2, 3, 4, 6, and 7 are printed. The number 5 is skipped, and the loop terminates when it reaches 8.

 void main() {
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue; // Move to the next iteration
    }

    if (i == 8) {
        break; // Stop the loop
    }

    IO.println(i);
}
}

Combining Control Structures

A loop structure can contain other structures, such as conditional statements and additional loops. When using nested structures, it is important to understand variable scope: a variable defined inside an inner structure is not visible outside that structure and a variable defined in an outer structure is visible inside nested structures.

For example, a variable defined inside an if statement cannot be used outside the if block.

void main() {
    int number = 10;

    if (number > 5) {
        int number2 = number + 1; // OK: number is defined in an outer scope
        number2 *= 5;
    }

    IO.println(number2); // ERROR: number2 is defined inside the if-block
}

error: cannot find symbol
    IO.println(number2);
               ^
  symbol:   variable number2

In situations like this, one solution is to move the variable declaration into the outer scope.

void main() {
    int number = 10;

    // Define and initialize the variable in the outer scope
    int number2 = 0;

    if (number > 5) {
        // OK: both number and number2 are defined in the outer scope
        number2 = number + 1;
        number2 *= 5;
    }

    // OK: number2 is defined in the same scope as this statement
    IO.println(number2);
}

Nested Loops

Nested loops mean writing one or more loop structures inside another loop. For each iteration of the outer loop, a certain number of additional iterations are performed by the inner loop.

A common use case for nested loops is processing multidimensional arrays T[][].

void main() {
int[][] table2D = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int rowIndex = 0; rowIndex < table2D.length; rowIndex++) {
    IO.println("Row " + rowIndex + ":");
    for (int columnIndex = 0; columnIndex < table2D[rowIndex].length; columnIndex++) {
        int element = table2D[rowIndex][columnIndex];
        IO.println("  Column " + columnIndex + ": " + element);
    }
}
}

Remember that int[][] means an array whose elements are themselves arrays of integers. Therefore, in the example above:

• table2D.length returns the number of arrays contained in table2D, that is, the number of rows.
• table2D[rowIndex] returns the int[] array stored at the specified index, containing all elements of that row.
• table2D[rowIndex][columnIndex] returns the element at index columnIndex within the row table2D[rowIndex].

Subroutines

• You can define a subroutine.
• You can process data using subroutines.
• You understand the difference between Java primitive types and reference types when calling a subroutine.
• You can document a subroutine.

A subroutine is a part of a program that performs a specific task. Subroutines make programs easier to structure because they allow a program to be divided into smaller, more manageable parts. Subroutines also improve reusability, as the same subroutine can be called multiple times from different parts of a program without rewriting the code.

Subroutines are sometimes called functions, and in the context of object-oriented programming, they are often referred to as methods. The exact terminology depends on the context, but in this context we use the term subroutine.

A subroutine can receive inputs, called parameters. After completing its task, a subroutine may return a result. Consider the average subroutine below, which calculates the average of a collection of integers. The subroutine receives an integer array as a parameter and returns the average as a double.

void main() {
    int[] numbers = {4, 8, 15, 16, 23, 42};
    double average = average(numbers);
    IO.println("The average of the numbers is: " + average);
}

double average(int[] numbers) {
    if (numbers.length == 0) {
        return 0;
    }
    double sum = 0;
    for (int number : numbers) {
        sum += number;
    }

    return sum / numbers.length;
}

Defining a Subroutine

The average subroutine above consists of four main parts (1) return type, (2) name, (3) parameters, (4) body.

• (1) Return type (here double): Specifies the type of value returned by the subroutine. If the subroutine does not return a value, the return type is void.
• (2) Subroutine name (here average): Specifies the name used when calling the subroutine.
• (3) Parameters (here int[] numbers): Variables declared within the parentheses that receive the inputs provided to the subroutine. A subroutine may have zero or more parameters, separated by commas. Each parameter has its own type and name.

Together, these three parts are called the subroutine declaration. In Part 2, we will also introduce object-oriented programming modifiers, which can be added to the declaration.

Following the declaration, the body of the subroutine is written inside curly braces. The body contains the code that is executed whenever the subroutine is called.

As with all source code, the names of subroutines and parameters should be descriptive, follow Java naming conventions, and comply with the style guide used in this course.

Return Values and Data Processing

A subroutine can be viewed as a black box: raw materials (parameters) go in, processing happens inside the box, and a finished product (the return value) comes out. The return keyword immediately terminates the execution of a subroutine and returns a value to the caller. The type of the returned value must match the return type specified in the subroutine declaration.

When using a subroutine written by someone else, we do not necessarily know what happens inside the box. Instead, we trust that it behaves according to its specification. This is common in programming, where we routinely use pre-existing libraries and subroutines.

Void Subroutines

Sometimes a subroutine is needed only to perform an action, such as printing text to the screen or causing some other side effect. In such cases, the subroutine does not need to return a value. The return type is then specified as void.

Parameter Passing: Primitive Types and Reference Types

It is important to understand what is actually passed as a parameter when a subroutine is called. In Java, all parameters are passed by value (pass-by-value), but the nature of the value being passed depends on the parameter's type.

• If the parameter type is a primitive type (such as int, double, char, or boolean), the subroutine receives a copy of the original value.
• If the parameter type is a reference type (such as an array), the subroutine receives a copy of the reference to the original data.

When a primitive type is passed as a parameter, (see Chapter 1.2) the value of the variable is copied and passed to the called subroutine. If the subroutine modifies this copy, the original variable remains unchanged.

void tryToModify(int number) {
    number = 99; // Only the copy is modified
    IO.println("Inside method: " + number);
}

void main() {
    int x = 10;

    tryToModify(x);

    IO.println("In main: " + x); // Still prints 10
}

When a reference type is passed as a parameter (see Chapter 1.2) , the reference is copied rather than the underlying data. The subroutine therefore receives a copy of a reference that points to the same data as the variable in the main program. If the subroutine modifies the data being referenced (for example, elements of an array), the change is visible in the main program as well.

You can think of a reference as a remote control used to operate a television, where the television represents the data. Even though a copy of the remote control is passed to the subroutine, it can still control the same television.

The following example demonstrates this by passing an int[] array as a parameter and modifying its elements:

void zeroArray(int[] array) {
    // This modification affects the original array!
    // The variable "array" refers to the same array.
    for (int i = 0; i < array.length; i++) {
        array[i] = 0;
    }
}

void main() {
    int[] numbers = {1, 2, 3};

    zeroArray(numbers);

    // The original array has been modified
    IO.println(numbers[0]); // Prints 0
}

However, it is important to understand that the subroutine call passed a copy of the reference, not the original reference itself. If the subroutine attempts to make the reference point to different data (for example, another array), this change will not affect the original reference in the calling code.

The following example demonstrates this:

void main() {
    int[] numbers = {1, 2, 3};

    changeReference(numbers);

    // The original array has not changed
    IO.println(numbers[0]); // Still prints 1
}

void changeReference(int[] array) {
    // This does not affect the original reference!
    array = new int[] {9, 9, 9};
}

In some languages, such as C++, it is possible to pass the original variable itself by reference (pass-by-reference). Java does not provide such a mechanism. Instead, all parameters are passed by value, as described above.

Subroutines and Side Effects

A subroutine that modifies data provided through its parameters is often said to produce side effects. For example, consider the following reverse subroutine, which reverses the order of elements in an array:

void reverse(int[] array) {
    // Implementation hidden to save space
 for (int i = 0; i < array.length / 2; i++) {
     int temp = array[i];
     array[i] = array[array.length - 1 - i];
     array[array.length - 1 - i] = temp;
 }
}

void main() {
    int[] array = {1, 2, 3, 4, 5};
    IO.println("array = " + Arrays.toString(array));
    reverse(array);
    IO.println("array = " + Arrays.toString(array));
}

Notice that reverse does not return a value, yet it has the side effect of reversing the array that was provided as a parameter. The same functionality could also be implemented without side effects by returning a new array instead:

int[] reverse(int[] array) {
    // Implementation hidden to save space
 int[] result = new int[array.length];
 for (int i = 0; i < array.length; i++) {
     result[i] = array[array.length - 1 - i];
 }
 return result;
}

void main() {
    int[] array = {1, 2, 3, 4, 5};
    IO.println("array = " + Arrays.toString(array));
    int[] reversed = reverse(array);
    IO.println("reversed = " + Arrays.toString(reversed));
}

Side effects can be useful, for example, when optimizing memory usage. However, they can also make programs more difficult to understand. In the example above, the side effect of void reverse(int[] array) is not immediately obvious unless the implementation of the subroutine is examined. Side effects can unintentionally modify or even destroy data if the programmer is not aware of them. For this reason, it is extremely important to understand how subroutines process their parameters.

Comments and Documentation

Source code can contain text that is not executable code but instead explains it. Such explanatory text comes in two forms: (1) comments written directly within the code (referred to simply as comments) and also (2) documentation comments.

The purpose of comments is to support the development process. They are intended for programmers working with the code. Documentation comments, on the other hand, are intended for everyone who uses the code. They are visible not only to the programmer who wrote the code but also to users who access the code through an API (Application Programming Interface), for example.

Single-Line Comments

Single-line comments, which use the syntax //, can be used to mark TODO items in code:

void main() {
    // TODO: Investigate potential issues with this solution
    String input = IO.readln();
    IO.println("You typed: " + input);
}

In general, a good principle is to write code that explains itself. Variables, classes, subroutines, and other programmer-defined names should be as descriptive as possible, reducing the need for comments on individual lines.

Sometimes, however, single-line comments are unavoidable when an operation is not self-explanatory or when a descriptive variable name would become excessively long:

void main() {
    int n = 9;
    // Rounds down to the nearest number divisible by four
    int rounded = n & ~3;
    IO.println(rounded);
}

The variable name roundedDownToNearestNumberDivisibleByFour would also not be a particularly reasonable alternative.

Multi-Line Comments

In Java, a multi-line comment is enclosed between /* and */. This style of comment is recommended when more complex logic requires additional explanation and/or when it is useful to explain why a particular solution was chosen. Unlike documentation comments, these explanations are not intended to be displayed to users of the code.

if (user.usesLegacySystem()) {
    /*
     * Users registered before 2022 still use the legacy
     * authorization model for the time being.
     * Do not remove this check until all accounts have
     * been migrated.
     */
    return useLegacyPermissions(user);
}

Documentation Comments

A documentation comment is a comment from which documentation intended for users of the code can be generated automatically. Examples of such documentation include HTML API documentation that explains how to use the code, as well as tooltips displayed by IDEs when using subroutines.

Documentation comments are placed immediately before the code element being documented, such as a subroutine or a class.

In Java, documentation comments use a special syntax that differs from ordinary comments. They begin with /** and end with */, making them very similar to multi-line comments.

 void main() {
     IO.println("sum(1, 2) ==> " + sum(1, 2));
 }

/**
 * Calculates the sum of two integers.
 *
 * @param a The first number
 * @param b The second number
 * @return The sum of the numbers
 */
int sum(int a, int b) {
    return a + b;
}

The basic structure of a documentation comment can be generated automatically in the IntelliJ IDEA development environment by typing /** above a subroutine declaration and pressing Enter.

All Exercises in This Part

Number of words: 5

int[][] matrix = {
    {42, 2, 3},
    {4, 67, 6},
    {7, 8, 9}
};

printMatrix(matrix);

42 2 3 4 67 6 7 8 9

1: 1 pcs
2: 3 pcs
3: 1 pcs

0: 3 pcs
1: 2 pcs
2: 3 pcs
4: 3 pcs

int digitAsNumber = Integer.parseInt(Character.toString(a));

int[] generateInput(int maxNumber) {
    Random r = new Random();
    List<Integer> numbers = new ArrayList<>(IntStream.range(1, r.nextInt(2, maxNumber + 1)).boxed().toList());
    Collections.shuffle(numbers);
    numbers.remove(r.nextInt(numbers.size()));
    return numbers.stream().mapToInt(Integer::intValue).toArray();
}

// Creates an random array of size 1-10, but with one number missing
int[] input = generateInput(10);

// Determine which number is missing
int missing = missingNumber(input);

Basics of Object-Oriented Programming

Learning objectives

• You understand the basic idea of object-oriented programming and how it differs from procedural programming.
• You can view an object as a whole in which data and behavior are combined.
• You understand the relationship between a class and an object, and how a class serves as a template for creating objects.
• You can define your own class and its members, including attributes, methods, and constructors.
• You understand the lifecycle of objects and can use objects as components of a program.
• You know what the static modifier means in relation to class members.
• You understand the principles and benefits of encapsulation and can distinguish an object's internal implementation from its external use.

Towards Object-Oriented Programming

Learning goals

• You take a step from the procedural programming mindset of data and functions toward the object-oriented programming mindset of state and methods.
• You understand the concept of an object: data and functionality combined into a single package.
• You understand how modeling concepts as objects can make building programs easier.

So far, we have mostly created programs in which data is stored in variables and processed using functions. This style of programming is called procedural programming. In this course, we will become familiar with another programming paradigm: object-oriented programming.

Object-oriented programming is a very broad topic, and in this course we will cover its theory selectively, focusing especially on the needs of this study module.

Basic Idea

The idea of object-oriented programming is to create structures called objects that contain both data and the functionality used to manipulate that data. Objects may be similar to one another, but each object has its own state, which can change during program execution. The state of an object is stored in its own variables, called attributes.

An object can also have its own subroutines, called methods. A method is a subroutine that belongs to an object and can inspect and modify the state of the object that owns it. Before objects can be created, a class must first be defined. A class describes the structure of an object.

Objects are meant to be responsible for the functionality within their own area of responsibility. Cooperation and communication between objects through method calls are central concepts in object-oriented programming. In some programming languages, this may be referred to as message passing.

A minimal program utilizing objects could look like this:

class Cat {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        this.name = newName;
    }
}

void main() {
    Cat cat1 = new Cat();
    cat1.setName("Miuku");

    Cat cat2 = new Cat();
    cat2.setName("Katti");

    IO.println(cat1.getName());
    IO.println(cat2.getName());
}

In the example, a class called Cat is first defined, and objects are then created from it in the main program. Each object contains a string attribute called name and two methods. The name of an object can be changed by calling its setName method and retrieved by calling its getName method. Both objects have their own state—that is, their own name. The state of one object does not affect the state of another.

From this simple example, we can see how data can be grouped inside objects. In this case, the object's only attribute, name, is accessed directly through methods. In practice, this kind of direct manipulation is uncommon in production code, but we will return to this topic later.

It is hardly worth creating separate objects for a single variable, but the benefits of object-oriented programming quickly become apparent when the amount of data increases. Consider a situation where we want to store information about competitors participating in a contest. There may be many competitors, and for each one we need to store at least a name, a competitor number, and a score. Using objects, we can keep a single competitor's data and the functionality related to modifying that data within the same structure, making the information easier to manage.

class Competitor {
    private String name;
    private int number;
    private int score;

    public Competitor(String name, int number, int score) {
        this.name = name;
        this.number = number;
        this.score = score;
    }

    // ...

    public void printInformation() {
        IO.println(String.format("%d: %s, %d points", number, name, score)); 
    }
}

void main() {
    Competitor[] competitors = {
        new Competitor("A", 2, 20),
        new Competitor("B", 4, 15),
        new Competitor("C", 6, 10)
    };

    for (Competitor competitor : competitors) {
        competitor.printInformation();
    }
}

Creating an equivalent program without object-oriented programming requires some mental gymnastics. One possible approach would be to use three separate arrays: one containing names, another containing competitor numbers, and a third containing scores. However, you would then need to ensure that each competitor's information is always stored at the same index in all arrays, which is cumbersome in practice and prone to errors.

Objects make it possible to package data and functionality together in a clearer and more organized manner. Organizing related data and functionality within the same structure makes program code easier to understand and extend. However, this is not the only advantage of object-oriented programming. We can also hide some of a class's implementation details for internal use only, allowing programmers who use the class to access only a carefully defined public interface without needing to understand its internal workings. In Part 3, we will also explore polymorphism, inheritance, and interfaces, where the benefits of object-oriented programming become even more apparent.

Main Program in Java

Java is a programming language that is particularly oriented toward object-oriented programming. Historically, even the main program had to be placed inside a class. In newer versions of Java, this has changed; writing simple programs has been made easier so that the main program no longer needs to be wrapped inside a class. You can read more about these changes from Java 21 documentation and Java 25 documentation published in autumn 2025.

Today, the straightforward main program used in these materials is sufficient:

void main() {
    IO.println("Hello World!");
}

Previously, a minimal Java program might have looked like this:

public class HelloWorld {
    public static void main(String[] args) {
        IO.println("Hello World!");
    }
}

The older-style example introduces a few new concepts that we will examine more closely in this section. First, a class is defined using the class keyword. In the example, the class is named HelloWorld. The main program, main, is placed inside this class. In the older style, the main program must also include the static modifier, which we will examine in more detail shortly.

Because the simpler style of writing a main program is a relatively new feature, the majority of examples found online and in books still use the original style, where the main program is embedded inside a class. This is useful to keep in mind when searching for information.

Class and Object

Learning goals

• You understand the relationship between a class and an object, and how a class serves as a template for creating objects.
• You can define your own class and its members: attributes, methods, and constructors.
• You understand the lifecycle of objects and know how to use objects as parts of a program.
• You understand how the this reference works in object methods.
• You know what the static modifier means for class members.

Class

The first step in object-oriented programming is defining a class using the class keyword. A class can be thought of as a blueprint or template from which objects are created. A class specifies what data an object contains (attributes) and what it can do (methods). Attributes and methods defined in a class are also called class members.

Let's do a small thought experiment: consider building houses. From a single architectural blueprint, many buildings can be constructed. They would have the same structure because they are built according to the same design, but each building would still have its own state: a different owner, color, interior, and so on. The blueprint can be compared to a class in object-oriented programming, while the buildings are the objects created from it. The name of a class describes what an object is. Therefore, if we created a class for buildings, a suitable name would be Building.

Note that in Java, class names are conventionally written starting with an uppercase letter.

Let's begin by defining an empty Building class and gradually expand it.

class Building {
    // Inside the class we define the structure
    // that objects created from this class will follow.
}

Objects (instances) are created from a class using the new keyword. This allocates memory for the object, selects and executes an appropriate constructor, and returns a reference to the newly created object. We store this reference in a variable so that we can access the object through it. The class name serves as the variable's type and tells the compiler what kind of object must exist at the referenced memory location.

void main() {
    // The expression 'new Building()' creates an object
    // and returns a reference to it.
    // We store this reference in the variable 'building'.
    Building building = new Building();
}

Attributes

An attribute is a variable defined inside a class but outside any methods. It represents a property, characteristic, or state of an object. Objects created from a class always contain the attributes defined in that class. While a class defines what information objects can have, attributes store the concrete values for each individual object. Like variables in general, attributes may be primitive data types or references. The same naming conventions apply to them. Note that variables declared inside methods are not attributes; they are local variables. Local variables are not part of an object's state.

Let's add a few attributes to our Building class.

public class Building {
    // These variables are attributes of the object.
    // Every building has an owner and a color, but
    // the values do not have to be the same for all objects.
    private String owner;

    // An attribute can be given a default value.
    // In this case, the default color is blue.
    private String color = "blue";
}

Attributes differ from local variables because their visibility can be controlled using access modifiers. Local variables only exist and are visible within a method during its execution. Attributes, on the other hand, exist for the entire lifetime of the object and are visible to all members within the class. Attributes can also be made visible outside the object, although this is generally considered a poor design choice. We will return to access modifiers later.

An attribute may be assigned a default value in the class definition. Objects created from that class then receive the same initial value for their corresponding attribute. If no default value is provided, the attribute's value can be set when the object is created, later through methods, or left uninitialized.

public class Building {
    // Object attribute with a default value.
    private String color = "blue";

    public void print() {
        // This local variable shadows the attribute.
        String color = "red";

        // Prints "red".
        // The identifier 'color' refers to the local variable.
        IO.println(color);

        // Prints "blue".
        // The object's attribute can be accessed using 'this'.
        IO.println(this.color);
    }
}

Methods

Subroutines defined inside a class are called methods. While an attribute represents the internal state of an object, a method can be described as the object's ability to perform some action. One distinctive feature of Java is that all subroutines are always contained within some class. Perhaps for this reason, Java developers commonly refer to all subroutines as methods.

Method definitions do not differ syntactically from other subroutines, and the same naming conventions apply. Methods can also be overloaded. Like attributes, their visibility outside the class can be controlled using access modifiers.

As with any subroutine, a method should perform the task indicated by its name. Large tasks should generally be divided into smaller methods.

To call an object's method, we need both the object and a reference to it. Let's add a couple of simple methods to our Building class for manipulating its state. Methods like these are often called accessor methods.

public class Building {
    private String owner;
    private String color;

    // Object method that receives a string and stores
    // it in the 'color' attribute.
    public void setColor(String color) {
        // The parameter and attribute have the same name,
        // so we use the 'this' reference.
        this.color = color;
    }

    // Object method that returns the value of the
    // 'color' attribute to the caller.
    public String getColor() {
        return this.color;
    }
}

void main() {
    // Create two buildings.
    Building building1 = new Building();
    Building building2 = new Building();

    // Use the objects' methods to change their state.
    building1.setColor("green");
    building2.setColor("white");

    // Print the colors using accessor methods.
    IO.println(building1.getColor()); // Prints "green"
    IO.println(building2.getColor()); // Prints "white"

    // Note! We cannot call an object method without an object.
    // Building.setColor("blue"); // Causes an error.
}

We could also add similar methods for the class's other attribute. Later in this chapter, we will discuss more sensible ways of managing object state, but for now simple get and set methods are sufficient.

The this Reference

The keyword this refers to the object itself. It acts as a reference to "this object" in whose context the code is currently executing.

In previous examples, we used the this reference to read the object's attributes:

public class Building {
    private String color;

    // ...

    public String getColor() {
        return this.color;
    }
}

This reference is automatically available whenever an object's method is called. When a method is invoked, this is automatically set to refer to the object whose method was called, and it cannot be changed. Through this reference, the method can access the correct object's state and other methods. Inside object methods, writing this is only required when another member with the same name exists within the current scope, such as a local variable. Therefore, we do not have to prefix every attribute or method call with this; the compiler can determine it automatically if no ambiguity exists.

In some programming languages, a similar reference is called self.

Let's look at a few examples.

public class Building {
    private String owner;
    private String color;

    public void setColor(String color) {
        // We use 'this' because the parameter and
        // attribute have the same name.
        this.color = color;
    }

    public String getColor() {
        // Here 'this' is optional.
        // There are no other variables named 'color'
        // in this scope.
        return this.color;
    }
}

void main() {
    Building house = new Building();

    // We call setColor through the reference 'house'.
    // Therefore, inside the method, 'this' refers
    // to the same object as 'house'.
    house.setColor("gray");

    IO.println(house.getColor());
}

Inside methods, we can use this just like any other reference variable. For example, we can pass it as a parameter to another method. This is not necessary when calling the object's own methods, but it allows us to pass a reference to the object to methods outside the class.

public class Building {
    private String owner;
    private String color;

    public String getOwner() {
        return owner;
    }

    public void setOwner(String owner) {
        this.owner = owner;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    // Object method
    public String beautify() {
        // Pass this object to a method in another class.
        return Formatter.formatNicely(this);
    }
}

public class Formatter {
    public static String formatNicely(Building building) {
        return "A lovely building owned by "
                + building.getOwner()
                + ", colored "
                + building.getColor().toLowerCase() + ".";
    }
}

void main() {
    Building house = new Building();
    house.setOwner("Mary Teacher");
    house.setColor("Yellow");
    IO.println(house.beautify());
}

Constructor

A constructor is a special method of a class that is used to initialize the state of a new object when it is created. The constructor's name is always the same as the class name and begins with an uppercase letter. This differs from the naming style typically used for other methods. A constructor does not have a return type. Instead, it always returns a reference to the newly constructed object.

Every class must have at least one constructor. So far, however, we have been creating objects without defining one ourselves. This works in Java because if a class contains no constructors at all, the compiler automatically creates a parameterless constructor. This automatically generated default constructor contains no statements. However, it is only generated if the class does not define any constructor of its own.

Because constructors share the same name as the class, defining multiple constructors with different parameters is a form of method overloading. The compiler chooses the appropriate constructor automatically based on the arguments provided during object creation.

Let's temporarily remove the methods from the Building class and examine what happens when objects are created.

public class Building {
    private String owner;
    private String color;
}

void main() {
    // We did not define any constructor,
    // so the object is created using the
    // automatically generated default constructor.
    Building building = new Building();
}

In this case, the object is created using the compiler-generated default constructor because no constructor has been defined. We can also define an equivalent constructor ourselves:

public class Building {
    private String owner;
    private String color;

    // Parameterless constructor equivalent
    // to the default constructor.
    public Building() {
        // Here we could initialize the
        // object's state if desired.
    }
}

void main() {
    // Object created using our own constructor.
    Building building = new Building();
}

Up to this point, we have been creating objects without proper initialization. This is generally not good practice.

A newly created building currently has neither an owner nor a color. The values of these attributes are null. Depending on the object and its intended use, such values may be acceptable. However, if a building exists, it should probably have some owner and color.

A better approach is for the object to be usable immediately after creation. We could create an object directly in the correct staty by defining a constructor that accepts the information needed to initialize the object's state as parameters and properly initializes its attributes.

Let's add a constructor to the Building class that receives the owner and color as parameters and uses them to initialize the object's attributes. This way, we do not have to set the attributes separately after the object is created. We can also remove the parameterless constructor so that objects can no longer be created in an invalid initial state.

public class Building {
    private String owner;
    private String color;

    public Building(String owner, String color) {
        // Initialize the object's state using the parameters.
        // Note the use of 'this', since the parameter names
        // are the same as the attribute names.
        this.owner = owner;
        this.color = color;
    }
}

void main() {
    // Two strings are provided as arguments.
    // They match the constructor we defined.
    Building building1 = new Building("University of Jyväskylä", "white");
}

A couple of observations: We cannot create a building using only one parameter, for example Building building2 = new Building("University of Jyväskylä"); because the constructor requires two parameters. Similarly, we cannot create a building without parameters Building building3 = new Building(); because the default constructor no longer exists.

Let's add a somewhat more advanced constructor that accepts another object of the same class and copies its state into the newly created object. Such a constructor is often called a copy constructor.

public class Building {
    private String owner;
    private String color;

    public Building(String owner, String color) {
        this.owner = owner;
        this.color = color;
    }

    // Constructor that copies another Building object.
    public Building(Building source) {
        this.owner = source.owner;
        this.color = source.color;
    }
}

void main() {
    Building building1 = new Building("University of Jyväskylä", "white");

    // By passing another Building object as an argument,
    // we use the copy constructor.
    // Both buildings now have the same owner and color.
    Building building2 = new Building(building1);
}

We can also use the this keyword inside a constructor similarly to a method call if we want to delegate object creation to another constructor of the same class. This often helps avoid code duplication.

Let's modify the class so that one constructor uses another constructor to initialize the attributes.

public class Building {
    private String owner;
    private String color;

    public Building(String owner, String color) {
        this.owner = owner;
        this.color = color;
    }

    public Building(Building source) {
        // Delegate construction to the constructor above.
        this(source.owner, source.color);
    }
}

int seconds = 75; // Example of value in parameter

// This gives the amount of minutes to be added
int minutesToAdd = (this.seconds + seconds) / 60;

int remainingSeconds = (this.seconds + seconds) % 60;

Static

Class members can be defined as belonging to the class itself rather than to individual objects by using the static modifier. Such members are called class attributes and class methods.

The word static can be slightly misleading. In this context, it does not mean that the member is permanent or immutable. Throughout this material, however, we use the term static to refer to class members.

Attributes and methods normally belong to an object. Object attributes and methods can access the object's state. A class attribute, on the other hand, is not part of any object's state. There is only one copy of it, shared by all objects of the class. If one object changes the value of a class attribute, the change is visible to all objects of the same class.

Similarly, class methods are shared by all objects of a class. They do not belong to any particular object and therefore cannot directly access an object's state. Objects may call static methods of their class, but doing so does not provide access to the object's state. Since static methods do not belong to any object, the this reference cannot be used inside them.

To call an object method, we need an object and a reference to it. A static class method, however, can be called directly through the class without creating an object. Although static methods can also be invoked through object references, doing so still does not grant access to any object's state.

Let's start with a class that has no static members.

public class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getName() {
        return firstName + " " + lastName;
    }
}

void main() {
    // We cannot call an object method directly
    // through the class.
    // Person.getName();

    Person p1 = new Person("Anna", "Korhonen");
    IO.println(p1.getName());
}

Because getName is an object method, we must first create an object. We cannot call it statically using something like Person.getName().

Now let's add a class attribute called adultAgeLimit, which represents the age of adulthood for all people. We will also add a method called isAdult that checks whether a given age qualifies as an adult. Notice that this method is not associated with any particular object. It simply evaluates the given age.

public class Person {
    private String firstName;
    private String lastName;
    private static int adultAgeLimit = 18;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getName() {
        return firstName + " " + lastName;
    }

    public static boolean isAdult(int age) {
        return age >= adultAgeLimit;
    }
}

void main() {
    Person p1 = new Person("Anna", "Korhonen");

    IO.println(p1.getName());

    // Static methods can be called through the class:
    IO.println(Person.isAdult(20)); // true
    IO.println(Person.isAdult(15)); // false

    // Static methods can also be called through an object,
    // but this is generally discouraged.
    // System.out.println(p1.isAdult(20));
}

We now have a class method, isAdult, that can be called without creating an object. We could call this through an object, but that's unecessary and compiler warns about it.

Static members are useful when we want functionality that does not belong to any single object but instead relates to the class as a whole.

Static members can also be accessed from object methods. For example, we can check if person is adult

// An object method can use a static variable.
public boolean isPersonAdult() {
    return this.age >= adultAgeLimit;
}

For clarity, it is often a good idea to use the class name even inside the class itself Person.adultAgeLimit. This makes it easier to distinguish static members from object members.

The previous example is also a warning: the adulthood limit can be modified from anywhere that has access to the Person class. Using this kind of global shared state is generally considered a poor design choice.

One example of a static method that we use frequently is IO.println(). This is a static method of IO class and it is convenient because we do not need to create a separate object every time we want to print something.

Object Lifecycle

During program execution, instances of classes are created; these instances are called objects. To access an object, we create a reference variable for it. During compilation, Java verifies that the variable type is compatible with the object being created and then stores a reference to the newly created object in that variable.

When an object is created, Java allocates space for it in the JVM's heap memory. When there are no longer any references to the object, it becomes eligible for destruction. In Java, programmers do not need to manually allocate or free memory. The memory occupied by discarded objects is eventually reclaimed by Java's automatic garbage collector.

Let's walk through an object's entire lifecycle using examples. To create objects, we first need a class. We'll once again use a Person class and add a few simple methods for modifying the object's state.

class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getName() {
        return firstName + " " + lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

void main() {
    // We can declare a reference variable without
    // making it refer to any object yet.
    // No object is created here.
    Person p0;

    // An object is created and its reference is
    // stored in p0.
    p0 = new Person("Mikko", "Mäkinen");

    // An object is created, but its reference is not
    // stored anywhere.
    // We can no longer access this object, so it
    // becomes eligible for garbage collection.
    new Person("Mikko", "Mäkinen");

    // Usually it is more straightforward to declare
    // the reference variable and create the object
    // in a single statement.
    Person p1 = new Person("Mikko", "Mäkinen");
    IO.println("p1: " + p1.getName());

    // We can create another object by supplying
    // values matching the constructor parameters.
    Person p2 = new Person("Anna", "Korhonen");
    IO.println("p2: " + p2.getName());

    // Multiple reference variables can point
    // to the same object. The object is not copied.
    Person p3 = p2;
    IO.println("p3: " + p3.getName());
}

In the main program above, objects are created in several different ways while demonstrating how references behave.

Once objects have been created, we can inspect and modify their state during program execution.

void main() {
    Person p1 = new Person("Joni", "Mäkinen");
    IO.println(p1.getName());
    p1.setLastName("Korhonen");
    IO.println(p1.getName());
}

class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getName() {
        return firstName + " " + lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

Let's finally examine the end of an object's lifecycle: its destruction. When an object no longer has any references pointing to it, it becomes garbage, meaning that Java's automatic garbage collection mechanism may eventually remove it from memory and reclaim the space it occupies.

void main() {
    // Create two objects.
    Person p1 = new Person("Joni", "Mäkinen");
    Person p2 = new Person("Anna", "Korhonen");

    // p1 is currently the only reference to the first object.
    // If we assign another reference to p1 or set it to null,
    // the object becomes eligible for garbage collection,
    // because no references to it remain.
    p1 = null;

    // When the method ends, all local variables created
    // inside it (p1 and p2) are destroyed.
    // If there are no other references to the objects,
    // they too become eligible for garbage collection.
}

class Person {
    private String firstName;
    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getName() {
        return firstName + " " + lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

We will not study Java's garbage collector or memory management in great detail in this course. For the purposes of this course, it is sufficient to understand when an object becomes garbage and can be destroyed. Once no references to an object exist, it becomes eligible for garbage collection, and Java may later reclaim the memory it occupies. If you would like to explore the topic in more detail, you can start by reading more about heap memory and memory allocation here, and about Java garbage collection from here, both of which provide relatively accessible introductions to the subject.

Encapsulation

Learning objectives

After this chapter, you will:

• Know what visibility modifiers such as public and private mean.
• Understand that methods are the primary way for objects to communicate.
• Understand the principles and benefits of encapsulation, and how an object's internal implementation differs from its external use.
• Be able to implement programs where objects work together without depending on each other's internal implementation.

Visibility Modifiers

Java provides three main visibility modifiers: public, protected, and private. Visibility modifiers determine from where the members of a class can be accessed.

If no visibility modifier is explicitly specified, the member receives package-private visibility. This means that the member is visible only to classes in the same package. The table below summarizes the effects of the different visibility modifiers. The Default row refers to package-private visibility.

The first column ("Class") indicates whether the class itself can access the member. As you can see, a class always has access to its own members. The second column ("Package") indicates whether other classes in the same package can access the member. The third column ("Subclass") indicates whether subclasses located outside the package can access the member. The fourth column indicates whether any other code can access the member.

When other programmers—or even your future self—use a class you have created, visibility modifiers help ensure that the class is used in the way it was intended. As a general rule, a programmer should use the most restrictive visibility modifier possible, unless there is a specific reason not to. This helps protect the internal state of the class and prevents both intentional and accidental misuse. In particular, public attributes should be carefully considered, as they expose the internal state of a class directly to external code. In this course, we aim to design programs so that public attributes—except constants—are not needed.

A visibility modifier can be assigned to attributes and methods by adding it to their declaration. Classes can also have visibility modifiers.

class Person {
    // The 'private' visibility modifier hides the attribute so that it
    // cannot be accessed from outside the class.
    private String firstName;
    private String lastName;

    // The 'public' visibility modifier allows the method to be called
    // from outside the class.
    public String getFullName() {
        return firstName + " " + lastName;
    }
}

Encapsulation and Cohesion

Encapsulation is one of the most important concepts in object-oriented programming. It refers to designing classes to be as independent and modular as possible. Each class has its own responsibility, and the information and functionality required for that responsibility are encapsulated within the object. Some of this information and functionality can be hidden for internal use only. To allow access to an object's state, a class typically provides a public interface consisting of methods. This improves maintainability and extensibility by reducing side effects caused by internal changes.

The first principle of encapsulation is:

Place related data and functionality inside the same structure.

We have already done this by defining classes together with suitable attributes and methods.

Cohesion describes how well a class's methods and attributes fit its intended purpose. The goal when designing classes is to achieve high cohesion. The members of a class should be closely related to what the class is meant to represent. For example, if we create a class representing a car, it may not make sense to include the owner's name, address, and phone number in that class. Owner-related information and functionality would likely belong in a separate class.

Let's create a class Car and apply encapsulation principles. First, we add only attributes and a simple constructor.

class Car {
    String model;
    String serialNumber;
    double kilometersDriven;

    public Car(String model, String serialNumber, double kilometersDriven) {
        this.model = model;
        this.serialNumber = serialNumber;
        this.kilometersDriven = kilometersDriven;
    }
}

We would also like to store information about the car's various components. For example, for the engine we might want to store its model and current RPM. For the tires, it would be useful to know at least the model, tire pressure, and perhaps also a type that allows us to distinguish between summer and winter tires. We could add all of this information directly to the Car class as attributes, but the number of attributes would become quite large because each tire has its own data. If we used arrays or lists, we would need several of those as well. It is also possible that a car might not always have an engine installed. Tires can also be removed, and the number of tires may vary between different car models.

The car does not really need to be aware of the internal workings of its engine or tires, so it is better to create multiple classes, each responsible for its own data and functionality.

Let's now add Engine and Tire classes and define suitable attributes and constructors for them.

class Engine {
    String model;
    double rpm;

    public Engine(String model, double rpm) {
        this.model = model;
        this.rpm = rpm;
    }
}

class Tire {
    String model;
    String type;
    double tirePressure;

    public Tire(String model, String type, double tirePressure) {
        this.model = model;
        this.type = type;
        this.tirePressure = tirePressure;
    }
}

Next, we add an engine and a list of tires as attributes of the Car class. These attributes contain references to Engine and Tire objects. Remember that references do not point to anything by default, so we must create the objects and assign the references ourselves. The Car object now contains objects from other classes that manage their own responsibilities as part of the overall car. This type of structure is called composition. One benefit of composition is that the engine or tires can easily be replaced by assigning the reference attributes to new objects.

Let's also add a small main program that creates a car with default values and prints some of its information. For now, we will still access attribute values directly, which is not considered good practice. We will improve this shortly.

class Engine {
    String model;
    double rpm;

    public Engine(String model, double rpm) {
        this.model = model;
        this.rpm = rpm;
    }
}

class Tire {
    String model;
    String type;
    double tirePressure;

    public Tire(String model, String type, double tirePressure) {
        this.model = model;
        this.type = type;
        this.tirePressure = tirePressure;
    }
}

import java.util.ArrayList;

class Car {
    String model;
    String serialNumber;
    double kilometersDriven;
    Engine engine;
    ArrayList<Tire> tires = new ArrayList<>();

    public Car(String model, String serialNumber, double kilometersDriven) {
        this.model = model;
        this.serialNumber = serialNumber;
        this.kilometersDriven = kilometersDriven;

        // Add an engine by creating a new Engine object.
        engine = new Engine("M100", 0);

        // Add four tires by creating Tire objects and
        // storing their references in the tires list.
        tires.add(new Tire("T1", "studded", 100.0));
        tires.add(new Tire("T2", "studded", 100.0));
        tires.add(new Tire("T3", "studded", 100.0));
        tires.add(new Tire("T4", "studded", 100.0));
    }
}

void main() {
    Car car = new Car("ABC", "123A", 0);

    IO.println("Car model: " + car.model);
    IO.println("Car serial number: " + car.serialNumber);

    IO.println("Engine:");
    IO.println("- " + car.engine.model);

    IO.println("Tires:");
    for (Tire tire : car.tires) {
        IO.println("- " + tire.model);
    }
}

The second principle of encapsulation is hiding a class's internal information and restricting access to it so that it can only be accessed through a carefully defined public interface. An object may contain a large amount of internal information used to maintain its state, and that information is usually not intended to be viewed or modified directly from outside the object. In fact, all attributes are typically hidden to prevent the object from being accidentally placed into an invalid state through direct modification.

To modify an object's internal state, classes define public methods that can be called from elsewhere in the program. These methods form the public interface mentioned above. All changes to the object's state take place through these methods, allowing invalid changes to be detected and handled appropriately within the method itself.

What attributes a class contains and how they are internally managed are usually implementation details that users of the class do not need to know. The purpose of hiding these implementation details is to make programming easier: when internal details are hidden and the object's state is managed only through its public interface, internal changes can often be made without affecting the code that uses the class. This is one of the greatest benefits of encapsulation.

Let's add a few methods to the Car class to provide a simple public interface. We will also hide the attributes so that the car's state can no longer be modified directly. The Engine and Tire classes remain unchanged for now.

import java.util.ArrayList;

public class Car {
    private String model;
    private String serialNumber;
    private double kilometersDriven;
    private Engine engine;
    private ArrayList<Tire> tires = new ArrayList<>();

    public Car(String model, String serialNumber, double kilometersDriven) {
        this.model = model;
        this.serialNumber = serialNumber;
        this.kilometersDriven = kilometersDriven;

        // Add an engine by creating a new Engine object.
        engine = new Engine("M100", 0);

        // Add four tires by creating Tire objects and storing
        // references to them in the tires list.
        tires.add(new Tire("TT", "studded", 100.0));
        tires.add(new Tire("TT", "studded", 100.0));
        tires.add(new Tire("TT", "studded", 100.0));
        tires.add(new Tire("TT", "studded", 100.0));
    }

    public void drive(double kilometers) {
        if (kilometers < 0) return;
        this.kilometersDriven += kilometers;
    }

    public void addEngine(Engine engine) {
        this.engine = engine;
    }

    public void addTire(Tire tire) {
        this.tires.add(tire);
    }

    public void printDetails() {
        IO.println("Model: " + model);
        IO.println("Serial number: " + serialNumber);
        IO.println("Kilometers driven: " + kilometersDriven);

        // We will add printing of the engine and tires next.
    }
}

void main() {
    Car car = new Car("ABC", "123A", 0);
    car.drive(100);
    car.printDetails();
}

class Engine {
    String model;
    double rpm;

    public Engine(String model, double rpm) {
        this.model = model;
        this.rpm = rpm;
    }
}

class Tire {
    String model;
    String type;
    double tirePressure;

    public Tire(String model, String type, double tirePressure) {
        this.model = model;
        this.type = type;
        this.tirePressure = tirePressure;
    }
}

We hid the attributes of the Car class using the private visibility modifier, and the car's state is now managed through a simple public interface. We also moved the responsibility for printing information into the class itself. We should make similar changes to the Engine and Tire classes so that the Car class can use their public interfaces instead of relying on their internal implementation details.

import java.util.ArrayList;

public class Car {
    private String model;
    private String serialNumber;
    private double kilometersDriven;
    private Engine engine;
    private final int maxTires = 4;
    private ArrayList<Tire> tires = new ArrayList<>();

    public Car(String model, String serialNumber, double kilometersDriven) {
        this.model = model;
        this.serialNumber = serialNumber;
        this.kilometersDriven = kilometersDriven;
    }

    public void drive(double kilometers) {
        if (kilometers < 0) return;
        this.kilometersDriven += kilometers;
    }

    public void addEngine(Engine engine) {
        this.engine = engine;
    }

    public void addTire(Tire tire) {
        if (tires.size() < maxTires) {
            tires.add(tire);
        }
    }

    public void printDetails() {
        IO.println("Car model: " + model);
        IO.println("Car serial number: " + serialNumber);
        IO.println("Kilometers driven: " + kilometersDriven);

        IO.println();
        IO.println("Engine:");
        IO.println();

        // Delegate the printing operation to the engine object.
        if (engine != null) {
            engine.printDetails();
        }

        IO.println();
        IO.println("Tires:");

        // Delegate the printing operation to each tire.
        for (Tire tire : tires) {
            IO.println();
            tire.printDetails();
        }
    }
}

public class Engine {
    private String model;
    private double rpm;

    public Engine(String model, double rpm) {
        this.model = model;
        this.rpm = rpm;
    }

    public void printDetails() {
        IO.println("Model: " + model);
        IO.println("RPM: " + rpm);
    }
}

public class Tire {
    private String model;
    private String type;
    private double tirePressure;

    public Tire(String model, String type, double tirePressure) {
        this.model = model;
        this.type = type;
        this.tirePressure = tirePressure;
    }

    public void printDetails() {
        IO.println("Model: " + model);
        IO.println("Type: " + type);
        IO.println("Pressure: " + tirePressure);
    }
}

void main() {
    Car car = new Car("ABC", "123A", 0);
    car.addEngine(new Engine("M1", 0));
    car.addTire(new Tire("T1", "studded", 10));
    car.addTire(new Tire("T2", "studded", 10));
    car.addTire(new Tire("T3", "studded", 10));
    car.addTire(new Tire("T4", "studded", 10));

    car.drive(100.0);
    car.printDetails();
}

Our Car class is now no longer dependent on the internal implementation details of the Engine or Tire classes.

Responsibility for an Object's State Belongs to the Object Itself

In some examples we have seen so far, attributes were hidden, but they could still be modified almost directly through methods. This is not entirely in line with the goals of object-oriented programming. A public interface is not intended to serve merely as an intermediate step for modifying an attribute. The idea of a public interface is to send an object a command to perform an action, after which the object carries out that action in the way it considers most appropriate.

A good example would be a game character whose position is represented by the coordinates x and y. Instead of modifying the character's position through simple setX and setY methods, we could define a method called moveTo that receives target coordinates and allows the character to perform the movement according to its own internal implementation and constraints. In this case, responsibility for movement belongs to the character itself. For example, if the character is temporarily unable to move, the method can handle the situation internally, and the code calling the method does not need to consider such special cases.

In practice, simple getter and setter methods are often used in production code because designing objects ideally takes time and effort. In some situations, directly modifying a simple attribute through a method may also be perfectly reasonable. Although such a method may seem unnecessary, its existence still provides an important benefit: the internal implementation of the class can be changed in the future without breaking the code that uses the class.

Unfortunately, we do not have time in this course to cover object-oriented design theory in depth. We recommend studying a dedicated object-oriented programming course for a more thorough understanding of these concepts.

Cooperation Between Objects

Let's review the concepts introduced in this chapter through another example involving object collaboration. The benefits of objects become much more apparent when we begin building programs consisting of multiple classes that work together. Now that we have learned the principles of encapsulation, we can use them to organize our code more effectively.

Objects can cooperate in many different ways. Objects can contain other objects—or, more precisely, references to other objects. When an object consists of other objects, each contributing its own functionality, this is often called composition. Objects can also call each other's methods to delegate tasks to the object that is responsible for them or communicate in response to events. Objects may additionally contain collections of other objects; for example, Java's built-in data structures are themselves objects that contain collections of objects.

Let's look at an example where we want our program to model buildings, rooms located within those buildings, and reservations made for those rooms. Each building can contain multiple rooms, and each room can contain multiple reservations. For now, we will ignore the possibility of overlapping reservations. We will also keep the classes relatively simple.

First, let's define the required classes: Building, Room, and Reservation and constructors for these classes.

import java.util.*;

public class Building {
    private String name;
    private List<Room> rooms = new ArrayList<>();

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

import java.util.*;

public class Room {
    private String name;
    private List<Reservation> reservations = new ArrayList<>();

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

    public String getName() {
        return name;
    }
}

public class Reservation {
    private String reservedBy;
    private int startTime;
    private int duration;

    public Reservation(String reservedBy, int startTime, int duration) {
        this.reservedBy = reservedBy;
        this.startTime = startTime;
        this.duration = duration;
    }
}

Next, let's add methods to the Building class for adding rooms. We would like to find a room later based on its name, so a building should not contain multiple rooms with the same name. Therefore, we also need a way to search for a room by name. To add a room, we only need the room's name.

import java.util.*;

public class Building {
    private String name;
    private List<Room> rooms = new ArrayList<>();

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

    public Room findRoom(String roomName) {
        for (Room room : rooms) {
            if (room.getName().equals(roomName)) {
                return room;
            }
        }
        return null;
    }

    public void addRoom(String roomName) {
        Room room = findRoom(roomName);
        if (room != null) {
            IO.println("Building " + name + " already contains room " + roomName);
            return;
        }
        rooms.add(new Room(roomName));
    }
}

import java.util.*;

public class Room {
    private String name;
    private List<Reservation> reservations = new ArrayList<>();

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

    public String getName() {
        return name;
    }
}

public class Reservation {
    private String reservedBy;
    private int startTime;
    private int duration;

    public Reservation(String reservedBy, int startTime, int duration) {
        this.reservedBy = reservedBy;
        this.startTime = startTime;
        this.duration = duration;
    }
}

Rooms should also support making reservations. To keep the example simple, we will assume that reservations start on the hour. The system might represent room reservations for a single day.

To make a reservation, we need the name of the person making the reservation, the starting hour, and the duration. Add the following method to the Room class:

public void addReservation(String reservedBy, int startTime, int duration) {
    reservations.add(new Reservation(reservedBy, startTime, duration));
}

Next, let's add the ability to create reservations through the Building class so that the user does not even need to know that the Room class exists. How the Building class stores room information remains an implementation detail hidden from the user.

To add a reservation, we need the room name, the name of the person making the reservation ,the starting hour and duration.

We will also add simple print methods to all classes so that we can easily display all rooms and reservations within a building.

import java.util.*;

public class Building {
    private String name;
    private List<Room> rooms = new ArrayList<>();

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

    public Room findRoom(String roomName) {
        for (Room room : rooms) {
            if (room.getName().equals(roomName)) {
                return room;
            }
        }

        return null;
    }

    public void addRoom(String roomName) {
        Room room = findRoom(roomName);
        if (room != null) {
            IO.println( "Building '" + name + "' already contains room '" + roomName + "'");
            return;
        }
        rooms.add(new Room(roomName));
    }

    public void addReservation(String roomName, String reservedBy, int startTime, int duration) {
        Room room = findRoom(roomName);
        if (room == null) {
            IO.println( "Building '" + name + "' does not contain room '" + roomName + "'");
            return;
        }

        room.addReservation(reservedBy, startTime, duration);
    }

    public void print() {
        IO.println(name);
        for (Room room : rooms) {
            room.print();
        }
    }
}

import java.util.*;

public class Room {
    private String name;
    private List<Reservation> reservations = new ArrayList<>();

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

    public String getName() {
        return name;
    }

    public void addReservation(String reservedBy, int startTime, int duration) {
        reservations.add(new Reservation( reservedBy, startTime, duration));
    }

    public void print() {
        IO.print(" ");
        IO.println(name);
        if (reservations.isEmpty()) {
            IO.print("  ");
            IO.println("No reservations.");
        } else {
            for (Reservation reservation : reservations) {
                reservation.print();
            }
        }
    }
}

public class Reservation {
    private String reservedBy;
    private int startTime;
    private int duration;

    public Reservation(String reservedBy, int startTime, int duration) {
        this.reservedBy = reservedBy;
        this.startTime = startTime;
        this.duration = duration;
    }

    public void print() {
        IO.print("  ");
        IO.println("From " + startTime + ":00 to " + (startTime + duration)
            + ":00, reserved by " + reservedBy);
    }
}

void main() {
    Building agora = new Building("Agora");
    agora.addRoom("Auditorium 1");
    agora.addRoom("AgFinland");
    agora.addRoom("AgFinland"); // Fails.

    agora.addReservation("AgFinland", "Maija", 8, 2);
    agora.addReservation("AgFinland", "Matti", 10, 2);
    agora.addReservation("Auditorium 5", "Maija", 13, 1); // Fails.

    IO.println();
    agora.print();
}

We can now use the Building class without needing to know anything about how rooms or reservations work internally. Similarly, the Building class does not depend directly on how the Room class stores reservation information.

At this point, we are still missing some of the most important tools of object-oriented programming: inheritance, polymorphism, and interfaces. We will explore these concepts in the next chapter.

All Exercises in This Part

int seconds = 75; // Example of value in parameter

// This gives the amount of minutes to be added
int minutesToAdd = (this.seconds + seconds) / 60;

int remainingSeconds = (this.seconds + seconds) % 60;

Inheritance and Polymorphism

Learning objectives

• You can create a class hierarchy using inheritance.
• You can override the functionality of a base class.
• You understand the difference between concrete and abstract classes.
• You understand how polymorphism enables different classes to be treated uniformly.

Inheritance

Learning Objectives

After completing this chapter, you will:

• Understand the concept of inheritance in object-oriented programming and know how to inherit classes in Java.
• Be able to create a simple class hierarchy where one class inherits from another.
• Understand that all Java classes ultimately inherit from the Object class.

Inheritance is a mechanism that allows a class to include the properties (attributes) and behaviors (methods) of another class. This enables code reuse and the creation of hierarchies between classes.

In practice, objects often share common characteristics. One way to handle these shared characteristics without duplicating code is through inheritance.

Student Information System

Let's consider an imaginary student information system.

Olli Student, Maija Teacher, and Satu Secretary could all be objects in a fictional student information system called Kisu. They all share properties common to all users, such as a name and a username. Each user should also be able to log in to and log out of the system.

However, each user also has characteristics specific to their role: A student may have a list of courses they are enrolled in and the credits they have earned. A teacher has courses they teach and a job title but does not have earned credits. A secretary is responsible for recording completed courses and awarding degrees but does not have a student number or teaching assignments.

Let's start with a simpler version of the system. Below are Student and Teacher classes containing a few attributes and methods. Examine these classes.

import java.util.*;

class Student {
    String name;
    List<String> currentCourses;

    public Student() {
        this.currentCourses = new ArrayList<>();
    }

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return this.name;
    }

    void showStudyProgram() {
        String courses = String.join(", ", currentCourses);
        IO.println(name + " studies the following courses: " + courses);
    }

    void enrollInCourse(String course) {
        IO.println(this.name + " enrolled in course: " + course);
        currentCourses.add(course);
    }
}

import java.util.*;

class Teacher {
    String name;
    List<String> coursesTaught;

    public Teacher() {
        this.coursesTaught = new ArrayList<>();
    }

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return this.name;
    }

    void showCoursesTaught() {
        String courses = String.join(", ", coursesTaught);
        IO.println(this.getName() + " teaches courses: " + courses);
    }

    void addCourse(String course) {
        coursesTaught.add(course);
    }
}

void main() {
    Student student = new Student();
    student.setName("Olli Student");
    student.enrollInCourse("Programming 2");

    Teacher teacher = new Teacher();
    teacher.setName("Maija Teacher");
    teacher.addCourse("Programming 1");
    teacher.addCourse("Programming 2");
    teacher.showCoursesTaught();
}

Notice that both classes contain the same name attribute as well as the methods getName and setName.

Although the classes also have differences, the duplication is problematic because:

• Every class must redefine the same properties and behaviors.
• If we want to change a shared property or behavior, we must make the change in multiple places.
• Adding a new class with the same characteristics requires copying the same code yet again.

Suppose we wanted to change the name attribute so that first and last names are stored separately. We would need to make the same modification in every class. This increases the likelihood of errors and makes maintenance difficult. One of the key principles of software development is Don't Repeat Yourself (DRY) (see Wikipedia)

Class Hierarchy

To avoid duplication, we can create a superclass called Person that contains all shared properties and behaviors. The subclasses Student and Teacher can then inherit from the Person class and automatically gain access to all of its attributes and methods. This allows us to add only the role-specific functionality to each subclass without duplicating common code.

Let's create a new Person class and modify the Student and Teacher classes so that they inherit from it. In Java, inheritance is implemented using the extends keyword. For example: class Student extends Person means that the Student class inherits from the Person class.

Let's make that change.

public class Person {
    String name;

    String getName() {
        return this.name;
    }

    void setName(String name) {
        this.name = name;
    }
}

import java.util.*;

class Student extends Person {
    List<String> currentCourses;

    public Student() {
        this.currentCourses = new ArrayList<>();
    }

    void showStudyProgram() {
        String courses = String.join(", ", currentCourses);
        IO.println(name + " studies the following courses: " + courses);
    }

    void enrollInCourse(String course) {
        IO.println(this.name + " enrolled in course: " + course);
        currentCourses.add(course);
    }
}

import java.util.*;

class Teacher extends Person {
    List<String> coursesTaught;

    public Teacher() {
        this.coursesTaught = new ArrayList<>();
    }

    void showCoursesTaught() {
        String courses = String.join(", ", coursesTaught);
        IO.println(this.getName() + " teaches courses: " + courses);
    }

    void addCourse(String course) {
        coursesTaught.add(course);
    }
}

void main() {
    Student student = new Student();
    student.setName("Olli Student");
    student.enrollInCourse("Programming 2");

    Teacher teacher = new Teacher();
    teacher.setName("Maija Teacher");
    teacher.addCourse("Programming 1");
    teacher.addCourse("Programming 2");
    teacher.showCoursesTaught();
}

Notice that the Student and Teacher classes no longer define the name attribute or the getName method or the setName method because these are inherited from the Person class. The code is now considerably cleaner and easier to maintain. Inheritance defines one superclass (Person) and one or more subclasses (Student, Teacher) that extend the superclass with additional information and functionality.

In other words, when Student and Teacher inherit from Person, they gain access to all non-private attributes and methods defined in Person. Private members remain part of the object's internal structure but are not directly available to subclasses. They are generally not considered part of the object's public interface.

In the literature, you may also encounter the terms base class (superclass) and derived class (subclass). These terms mean the same thing. In this material, however, we mainly use the terms superclass and subclass.

Inheritance can be represented using a diagram such as the following:

Here:

• Big letter C means Class
• Person is the superclass.
• Student and Teacher are subclasses.
• The inheritance arrow points from subclass to superclass.

This type of diagram is based on UML (Unified Modeling Language).

Constructors and the super Keyword

Constructors defined in a superclass can be called from a subclass using the super keyword. Let's look at an example where such a call becomes necessary.

Our previous example has a couple of problems. The Person class does not have a constructor, so the name is initialized through the setName method instead. This means that after a Person object has been created, the name attribute is initially null until it is explicitly assigned a value. This is not good practice for two reasons: an object should ideally be ready for use immediately after it is created, without requiring additional initialization. Secondly setting the name through a public setName method breaks the principle of encapsulation.

While there may be situations where changing a person's name is necessary in a student information system, allowing any object to change the name of any Person object through a public method is not desirable. Such changes should occur through a much more controlled process.

Let's improve the design. First, make the name attribute private in the Person class. Then add a constructor that receives a name as a parameter and initializes the attribute accordingly. After that, we can remove the setName method entirely, making the constructor the only way to assign a name. This means the name can no longer be changed after object creation, which is acceptable for our purposes at this stage.

We must also update object creation in the main program to use the new constructor.

class Person {

    // HIGHLIGHT_GREEN_BEGIN
    private String name;

    public Person(String name) {
        this.name = name;
    }
    // HIGHLIGHT_GREEN_END

    // HIGHLIGHT_RED_BEGIN
    void setName(String name) {
        this.name = name;
    }
    // HIGHLIGHT_RED_END

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

public class Main {
    public static void main() {
        // HIGHLIGHT_GREEN_BEGIN
        Student student = new Student("Matti Meikäläinen");
        // HIGHLIGHT_GREEN_END
        // HIGHLIGHT_RED_BEGIN
        student.setName("Matti Meikäläinen");
        // HIGHLIGHT_RED_END
        student.enrollInCourse("Programming 2");
        student.showStudyPlan();

        // ...
    }
}

Now that Person defines a constructor that takes parameters, Java no longer automatically creates a default no-argument constructor. As a result, the compiler produces an error similar to the following:

java: constructor Student in class Student cannot be applied to given types;
    required: no arguments
    found: java.lang.String
    reason: actual and formal argument lists differ in length

The essential point of this error message is that the constructor of Student does not match the way we are trying to create the object.

A very important observation follows from this: classes do not inherit constructors from their superclasses. For example, the Student class does not inherit the constructors of the Person class. Constructors must be defined separately in each subclass. Let's add constructors to both Student and Teacher. The beginning of the Student constructor might look like this:

class Student extends Person {
    public Student(String name) {
        // Constructor body goes here
    }
}

However, since we made the name attribute private, we cannot assign it directly in the subclass:

class Student extends Person {
    public Student(String name) {
        // HIGHLIGHT_YELLOW_BEGIN
        this.name = name;
        // HIGHLIGHT_YELLOW_END
    }
}

This results in compiler errors such as:

Student.java:6:5
java: constructor Person in class Person cannot be applied to given types;
  required: java.lang.String
  found:    no arguments
  reason: actual and formal argument lists differ in length

Student.java:8:13
java: nimi has private access in Person

The second error is our current concern. Because name is private, subclasses cannot access it directly.

Since the setName method was removed, the only way to initialize the name is to call the superclass constructor from within the subclass constructor and pass the required parameter to it. This is done using the super keyword. Let's modify both subclasses accordingly and make the remaining attributes private as well.

import java.util.*;
class Student extends Person {
    // HIGHLIGHT_GREEN_BEGIN
    private ArrayList<String> ongoingCourses;
    // HIGHLIGHT_GREEN_END


    // HIGHLIGHT_GREEN_BEGIN
    public Student(String name) {
        super(name);
        ongoingCourses = new ArrayList<>();
    }
    // HIGHLIGHT_GREEN_END
    // ...
}

Notice that the call to super(...) is usually the first statement in a constructor. With certain restrictions, the super(...) call may also appear elsewhere in the constructor body (see JEP 513: Flexible Constructor Bodies).

Make the same change to the Teacher class.

After doing so, the program still will not compile because the subclasses are still attempting to access the superclass's private name attribute directly.

class Student extends Person {
    void showStudyPlan() {
        String courses = String.join(", ", ongoingCourses);
        // HIGHLIGHT_YELLOW_BEGIN
        IO.println(this.name + " is studying: " + courses);
        // HIGHLIGHT_YELLOW_END
        // Compilation error: name is private
    }
}

The only way to access the name attribute is through the superclass's public getName() method. Replace all direct references to the name attribute in subclasses with calls to getName().

For example:

public class Person {
    String name;

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

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

import java.util.*;

class Student extends Person {
    List<String> currentCourses;

    public Student(String name) {
        super(name);
        this.currentCourses = new ArrayList<>();
    }

    void showStudyProgram() {
        String courses = String.join(", ", currentCourses);
        IO.println(this.getName() + " studies the following courses: " + courses);
    }

    void enrollInCourse(String course) {
        currentCourses.add(course);
    }
}

import java.util.ArrayList;
import java.util.List;

class Teacher extends Person {
    private List<String> coursesTaught;

    public Teacher(String name) {
        super(name);
        this.coursesTaught = new ArrayList<>();
    }

    void showCoursesTaught() {
        String courses = String.join(", ", coursesTaught);
        IO.println(this.getName() + " teaches courses: " + courses);
    }

    void addCourse(String course) {
        coursesTaught.add(course);
    }
}

void main() {
    Student student = new Student("Olli Opiskelija");
    student.enrollInCourse("Programming 2");
    student.showStudyProgram();

    Teacher teacher = new Teacher("Maija Teacher");
    teacher.addCourse("Programming 1");
    teacher.addCourse("Programming 2");
    teacher.showCoursesTaught();
}

After making these changes, the program compiles successfully again.

We no longer need a no-argument constructor, so we will simply leave it unimplemented.

UML Representation

In UML diagrams, it is common to include not only inheritance relationships but also information about attributes, methods, and their visibility. Attributes are listed below the class name, and methods—including constructors—are listed beneath the attributes. Inherited members are usually omitted from the subclass unless they are overridden—more from this in Part 3.2. Green ball means public visibility and a red square means a private attribute/methods. These diagrams allow us to describe program structure without needing to explain every implementation detail in prose.

A class hierarchy can be more than two levels deep. For example, we might also have a Secretary class that can record completed studies. The Secretary class would inherit directly from Person. We might also distinguish between different types of students: DegreeStudent and OpenUniversityStudent A DegreeStudent could belong to a degree program and an OpenUniversityStudent might not belong to a degree program, but instead would need to pay fees before receiving study credits.

In such a hierarchy: DegreeStudent and OpenUniversityStudent inherits from Student. and since Student inherits from Person, both subclasses also indirectly inherit from Person.

This means that a DegreeStudent object inherits: all non-private members of Student and also all non-private members of Person

The same is true for an OpenUniversityStudent object.

We don't implement this system, but you can find the code in finnish here.

One final note: calling a superclass constructor with super(...) always invokes the constructor of the immediate superclass. You cannot "skip levels" in the hierarchy with something like: super().super(); For example, a constructor in DegreeStudent can directly call only the constructor of Student, not the constructor of Person.

Methods and the super Keyword

The super keyword can also be used when calling a method inherited from a superclass. It allows us to explicitly refer to the superclass version of a method.

class Student extends Person {

    // ...
    public void showCourses() {
        String allCourses = String.join(", ", ongoingCourses);
        // HIGHLIGHT_RED_BEGIN
        IO.println(this.getName() + " is studying: " + allCourses);
        // HIGHLIGHT_RED_END
        // HIGHLIGHT_GREEN_BEGIN
        IO.println(super.getName() + " is studying: " + allCourses);
        // HIGHLIGHT_GREEN_END
    }
}

In this example, using this.getName() or super.getName() produces exactly the same result because the getName() method exists only in the superclass and has not been redefined in the subclass. In the next chapter, 3.2 Polymorphism, we will examine situations where a subclass defines a method with the same name as one in the superclass. In such cases, the super keyword allows us to specifically invoke the superclass implementation.

A Note About the Absence of Multiple Inheritance

In Java, a class can inherit from only one class. Some other programming languages, such as C++, support multiple inheritance, where a class may inherit from more than one superclass. We will not explore multiple inheritance in detail here, but it is worth mentioning that it can introduce certain complications. One famous example is the Diamond Problem, where the same member may be inherited through multiple paths in the inheritance hierarchy.

You may sometimes read that Java's interfaces provide functionality somewhat similar to multiple inheritance. While there are similarities, interfaces are fundamentally a different concept and serve a different purpose. Interfaces will be covered later in the course.

Exercises

Calling inherited methods:
Dulce & Käppänä Winter Jacket: 120.0 €
Reissurähjä Rye Bread: 2.5 €
HighPower Computer: 899.0 €

----------------------------

Calling subclass-specific methods:
Test 1: Trying it on a user who wears size M:
Trying on the clothing item Dulce & Käppänä Winter Jacket...
This may not be the best fit. You wear size M, but this clothing item is size L.

Test 2: Trying it on a user who wears size L:
Trying on the clothing item Dulce & Käppänä Winter Jacket...
Great! Size L fits you perfectly!

Eating Reissurähjä Rye Bread.
The best-before date was 20.12.2024. Hopefully it's still good.

Warranty remaining: 19 months.

pHone: 999.99 €
Phone warranty remaining: 19 months
Operating system: Orange
Connection type: 4G
Calling from Orange (4G) to 0401122330

Pea Bag: 0.99 €
You thawed the frozen food Pea Bag for 10 minutes.
Recommended storage temperature is -18 °C.
Eating Pea Bag.
The best-before date was 31.5.2026. Hopefully it's still good.

Polymorphism

Learning Objectives

After completing this chapter, you will:

• Understand the basic idea of polymorphism.
• Be able to override a superclass method in a subclass and prevent overriding with the final keyword.
• Be able to write a small program that utilizes polymorphism.
• Recognize overridable methods inherited from Object, such as toString().

Polymorphism refers to the ability in object-oriented programming to treat different kinds of objects in a uniform way. When a method is called, the decision about which implementation is actually executed is made at runtime based on the object's real type. Polymorphism makes it possible to write flexible code where new object types can be added without requiring changes to existing code.

Polymorphism is usually divided into two main categories: (1) Compile-time polymorphism, also called static binding and (2). Runtime polymorphism.

In Java, compile-time polymorphism refers to method overloading. This topic was covered in Programming 1, so we will not discuss it in detail here. Briefly, method overloading means that a method may have multiple implementations that differ in the number of parameters, parameter types, or return type. Refer to the Programming 1 material for more information.

This may all sound a bit abstract, so let's look at a concrete example!

Method Overriding and Dynamic Binding

Imagine a program that contains different musical instruments: a Guitar, a Piano, and a DrumSet. We want to be able to play these instruments. One possibility would be to create a separate method for each instrument:

Guitar guitar = new Guitar();
guitar.playGuitar();
Piano piano = new Piano();
piano.playPiano();
DrumSet drumSet = new DrumSet();
drumSet.playDrums();

This approach is not very extensible. If we wanted to process instruments as a group—for example, in a list—we would need awkward and error-prone type checks just to determine which play method should be called. The solution is to find something common to all instruments. After all, both guitars and pianos are instruments. Let's create a superclass called Instrument that contains a behavior every instrument should support: play().

public class Instrument {
    // Every instrument has a play() method.
    public void play() {
        IO.println("An unknown instrument is playing.");
    }
}

Now we can define Guitar and Piano as subclasses of Instrument.

public class Guitar extends Instrument {
    // ...
}

public class Piano extends Instrument {
    // ...
}

We now have a common method name, but if we call play() on either a Guitar or a Piano, they will both execute the superclass implementation: "An unknown instrument is playing." That is not sufficient! We want each instrument to play in its own distinctive way. To achieve this, a subclass can override a superclass method with its own specialized implementation. Overriding is indicated using the @Override annotation. Although the annotation is not required by Java syntax, it is strongly recommended because it helps both the programmer and the IDE recognize that the method is intended to override an inherited method. In the assignments for this course, the @Override annotation is required.

public class Guitar extends Instrument {
    // Override Instrument.play()
    @Override
    public void play() {
        IO.println("The guitar plays and its strings are plucked.");
    }
}

public class Piano extends Instrument {
    // Override Instrument.play()
    @Override
    public void play() {
        IO.println("The piano plays and its keys are pressed.");
    }
}

Inheritance gave us a common type (Instrument). Method overriding gave us object-specific implementations. Together, these two mechanisms enable polymorphism. When we call a method through a superclass reference, the program automatically selects the correct overridden method based on the actual runtime type of the object.

This allows the uniform processing we were looking for:

void main() {
    ArrayList<Instrument> orchestra = new ArrayList<>();
    orchestra.add(new Guitar());
    orchestra.add(new Piano());
    // A DrumSet could be implemented similarly
    // orchestra.add(new DrumSet());

    // Call the same play() method for all instruments...
    for (Instrument instrument : orchestra) {
        instrument.play();
    }
}

public class Instrument {
    // Every instrument has a play() method.
    public void play() {
        IO.println("An unknown instrument is playing.");
    }
}

public class Guitar extends Instrument {
    // Override Instrument.play()
    @Override
    public void play() {
        IO.println("The guitar plays and its strings are plucked.");
    }
}

public class Piano extends Instrument {
    // Override Instrument.play()
    @Override
    public void play() {
        IO.println("The piano plays and its keys are pressed.");
    }
}

The is-a Relationship

An inheritance relationship is often described using the English term is-a relationship.

We can say that: A Piano is an Instrument and A Guitar is an Instrument. Importantly, the relationship works in this direction.

Let's briefly return to our student information system example. There too we can say: A Student is a Person and a Teacher is a Person and a Secretary is a Person. Likewise, a DegreeStudent is a Person, because it inherits from Student, which in turn inherits from Person.

As we learned above, polymorphism allows us to treat Student, Teacher, and Secretary objects as Person objects in our code.

We can therefore place all these objects into a Person array:

Student student = new Student();
Teacher teacher = new Teacher();
Secretary secretary = new Secretary();

Person[] people = {student, teacher, secretary };

To make the example a bit more meaningful, let's add methods login() and logout() to the Person class. All subclasses of Person automatically inherit these methods.

class Person {
    // HIGHLIGHT_GREEN_BEGIN
    private boolean loggedIn;
    // HIGHLIGHT_GREEN_END

    public Person(String name) {
        // ...

        // HIGHLIGHT_GREEN_BEGIN
        this.loggedIn = false;
        // HIGHLIGHT_GREEN_END

        // ...
    }

    // HIGHLIGHT_GREEN_BEGIN
    void login() {
        this.loggedIn = true;
        IO.println(this.getName() + " logged in.");
    }

    void logout() {
        this.loggedIn = false;
        IO.println(this.getName() + " logged out.");
    }
    // HIGHLIGHT_GREEN_END
}

We can now call logout() for every object in the people array without knowing their exact types:

for (Person person : people) {
    person.logout();
}

Notice the direction of the is-a relationship: A Teacher is not a Secretary, even though both inherit from Person.

Let's add a boolean attribute studyRightValid to our Student example that indicates whether the student has a valid right to study. If the study right is not valid, the student should not be allowed to log into the system. Override the login() method in the Student class so that it checks this condition before logging in.

class Student extends Person {
    // ...

    boolean studyRightValid;

    @Override
    void login() {
        if (studyRightValid) {
            super.login(); // Call the superclass login() method
        } else {
            IO.println("Your study right is not valid. " + "You cannot log in.");
        }
    }
}

In other subclasses of Person, such as Teacher and Secretary, the login() method continues to work exactly as before because it has not been overridden.

There are a couple of important rules related to method overriding:

• Overriding always applies to the closest superclass method in the hierarchy.
• When a method is called on a subclass object, the call is always resolved to the closest overridden version in the inheritance hierarchy.

The following example demonstrates method overriding and how method calls are resolved in a class hierarchy.

public class TestOverriding {
    public static void main(String args[]) {
        C c = new C();
        c.hello();     // Calls A.hello()
        c.hi();        // Calls B.hi()
        c.whew();      // Calls C.whew()
    }
}

class A {
    public void hello() { IO.println("Object A says hello."); }
    public void hi() { IO.println("Object A says hi."); }
    public void whew() { IO.println("Object A says whew!!"); }
}

class B extends A {
    @Override
    public void hi() { IO.println("Object B shouts hi!"); }
    @Override
    public void whew() { IO.println("Object B shouts whew!!"); }
}

class C extends B {
    @Override
    public void whew() { IO.println("Object C goes whew...."); }
}

The UML diagram for this example would look as follows:

Example: The Shape Class

Let's look at another example. Consider a class called Shape that contains a method calculateArea().

public class Shape {
    public double calculateArea() {
        return 0.0;
    }
}

The implementation of calculateArea() looks a bit strange. The reason is that there is no such thing as a truly generic shape. A Shape should always represent some concrete type of shape, such as a rectangle or a circle, each of which has its own way of calculating area. As we mentioned in the instrument example, we will return to this issue in Chapter 3.3, Abstract Classes.

For now, let's create the subclasses Rectangle and Circle. Since these shapes calculate their areas differently, each class should provide its own implementation of calculateArea().

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

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

    @Override
    public double calculateArea() {
        return width * height;
    }
}

public class Circle extends Shape {
    private double radius;

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

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

We can now write code that works with Shape objects without needing to know whether they are rectangles or circles.

public class Main {
    public static void main() {

        Shape shape1 = new Circle(5);
        Shape shape2 = new Rectangle(5, 7);

        IO.println(shape1.calculateArea());
        IO.println(shape2.calculateArea());
    }
}

public class Shape {
    public double calculateArea() {
        return 0.0;
    }
}

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

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

    @Override
    public double calculateArea() {
        return width * height;
    }
}

public class Circle extends Shape {

    private double radius;

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

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

Why Do We Need Polymorphism?

Polymorphism enables flexible and extensible program design in many ways. In object-oriented programming, polymorphism is particularly useful because it provides a unified way to work with objects that may be very different from one another.

When several classes inherit from the same superclass (or implement the same interface, which we will discuss later in Chapter 4.1 Interface), they can all be treated through a single common type. This allows a program to work with collections of diverse objects such as:

• all instruments (Instrument), including guitars, pianos, and drums,
• all vehicles (Vehicle), including cars, bicycles, and airplanes,
• all animals (Animal), including dogs, cats, and birds,
• all graphical user interface components (Drawable), including buttons, text fields, and images,
• all payment methods (PaymentMethod), including credit cards, PayPal, and cash.

Java provides another way to distinguish object types through the instanceof operator. For example:

if (instrument instanceof Guitar) {
    ((Guitar) instrument).playGuitar();
}
else if (instrument instanceof Piano) {
    ((Piano) instrument).playPiano();
}

In this course, we generally avoid using instanceof unless specifically instructed otherwise. The reason is that frequent use of instanceof often indicates that inheritance and polymorphism are not being used effectively. It tends to lead to complicated chains of conditional statements like the example above and undermines one of the key benefits of object-oriented programming: hiding implementation details behind a common interface.

instanceof can still be appropriate in certain situations, such as:

• when we do not control the class hierarchy,
• when code operates at a system boundary, such as parsing external data, integrating with another system, or using reflection,
• when the alternative would be significantly more complex or require excessive code duplication.

interface Message { }

// Concrete message types (from an external library)
class TextMessage implements Message {
    String text;
}

class ImageMessage implements Message {
    byte[] data;
}

void process(Message message) {
    if (message instanceof TextMessage textMessage) {
        IO.println("Text: " + textMessage.text);
    } else if (message instanceof ImageMessage imageMessage) {
        IO.println( "Image size: " + imageMessage.data.length);
    } else {
        throw new IllegalArgumentException("Unknown message type");
    }
}

Overriding Methods from the Object Class

In Java, all classes share a common superclass called Object. This means that every class automatically inherits the attributes and methods of the Object class unless specified otherwise. The Object class contains several useful methods that can be overridden in subclasses.

One example is the toString() method, which provides a string representation of an object. By default, the method returns the object's class name and hash code, which is often not very informative. We can override this method in our own classes so that it returns a representation that is more meaningful for our needs.

Let's create a Vector3D class representing a three-dimensional vector. In the main program, we create a few Vector3D objects and print their values.

public class Main {
    public static void main(String[] args) {
        Vector3D v1 = new Vector3D(1.0, 2.0, 3.0);
        Vector3D v2 = new Vector3D(4.0, 5.0, 6.0);

        IO.println("Vector 1: (" + v1.getX() + ", " + v1.getY() + ", " + v1.getZ() + ")");
        IO.println("Vector 2: (" + v2.getX() + ", " + v2.getY() + ", " + v2.getZ() + ")");
    }
}

class Vector3D {
    private double x;
    private double y;
    private double z;

    public Vector3D(double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getZ() {
        return z;
    }
}

Although the printing works, it would be much more convenient if we could simply write IO.println("Vector 1: " + v1); without explicitly retrieving coordinates and concatenating strings. To accomplish this, we can override the toString() method in Vector3D.

public class Main {
    public static void main(String[] args) {
        Vector3D v1 = new Vector3D(1.0, 2.0, 3.0);
        Vector3D v2 = new Vector3D(4.0, 5.0, 6.0);

        IO.println("Vector 1: " + v1);
        IO.println("Vector 2: " + v2);
    }
}

class Vector3D {
    private double x;
    private double y;
    private double z;

    public Vector3D(double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getZ() {
        return z;
    }
    // HIGHLIGHT_GREEN_BEGIN
    @Override
    public String toString() {
        return "(" + x + ", " + y + ", " + z + ")";
    }
    // HIGHLIGHT_GREEN_END
}

The main program now looks considerably cleaner.

You are encouraged to explore other methods inherited from Object in the Java documentation.

Preventing Inheritance or Overriding (final Keyword)

Inheritance of a class or overriding of a method can be prevented using the final keyword. When a class is declared with the final keyword, it cannot be inherited. Similarly, when a method is declared with the final keyword, it cannot be overridden in a subclass.

Somewhat confusingly, the final keyword can also be used with variables. In that context, it means that the value of the variable cannot be changed after initialization. However, that usage is unrelated to inheritance.

Exercises

HighPower Computer: 899.0 €
Original device warranty: 24 months

Aifoun42: 888.0 €
Original device warranty: 37 months
Operating system: AiOS
Connection type: 5G

----------------------------

--- NEW STORE PRODUCT ---
Light Bulb: 67000.0 €
Original device warranty: 73 months
Battery health: 100.00%
Range: 404.00 km

--- ACTIVATION AND CHARGING ---

Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...

--- STATUS AFTER CHARGING ---

Light Bulb: 67000.0 €
Original device warranty: 73 months
Battery health: 99.50%
Range: 401.98 km

Abstract Classes

Learning Objectives

After completing this chapter, you will:

• Be able to create abstract classes and abstract methods in Java.
• Understand the concepts of abstract classes and abstract methods, as well as their benefits in object-oriented programming.

When designing superclass–subclass relationships, we may encounter situations where it is useful to create a superclass that defines shared functionality, but where creating instances of the superclass itself does not make sense.

Consider the concept of a chair. While the word chair probably brings a specific image to mind, there are actually many different kinds of chairs: wooden chairs, rocking chairs, office chairs, and so on. Each type of chair is somewhat different. One could argue that the concept of a chair is itself an abstraction. A chair is essentially just something that enables sitting. To describe an actual physical chair that could be manufactured, we need a more specific concept, such as an office chair.

Let's look at another example that is closer to actual code. We'll continue the Shape example from the previous chapter. In principle, we could create an instance of Shape and call its calculateArea() method.

Shape shape = new Shape();
double area = shape.calculateArea();
IO.println("The area of the shape is " + area); // 0.0

However, this doesn't really make sense. A Shape object does not represent any concrete shape. It is merely a general concept from which concrete shapes such as Circle and Rectangle inherit. This becomes especially obvious when we try to print the area of such a generic shape. The Shape class is therefore intended only to be inherited from, and creating direct instances of it is not meaningful. Let's make Shape an abstract class and calculateArea() an abstract method.

public abstract class Shape {
    public abstract double calculateArea();
}

After this change, instances of Shape can no longer be created.

Shape shape = new Shape();

java: Shape is abstract; cannot be instantiated

An abstract class is a class that allows us to express this idea directly in code. An abstract class cannot be instantiated directly. Instead, it serves only as a foundation for classes that inherit from it. An abstract class may contain: abstract methods (methods without an implementation) and also concrete methods (methods with an implementation). A subclass must implement all abstract methods unless the subclass itself is also abstract.

Example: Smart Home

A smart home might contain many different kinds of devices, such as lights, security cameras, and of course a smart coffee maker. Let's assume that every device has an operation called toggleState(), which performs the device's primary action( for example a light turns on or off, a security camera starts or stops recording, a coffee maker starts or stops brewing coffee.) Each device should also be able to report its current state through a method called reportState().

We'll begin with a simple example where a device can only switch between two states. More advanced controls will be considered later.

Our class diagram might look like this:

public class Main {
    public static void main() {
        Device[] devices = {
            new Light(),
            new SecurityCamera(),
            new CoffeeMaker()
        };

        for (Device device : devices) {
            device.toggleState();
            device.reportState();
        }
    }
}

public class Device {

    public void toggleState() {
    }

    public void reportState() {
    }
}

public class Light extends Device {

    private int brightness = 0;

    @Override
    public void toggleState() {
        switch (brightness) {
            case 0 -> brightness = 50;
            case 50 -> brightness = 100;
            case 100 -> brightness = 0;
        }
    }

    @Override
    public void reportState() {
        IO.println("The light brightness is " + brightness + "%.");
    }
}

public class SecurityCamera extends Device {
    private boolean recordingEnabled = false;

    @Override
    public void toggleState() {
        // Enable or disable recording
        recordingEnabled = !recordingEnabled;
    }

    @Override
    public void reportState() {
        String state = recordingEnabled ? "on" : "off";

        IO.println("Security camera recording is " + state + ".");
    }
}

public class CoffeeMaker extends Device {
    private boolean brewing = false;

    @Override
    public void toggleState() {
        // Start brewing or turn off
        brewing = !brewing;
    }

    @Override
    public void reportState() {
        String state = brewing ? "on" : "off";

        IO.println("The coffee maker is " + state + ".");
    }
}

If we examine the Device class, we notice that its methods toggleState() and reportState() do nothing. In theory, we could also create instances of Device directly and call its methods:

Device device = new Device();

device.toggleState();  // Does nothing
device.reportState();  // Does nothing

As we can see, nothing happens when these methods are called, making Device objects largely useless. It doesn't really make sense to have some generic "device" without knowing what type of device it is. Therefore, the Device class is really intended only for inheritance.

Let's make Device an abstract class. Since its methods are also intended to be implemented by subclasses, we will make those methods abstract as well. All subclasses must implement these methods, as they already do in our example.

public class Main {

    public static void main() {
        Device[] devices = {
            new Light(),
            new SecurityCamera(),
            new CoffeeMaker()
        };

        for (Device device : devices) {
            device.toggleState();
            device.reportState();
        }
    }
}

public abstract class Device {
    public abstract void toggleState();
    public abstract void reportState();
}

public class Light extends Device {
    private int brightness = 0;

    @Override
    public void toggleState() {
        // Change brightness:
        // 0 -> 50 -> 100 -> 0 ...
        switch (brightness) {
            case 0 -> brightness = 50;
            case 50 -> brightness = 100;
            case 100 -> brightness = 0;
        }
    }

    @Override
    public void reportState() {
        IO.println("The light brightness is " + brightness + "%.");
    }
}

public class SecurityCamera extends Device {

    private boolean recordingEnabled = false;

    @Override
    public void toggleState() {
        // Enable or disable recording
        recordingEnabled = !recordingEnabled;
    }

    @Override
    public void reportState() {
        String state = recordingEnabled ? "on" : "off";

        IO.println("Security camera recording is " + state + ".");
    }
}

public class CoffeeMaker extends Device {
    private boolean brewing = false;

    @Override
    public void toggleState() {
        // Start brewing coffee or turn off
        brewing = !brewing;
    }

    @Override
    public void reportState() {
        String state = brewing ? "on" : "off";

        IO.println("The coffee maker is " + state + ".");
    }
}

Just as in the earlier Shape example, instances of Device can no longer be created.

Device device = new Device();

java: Device is abstract; cannot be instantiated

The class diagram looks almost the same as before, but now Device is marked as an abstract class, and its methods are marked as abstract methods. In UML notation, abstract classes and abstract methods are written in italics.

The opposite of an abstract class is often called a concrete class, meaning a class that can be instantiated. For example, Light, SecurityCamera, and CoffeeMaker are concrete classes because objects can be created from them.

Why Are Abstract Classes Useful?

An abstract class is not merely a way to prevent instantiation.

Its primary purposes are:

• to define a common contract that all subclasses must follow, and
• to provide shared attributes and implementations so that subclasses can focus only on their unique behavior.

Because Device is abstract, we can add attributes and method implementations that all subclasses share.

Let's add the attribute name, representing the device's name, and the attribute poweredOn, indicating whether the device is currently powered on. These attributes are useful for all devices and therefore belong naturally in the abstract superclass.

public abstract class Device {

    // HIGHLIGHT_GREEN_BEGIN
    private String name;
    private boolean poweredOn;
    // HIGHLIGHT_GREEN_END

    public abstract void toggleState();
    public abstract void reportState();
}

If we were modeling network devices, useful or even mandatory attributes might include a MAC address and an IP address. To keep the example simple, however, we will limit ourselves to the device name and power state.

Let's also add the methods powerOn() and powerOff(), which provide common startup and shutdown logic that all devices can follow.

public abstract class Device {
    private String name;
    private boolean poweredOn;

    // HIGHLIGHT_GREEN_BEGIN
    protected Device(String name) {
        this.name = name;
        this.poweredOn = false; // default
    }

    public void powerOn() {
        if (!poweredOn) {
            poweredOn = true;
            IO.println(name + " is powering on.");
        }
    }

    public void powerOff() {
        if (poweredOn) {
            poweredOn = false;
            IO.println(name + " is powering off.");
        }
    }
    // HIGHLIGHT_GREEN_END

    public abstract void toggleState();
    public abstract void reportState();
}

Notice that because we decided every device must have a name, the name must now be supplied as a constructor parameter. As a result, we can no longer create instances using a parameterless constructor.

Light light = new Light();

Light.java
java: constructor Device in class Device cannot be applied to given types;
  required: java.lang.String
  found: no arguments
  reason: actual and formal argument lists differ in length

Creating an object now requires a name, for example: new Light("PhilipsHue"); Therefore, each subclass constructor must call the superclass constructor. Let's make this change in all subclasses.

public class Main {

    public static void main() {
        Device[] devices = {
            new Light("PhilipsHue"),
            new CoffeeMaker("Moccamaster"),
            new SecurityCamera("Reolink")
        };

        for (Device device : devices) {
            device.powerOn();
            device.toggleState();
            device.reportState();
            device.powerOff();
        }
    }
}

public abstract class Device {
    private String name;
    private boolean poweredOn;

    protected Device(String name) {
        this.name = name;
    }

    public void powerOn() {
        if (!poweredOn) {
            poweredOn = true;
            IO.println(name + " is powering on.");
        }
    }

    public void powerOff() {
        if (poweredOn) {
            poweredOn = false;
            IO.println(name + " is powering off.");
        }
    }

    public abstract void toggleState();
    public abstract void reportState();
}

public class Light extends Device {
    private int brightness = 0;

    public Light(String name) {
        super(name);
    }

    @Override
    public void toggleState() {
        // Change brightness: 0 -> 50 -> 100 -> 0 ...
        switch (brightness) {
            case 0 -> brightness = 50;
            case 50 -> brightness = 100;
            case 100 -> brightness = 0;
        }
    }

    @Override
    public void reportState() {
        IO.println("The light brightness is " + brightness + "%.");
    }
}

public class SecurityCamera extends Device {
    private boolean recordingEnabled = false;

    public SecurityCamera(String name) {
        super(name);
    }

    @Override
    public void toggleState() {
        // Enable or disable recording
        recordingEnabled = !recordingEnabled;
    }

    @Override
    public void reportState() {
        String state = recordingEnabled ? "on" : "off";
        IO.println("Security camera recording is " + state + ".");
    }
}

public class CoffeeMaker extends Device {
    private boolean brewing = false;

    public CoffeeMaker(String name) {
        super(name);
    }

    @Override
    public void toggleState() {
        // Start brewing coffee or turn off
        brewing = !brewing;
    }

    @Override
    public void reportState() {
        String state = brewing ? "on" : "off";
        IO.println("The coffee maker is " + state + ".");
    }
}

Subclasses now inherit the power-on and power-off logic directly, but they are required to implement the device-specific functionality themselves. This creates a balance between flexibility and enforced structure: changing state and reporting state are mandatory, the implementation of those operations is up to each individual device, startup and shutdown behavior is shared by all devices.

Visibility of Methods in Abstract Classes

Abstract methods follow the same visibility rules as other methods. Abstract methods are usually declared either public or protected so that subclasses can implement them. If a method will be called by code that uses objects of the class, the method should be public. If the method is intended for use only within subclasses, protected is sufficient. It is important to note that a subclass implementation cannot reduce visibility. For example, a public abstract method cannot be implemented as a protected method in a subclass.

Concrete methods may also be declared private. In that case they serve as internal helper methods and are not visible to subclasses.

An abstract method cannot be declared private.

Template Method Pattern

An abstract class may also contain a concrete method whose implementation calls an abstract method. This design is known as the Template Method pattern. The abstract class defines the overall algorithm or workflow, while delegating specific steps to subclasses.

The previously implemented parts have been hidden from the code. You can reveal them by clicking the eye icon in the upper-right corner of the code area.

public abstract class Device {
    private String name;
    private boolean poweredOn;

    protected Device(String name) {
        this.name = name;
    }

    public final void performUpdate() {
        powerOn();
        prepareUpdate(); // Abstract step implemented by subclasses
        update();
        powerOff();
    }

    protected abstract void prepareUpdate();

    private void update() {
        IO.println("Downloading the latest update from the network...");
        IO.println("Updating device...");
    }

    public void powerOn() {
        if (!poweredOn) {
            poweredOn = true;
            IO.println(name + " is powering on.");
        }
    }

    public void powerOff() {
        if (poweredOn) {
            poweredOn = false;
            IO.println(name + " is powering off.");
        }
    }

    public abstract void toggleState();
    public abstract void reportState();
}

public class Light extends Device {

    private int brightness = 0;

    public Light(String name)
    {
        super(name);
    }


    @Override
    protected void prepareUpdate() {
        IO.println("Preparing light for update...");
        IO.println("Setting brightness to 0%...");
    }

    @Override
    public void toggleState() {
        // Change brightness 0 -> 50 -> 100 -> 0 ...
        switch (brightness) {
            case 0 -> brightness = 50;
            case 50 -> brightness = 100;
            case 100 -> brightness = 0;
        }
    }

    @Override
    public void reportState() {
        IO.println("The light brightness is " + brightness + "%.");
    }
}

public class CoffeeMaker extends Device {
    private boolean brewing = false;

    public CoffeeMaker(String name)
    {
        super(name);
    }

    @Override
    protected void prepareUpdate() {
        IO.println("Preparing coffee maker for update...");
        IO.println("Interrupt brewing...");
    }

    @Override
    public void toggleState() {
        // Brew coffee or switch off
        brewing = !brewing;
    }

    @Override
    public void reportState() {
        String state = brewing ? "on" : "off";
        IO.println("The coffee maker is " + state + ".");
    }
}

public class Main {

    public static void main() {
        Light hue = new Light("PhilipsHue");
        CoffeeMaker mocca = new CoffeeMaker("MoccaMaster");

        hue.performUpdate();
        // Try also:
        // mocca.performUpdate();
    }
}

performUpdate() now acts as a predefined recipe that subclasses cannot modify because it is declared final. The subclasses instead customize the recipe by implementing the abstract methods required by the process.

🤔 Something to think about: In what situations would you want to prevent a subclass from overriding a particular method?

Exercises

All Exercises in This Part

Calling inherited methods:
Dulce & Käppänä Winter Jacket: 120.0 €
Reissurähjä Rye Bread: 2.5 €
HighPower Computer: 899.0 €

----------------------------

Calling subclass-specific methods:
Test 1: Trying it on a user who wears size M:
Trying on the clothing item Dulce & Käppänä Winter Jacket...
This may not be the best fit. You wear size M, but this clothing item is size L.

Test 2: Trying it on a user who wears size L:
Trying on the clothing item Dulce & Käppänä Winter Jacket...
Great! Size L fits you perfectly!

Eating Reissurähjä Rye Bread.
The best-before date was 20.12.2024. Hopefully it's still good.

Warranty remaining: 19 months.

pHone: 999.99 €
Phone warranty remaining: 19 months
Operating system: Orange
Connection type: 4G
Calling from Orange (4G) to 0401122330

Pea Bag: 0.99 €
You thawed the frozen food Pea Bag for 10 minutes.
Recommended storage temperature is -18 °C.
Eating Pea Bag.
The best-before date was 31.5.2026. Hopefully it's still good.

HighPower Computer: 899.0 €
Original device warranty: 24 months

Aifoun42: 888.0 €
Original device warranty: 37 months
Operating system: AiOS
Connection type: 5G

----------------------------

--- NEW STORE PRODUCT ---
Light Bulb: 67000.0 €
Original device warranty: 73 months
Battery health: 100.00%
Range: 404.00 km

--- ACTIVATION AND CHARGING ---

Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...
Charging vehicle Light Bulb...

--- STATUS AFTER CHARGING ---

Light Bulb: 67000.0 €
Original device warranty: 73 months
Battery health: 99.50%
Range: 401.98 km

Basics of Interfaces and Generic Types

Learning objectives

• You can use interfaces to define a contract that specifies the behavior of a class.
• You can implement the Comparable interface, which enables objects to be ordered and sorted.
• You understand the concepts of generic classes and type parameters.
• You can implement reusable classes and methods using generic types.

Interfaces

Learning Objectives

After completing this chapter, you will:

• Understand what an interface means in object-oriented programming.
• Be able to define and use interfaces in Java.
• Be able to use an interface as a method parameter and as a variable type.
• Understand when to use an interface instead of inheritance.
• Understand that a class can implement multiple interfaces but inherit only one class.

An interface acts as a binding contract: it defines which methods a class must provide without specifying how those methods are technically implemented. Unlike an abstract class, which provides a foundation for attributes and methods, an interface focuses on describing an object's capabilities. Interfaces make it possible to define common capabilities even when classes are completely different or belong to different inheritance hierarchies. When a programmer works with an object through its interface, they can rely on the object providing the agreed functionality regardless of the object's actual class.

Smart Home: Adjustable Devices

Let's continue the smart home example that we started in Part 3. Some devices in our smart home could be adjustable, meaning that a value such as brightness, temperature, or volume can be set directly. This is essentially what our Light class already does, where brightness changes between a few predefined values. From the perspective of the object's user, however, it would be more convenient if the brightness could be set directly to a desired value (for example, 33%) instead of repeatedly calling toggleState() and hoping to reach the correct setting. For an end user, this would be similar to setting the desired brightness directly in a mobile application instead of repeatedly clicking Increase Brightness or Decrease Brightness buttons.

Let's define an interface called Adjustable, containing the method setValue(int value). The file is saved as Adjustable.java, just like a class definition.

/**
 * A device that can be adjusted directly to a desired value.
 */
public interface Adjustable {
    void setValue(int value);
}

This can be read as follows:

Every class implementing the Adjustable interface must provide a setValue() method.

We can now modify the Light class to implement the Adjustable interface. For simplicity, we will leave CoffeeMaker and SecurityCamera out of this example because we decide that they are not adjustable devices.

public class Main {
    public static void main() {
        Light light = new Light("PhilipsHue");
        light.setValue(33);
        light.reportState();

        light.toggleState();
        light.reportState();
    }
}

public interface Adjustable {
    void setValue(int value);
}

public class Light extends Device implements Adjustable {
    private int brightness = 0;

    protected Light(String name) {
        super(name);
    }

    @Override
    public void setValue(int value) {
        this.brightness = Math.clamp(value, 0, 100);
    }

    @Override
    public void toggleState() {
        // Simple on/off behavior
        if (brightness == 100) {
            brightness = 0;
        }
        else {
            brightness = 100;
        }
    }

    @Override
    public void reportState() {
        IO.println("The light brightness is " + brightness + "%.");
    }
}

public abstract class Device {
    private final String name;
    private boolean poweredOn;

    protected Device(String name) {
        this.name = name;
    }

    public void powerOn() {
        if (!poweredOn) {
            poweredOn = true;
            IO.println(name + " is powering on.");
        }
    }

    public void powerOff() {
        if (poweredOn) {
            poweredOn = false;
            IO.println(name + " is powering off.");
        }
    }

    public abstract void toggleState();
    public abstract void reportState();
}

Our class diagram would now look like this. The letter I indicates an interface. Like abstract classes, interfaces are displayed in italics. Implementing an interface is represented with a dashed line ending in a hollow arrow pointing toward the interface.

Implementing Multiple Interfaces

A class can implement multiple interfaces. For example, Java's built-in ArrayList class implements several interfaces: List, RandomAccess, Cloneable and Serializable (see ArrayList class documentation).

Each interface describes a particular capability:

• List defines basic list operations such as adding, removing, and retrieving elements.
• RandomAccess indicates that elements should be accessed efficiently by index.
• Cloneable allows an object to be cloned.
• Serializable allows an object to be stored in a file or transmitted over a network.

Similarly, Java's Date class also implements the Cloneable interface, allowing date objects to be cloned. Notice that Date and ArrayList are otherwise unrelated classes, yet they both implement the same interface.

Let's create two interfaces of our own and classes that implement them.

Suppose we have user-interface components that can: be drawn on the screen, and be clicked with a mouse.

We define two interfaces: Drawable and Clickable. These interfaces describe the capabilities of user-interface components. Let's agree on the following: a drawable component can draw itself and a clickable component can process click events and highlight itself when the mouse cursor is over it.

/**
 * A component that can be drawn in the user interface.
 */
public interface Drawable {
    public void draw();
}

/**
 * A user interface component that can be clicked.
 */
public interface Clickable {
    public void clicked();

    public void setHighlight(boolean highlight);
}

Notice that we neither know nor care how these methods are implemented.

Rendering could happen in a graphical user interface, in a text-based interface, or even by writing output to a file. All we need to know is that every class implementing Drawable provides a draw() method, and every class implementing Clickable provides clicked() and setHighlight() methods.

Let's continue by implementing Text, a user-interface component that displays only text.

/**
 * A drawable component displaying only text.
 */
public class Text implements Drawable {
    private String content;
    public Text(String content) {
        this.content = content;
    }

    @Override
    public void draw() {
        // Draw only the text content without a border
        IO.println(content);
    }
}

The benefits of interfaces are not yet fully apparent, partly because draw() is currently the only method provided by the Drawable interface. Now, however, we can create another component: a Button, which is a box-shaped clickable button containing text. The Button class implements both interfaces: Drawable and Clickable.

/**
 * A box-shaped clickable button
 * containing text.
 */
public class Button implements Drawable, Clickable {
    private String content;
    private boolean highlighted;

    public Button(String content) {
        this.content = content;
        this.highlighted = false;
    }

    @Override
    public void draw() {
        // Draw a rectangle and text
        if (!highlighted) {
            IO.println("[ " + content + " ]");
        } else {
            IO.println("[*" + content + "*]");
        }
    }

    /**
     * Handle a click event.
     */
    @Override
    public void clicked() {
        IO.println( "(The button labeled \"" + content + "\" was clicked)");
    }

    /**
     * Set the highlight state.
     * If the state changes,
     * redraw the component.
     */
    @Override
    public void setHighlight(boolean highlight) {
        if (this.highlighted == highlight) {
            return;
        }

        this.highlighted = highlight;
        this.draw();
    }
}

We now have two different user-interface components that can both be drawn on the screen. In addition, the Button component is clickable. Let's use these components in a main program.

/**
 * A component that can be drawn
 * in the user interface.
 */
public interface Drawable {
    public void draw();
}

/**
 * A user interface component
 * that can be clicked.
 */
public interface Clickable {
    public void clicked();
    public void setHighlight(boolean highlight);
}

/**
 * A component displaying only text.
 */
public class Text implements Drawable {
    private String content;

    public Text(String content) {
        this.content = content;
    }

    @Override
    public void draw() {
        // Draw only the text content
        // without borders
        IO.println(content);
    }
}

/**
 * A box-shaped clickable button
 * containing text.
 */
public class Button implements Drawable, Clickable {

    private String content;
    private boolean highlighted;

    public Button(String content)
    {
        this.content = content;
        this.highlighted = false;
    }

    @Override
    public void draw() {
        // Draw a rectangle and text
        if (!highlighted) {
            IO.println("[ " + content + " ]");
        } else {
            IO.println("[*" + content + "*]");
        }
    }

    /**
     * Handle a click event.
     */
    @Override
    public void clicked() {
        IO.println("(The button labeled \"" + content + "\" was clicked)");
    }

    /**
     * Set the highlight state.
     */
    @Override
    public void setHighlight(boolean highlight) {
        this.highlighted = highlight;
    }
}

public class Main {
    public static void main(String[] args) {
        Text heading = new Text("Would you like to start studying interfaces?");
        heading.draw();

        Button okButton = new Button("OK!");
        okButton.draw();

        // Simulate moving the mouse
        // over the button
        // Redraw the button after highlighting
        okButton.setHighlight(true);
        okButton.draw();

        // Simulate a click
        okButton.clicked();
    }
}

/**
 * The Screen class manages drawable components.
 */
public class Screen {
    private ArrayList<Drawable> components = new ArrayList<>();

    public void addComponent(Drawable component) {
        components.add(component);
    }

    public void removeComponent(Drawable component) {
        components.remove(component);
    }
}

/**
 * Responsible for rendering the drawing surface.
 */
public class Renderer {
    public void drawButton(String text, boolean highlighted) {
        if (!highlighted) {
            IO.println("[ " + text + " ]");
        } else {
            IO.println("[*" + text + "*]");
        }
    }

    public void drawText(String text) {
        IO.println(text);
    }

    public void clear() {
        IO.println("Clearing drawing area");
        // Left unimplemented
    }
}

import java.util.ArrayList;

/**
 * The Screen class manages drawable components.
 */
public class Screen {
    private ArrayList<Drawable> components = new ArrayList<>();
    // HIGHLIGHT_GREEN_BEGIN
    private Renderer renderer = new Renderer();
    // HIGHLIGHT_GREEN_END

    public void addComponent(Drawable component) {
        components.add(component);
    }

    public void removeComponent(Drawable component) {
        components.remove(component);
    }

    // HIGHLIGHT_GREEN_BEGIN
    public void update() {
        renderer.clear();
        for (Drawable component : components) {
            component.draw(renderer);
        }
    }
    // HIGHLIGHT_GREEN_END
}

public interface Drawable {

    // HIGHLIGHT_GREEN_BEGIN
    public void draw(Renderer renderer);
    // HIGHLIGHT_GREEN_END
}

/**
 * A drawable component
 * displaying only text.
 */
public class Text implements Drawable {
    private String content;

    public Text(String content) {
        this.content = content;
    }

    /**
     * Draw the component.
     *
     * @param renderer Renderer
     */
    @Override
    // HIGHLIGHT_GREEN_BEGIN
    public void draw(Renderer renderer) {
        renderer.drawText(content);
    }
    // HIGHLIGHT_GREEN_END
}

Interface Inheritance

An interface can also extend (inherit from) another interface. Syntactically, this is done using the extends keyword, just as with classes. Unlike classes, however, an interface may inherit from multiple interfaces. A subinterface automatically inherits all methods declared in its parent interfaces. The following synthetic example demonstrates this.

public interface A {
    void methodA();
}

public interface B {
    void methodB();
}

public interface C extends A, B {
    void methodC();
}

public class D implements C {
    @Override
    public void methodA() {
        IO.println("Implementation of method A");
    }

    @Override
    public void methodB() {
        IO.println("Implementation of method B");
    }

    @Override
    public void methodC() {
        IO.println("Implementation of method C");
    }
}

public class Main {
    public static void main(String[] args) {
        D objectD = new D();
        objectD.methodA();
        objectD.methodB();
        objectD.methodC();
    }
}

Notes

Exercises

String encrypt(String message);
String decrypt(String encryptedMessage);

'a' -> '@'
'e' -> '3'
'i' -> '!'
'o' -> '0'

'a' -> 'b'
'b' -> 'c'
'k' -> 'l'

The Comparable Interface and Natural Ordering

The Comparable interface defines the method compareTo(), which allows objects of a class to define a natural ordering relative to other objects of the same type.

The interface contains a single method, compareTo(), which returns an integer indicating the ordering relationship between two objects. The return value is interpreted as follows:

For example, the Integer type implements the Comparable interface for integer objects. Therefore, two integer objects can be compared using the compareTo() method.

void main() {
    Integer number1 = 5;
    Integer number2 = 18;

    int result = number1.compareTo(number2);

    // Prints a negative value (< 0), because 5 < 18
    IO.println( "number1.compareTo(number2): " + result);
}

Strings already have a natural ordering defined as alphabetical order.

// Helper function that prints the ordering between two strings.
void describeOrder(String word1, String word2) {
    int result = word1.compareTo(word2);
    if (result < 0) {
        IO.println( "The string '" + word1 + "' comes before the string '" + word2 + "'");
    } else if (result > 0) {
        IO.println("The string '" + word1 + "' comes after the string '" + word2 + "'");
    }
    else {
        IO.println("'" + word1 + "' is equal to '" + word2 + "'");
    }
}

void main() {
    String word1 = "apple";
    String word2 = "orange";
    String word3 = "banana";

    describeOrder(word1, word2);
    describeOrder(word1, word3);
    describeOrder(word2, word3);
}

Similarly, the natural ordering for Integer values is ascending numerical order.

int describeOrder(Integer number1, Integer number2) {
    int result = number1.compareTo(number2);
    if (result < 0) {
        IO.println( number1 + " is smaller than " + number2);
    } else if (result > 0) {
        IO.println(number1 + " is greater than " + number2);
    } else {
        IO.println(number1 + " is equal to " + number2);
    }

    return result;
}


void main() {
    Integer number1 = 5;
    Integer number2 = 18;
    Integer number3 = 5;
    describeOrder(number1, number2);
    describeOrder(number1, number3);
    describeOrder(number2, number3);
}

One of the major benefits of the Comparable interface is that it allows us to write programs and use algorithms that require comparisons in a completely general way for any objects that implement Comparable. Classes implementing this interface can also be sorted using Java's built-in collection sorting implementations, such as the Collections.sort method. As a result, we do not need to implement sorting algorithms ourselves.

void main() {
    List<Integer> numbers = Arrays.asList(18, 5, 42);
    List<String> fruits = Arrays.asList("apple", "pear", "orange");
    IO.println(numbers); // [18, 5, 42]
    IO.println(fruits);  // [apple, pear, orange]

    // Sort lists according to the natural order of their elements.

    Collections.sort(fruits);
    Collections.sort(numbers);

    IO.println(numbers); // [5, 18, 42]
    IO.println(fruits);  // [apple, orange, pear]
}

Implementing the Comparable Interface Yourself

Let's try implementing the Comparable interface for one of our own classes.

Suppose we have a class called CollectibleCard, representing cards used in a collectible card game. Initially, our collectible card contains only a name and a unique identification number starting from one.

class CollectibleCard {
    private String name;
    private int idNumber;

    public CollectibleCard(String name, int idNumber) {
        this.name = name;
        this.idNumber = idNumber;
    }

    @Override
    public String toString() {
        return "Card: " + name + " (#" + idNumber + ")";
    }
}

void main() {
    List<CollectibleCard> cards = List.of(
        new CollectibleCard("Brilliant Dragon", 3),
        new CollectibleCard("Beginner Amoeba", 1),
        new CollectibleCard("Magnificent Seahorse", 2)
    );

    for (CollectibleCard card : cards) {
        IO.println(card);
    }
}

If we now try to sort CollectibleCard objects using Collections.sort(), we receive a compile-time error because the class does not implement the Comparable interface.

void main() {
    List<CollectibleCard> cards =
        Arrays.asList(
            new CollectibleCard("Brilliant Dragon", 3),
            new CollectibleCard("Beginner Amoeba", 1),
            new CollectibleCard("Magnificent Seahorse", 2)
        );

    IO.println("Before sorting:");
    for (CollectibleCard card : cards) {
        IO.println(card);
    }

    Collections.sort(cards);

    IO.println();
    IO.println("After sorting:");
    for (CollectibleCard card : cards) {
        IO.println(card);
    }
}

class CollectibleCard {

    private String name;
    private int idNumber;

    public CollectibleCard(
            String name,
            int idNumber) {
        this.name = name;
        this.idNumber = idNumber;
    }

    @Override
    public String toString() {
        return "Card: " + name + " (#" + idNumber + ")";
    }
}

main.java:14: error: no suitable method found for sort(List<CollectibleCard>)
    Collections.sort(cards);

The error message is rather cryptic. In simple terms, the error occurs because Collections.sort() cannot guess what the natural ordering of CollectibleCard objects should be. Should cards be ordered alphabetically by name? Or by increasing identifier number? To answer that question, we must implement the Comparable interface for the CollectibleCard class.

When implementing the Comparable interface for our collectible cards, we immediately have to consider what the natural ordering of our cards should be. For example, alphabetical ordering by name might be useful. On the other hand, since the cards have unique numerical identifiers starting from one, ordering by identifier might feel more natural and just as useful. When choosing a natural ordering, it is important to consider both the application domain and the needs of the users. What ordering would other programmers using the class—or the application's end users—expect as the default ordering for collectible cards?

For the purposes of this example, let's decide that ordering by the unique identifier is the most reasonable natural ordering. With that decision made, we can implement the Comparable interface so that cards are ordered according to their identifier number. To do this, we need to add the interface implementation to the class definition and implement the compareTo method.

We will use the return-value table presented earlier in the chapter.

class CollectibleCard implements Comparable<CollectibleCard> {
    private String name;
    private int idNumber;

    public CollectibleCard(String name, int idNumber) {
        this.name = name;
        this.idNumber = idNumber;
    }

    @Override
    public int compareTo(CollectibleCard other) {
        if (idNumber > other.idNumber) {
            return 1;
        }
        if (idNumber < other.idNumber) {
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Card: " + name + " (#" + idNumber + ")";
    }
}

void main() {
    List<CollectibleCard> cards =
        Arrays.asList(new CollectibleCard( "Brilliant Dragon", 3),
            new CollectibleCard("Beginner Amoeba", 1),
            new CollectibleCard("Magnificent Seahorse", 2)
        );

    IO.println("Before sorting:");
    for (CollectibleCard card : cards) {
        IO.println(card);
    }

    Collections.sort(cards);

    IO.println();
    IO.println("After sorting:");
    for (CollectibleCard card : cards) {
        IO.println(card);
    }
}

Comparable is a so-called generic interface, meaning that the interface itself does not specify what type of objects are being compared. We will cover generic programming in more detail in Part 4.4. Because of this, when implementing the Comparable interface, we must explicitly specify the type for which the natural ordering is being defined. In this case, we are defining an ordering for collectible cards, which is why we write: implements Comparable<CollectibleCard>.

Using Existing Comparison Methods

In the previous example, we implemented compareTo() directly according to the definition of the Comparable interface. However, Java's built-in types often already provide comparison methods that can be used when implementing Comparable.

For example, Java provides the method Integer.compare() for comparing int values. This allows us to simplify the implementation of compareTo() in CollectibleCard into a single-line method.

class CollectibleCard implements Comparable<CollectibleCard> {
    private String name;
    private int idNumber;

    public CollectibleCard(String name, int idNumber) {
        this.name = name;
        this.idNumber = idNumber;
    }

    @Override
    public int compareTo(CollectibleCard other) {
        return Integer.compare(idNumber, other.idNumber);
    }

    @Override
    public String toString() {
        return "Card: " + name + " (#" + idNumber + ")";
    }
}


void main() {
    List<CollectibleCard> cards = Arrays.asList(
        new CollectibleCard("Brilliant Dragon", 3),
        new CollectibleCard("Beginner Amoeba", 1),
        new CollectibleCard("Magnificent Seahorse", 2)
    );

    IO.println("Before sorting:");
    IO.println(cards);

    Collections.sort(cards);

    IO.println("After sorting:");
    IO.println(cards);
}

When implementing the Comparable interface for your own classes, it is generally a good idea to use existing comparison methods whenever possible. For example, Integer.compare() correctly handles all special cases related to integers. Similarly, Double.compare() correctly handles all floating-point special values, such as infinity and Not a Number (NaN).

Comparing Multiple Attributes

A natural ordering may also be based on multiple attributes. For example, we might decide that cards should be ordered alphabetically by name first, and by identifier number only when the names are the same. To achieve this, we modify compareTo() so that it first compares the name attributes using the String class's own compareTo() method. If the names are equal (that is, if compareTo() returns 0), then we compare the identifier numbers.

class CollectibleCard implements Comparable<CollectibleCard> {
    private String name;
    private int idNumber;

    public CollectibleCard(String name, int idNumber) {
        this.name = name;
        this.idNumber = idNumber;
    }

    @Override
    public int compareTo(CollectibleCard other) {
        int nameComparison = this.name.compareTo(other.name);
        if (nameComparison != 0) {
            return nameComparison;
        }

        return Integer.compare(this.idNumber, other.idNumber);
    }

    @Override
    public String toString() {
        return "Card: " + name + " (#" + idNumber + ")";
    }
}

void main() {
    List<CollectibleCard> cards = Arrays.asList( 
            new CollectibleCard("Brilliant Dragon", 3),
            new CollectibleCard("Beginner Amoeba", 1),
            new CollectibleCard("Magnificent Seahorse", 2)
        );

    IO.println("Before sorting:");
    for (CollectibleCard card : cards) {
        IO.println(card);
    }

    Collections.sort(cards);

    IO.println();
    IO.println("After sorting:");

    for (CollectibleCard card : cards) {
        IO.println(card);
    }
}

Exercises

List<Person> people = Arrays.asList(
    new Person("Joukahainen"),
    new Person("Ilmatar"),
    new Person("Kyllikki"),
    new Person("Kokko")
);

List<Person> people = Arrays.asList(
        new Person("Pacius", "Fredrik"),
        new Person("Mozart", "Wolfgang Amadeus"),
        new Person("Mozart", "Leopold"),
        new Person("Chopin", "Frédéric")
);

Inheritance and Interfaces in Object Collaboration

Learning Objectives

After completing this chapter, you will:

• Be able to use interfaces and abstract classes to avoid dependencies between classes.
• Recognize when inheritance should be used and when composition is the better alternative ("Composition over Inheritance").

Inheritance and interfaces can work together, and often do. Inheritance defines a hierarchy between classes and allows them to share common functionality. Interfaces, on the other hand, define capabilities that different classes can implement regardless of their position in the class hierarchy.

In fact, we already used both inheritance (the abstract Device class) and an interface (the Adjustable interface) in our Smart Home example. Let's expand this cooperation between inheritance and interfaces further. Consider a situation where we have classes that do not share a common superclass but still share a common capability.

Power Outlet and Electrical Devices

Let's do a small thought experiment. Imagine a power outlet on the wall of your home. The outlet provides electricity, but not to just anything. It requires the device to have a suitable plug.

In this analogy, an interface is the standard or contract that a device must satisfy in order to use the outlet. We can also think about it from another direction:

If a device has a plug that fits the outlet, it must be capable of reacting appropriately when connected to power.

The outlet does not care whether you plug in a toaster or a circular saw. These are actually completely different kinds of devices. One is used for food preparation; the other is a tool. They do not necessarily share a common ancestor in a class hierarchy the way a Car and a Motorcycle might inherit from a Vehicle class. The only thing connecting the toaster and the circular saw is their ability to connect to mains electricity.

If we tried to model this with inheritance alone, we would immediately run into problems. Should a toaster inherit from ElectricalDevice, KitchenAppliance, or perhaps both? Java does not allow a class to inherit from multiple superclasses.

An interface solves this elegantly:

• Toaster is a KitchenAppliance (inheritance), but it also implements the MainsPoweredDevice interface.
• Similarly, CircularSaw might be a Tool (inheritance) that also implements the same MainsPoweredDevice interface.

As a result, the outlet can accept either device because both satisfy the same contract.

At its simplest, the MainsPoweredDevice interface might define that a device must be able to react when power begins flowing through it.

public interface MainsPoweredDevice {
    // This method is the "plug".
    // When the outlet activates it,
    // the device receives power.
    void connectPower();
}

Now both Toaster and CircularSaw can implement this interface.

public class Toaster implements MainsPoweredDevice {
    @Override
    public void connectPower() {
        // The toaster's way of reacting to electrical power.
        IO.println( "Toaster: Heating elements begin glowing red.");
    }
}
public class CircularSaw implements MainsPoweredDevice {
    @Override
    public void connectPower() {
        // The circular saw's way of reacting to power.
        IO.println("CircularSaw: Motor begins spinning the blade at 4000 rpm.");
    }
}

These classes can exist in completely different parts of the class hierarchy. One is a kitchen appliance. The other is a tool. Both react to electrical power being connected—but in their own way. Let's add abstract superclasses KitchenAppliance and Tool, from which Toaster and CircularSaw inherit. To make the example more meaningful, we will add a few attributes and methods to the superclasses.

public abstract class KitchenAppliance {
    /**
     * Does the appliance contain heating elements?
     */
    boolean heating;

    /**
     * All kitchen appliances must be cleanable.
     */
    public abstract void clean();
}
public abstract class Tool {
    /**
     * Number of operating hours.
     */
    private int operatingHours = 0;

    /**
     * Use the tool.
     *
     * @param hours Number of hours the tool is used.
     */
    public void use(int hours) {
        this.operatingHours = hours;
    }

    /**
     * Service the tool.
     *
     * @return Whether servicing succeeded.
     */
    public abstract boolean service();
}

Now let's implement those behaviors in the subclasses.

// CircularSaw is a Tool that operates on mains power.
public class CircularSaw extends Tool implements MainsPoweredDevice {

    @Override
    public void connectPower() {
        // Circular saw's reaction to electrical power.
        IO.println("CircularSaw: Motor begins spinning the blade at 4000 rpm.");

        // Also call the superclass
        // use() method.
        super.use(1);
    }

    /**
     * Service the circular saw.
     *
     * @return Whether servicing  succeeded.
     */
    @Override
    public boolean service() {
        IO.println( "Servicing circular saw..."
            + "Sharpening blade and adjusting rotation speed."
        );
        return true;
    }
}
// Toaster is a KitchenAppliance that operates on mains power.
public class Toaster extends KitchenAppliance implements MainsPoweredDevice {

    @Override
    public void connectPower() {
        IO.println( "Toaster: Heating elements "
            + "begin glowing red."
        );
    }

    @Override
    public void clean() {
        IO.println( "Toaster: Removing crumbs "
            + "and wiping gently "
            + "with a damp cloth."
        );
    }
}

The class hierarchy would look like this:

This is the most important point conceptually: The power outlet is a class that uses the interface.

public class PowerOutlet {

    // Any mains-powered device
    // can be connected.
    // Outlot isn't intrested if it's toaster or TV
    public void connectDevice(MainsPoweredDevice device) {
        IO.println( "--- Power outlet supplies electricity ---");

        // The outlet calls the method defined by the contract.
        // Polymorphism occurs here:
        // each device reacts in its
        // own appropriate way.
        device.connectPower();
    }
}

Notice that the parameter type is the MainsPoweredDevice interface. The parameter does not need to be a Toaster, a CircularSaw, or any other specific class. It is enough that the object implements the interface.

This means the method can accept any object implementing MainsPoweredDevice, regardless of where that object belongs in the class hierarchy.

Interfaces as Variable Types

To put PowerOutlet to actual use, we need a main program that creates a PowerOutlet object and connects different devices to it. Let's first connect a Toaster.

public class HouseholdElectricity {

    public static void main(String[] args) {

        // 1. Create the infrastructure:
        // the power outlet
        PowerOutlet kitchenOutlet = new PowerOutlet();

        // 2. Create devices
        Toaster toaster = new Toaster();
        CircularSaw saw = new CircularSaw();

        // 3. Use the devices
        // through the outlet
        IO.println("--- Morning in the kitchen ---");

        kitchenOutlet.connectDevice(toaster);
        IO.println("\n--- Renovation begins ---");

        kitchenOutlet.connectDevice(saw);
    }
}

public interface MainsPoweredDevice {
    // This method is the "plug".
    // When the outlet activates it,
    // the device receives power.
    void connectPower();
}

public class Toaster extends KitchenAppliance implements MainsPoweredDevice {

    @Override
    public void connectPower() {
        IO.println( "Toaster: Heating elements "
            + "begin glowing red."
        );
    }

    @Override
    public void clean() {
        IO.println( "Toaster: Removing crumbs "
            + "and wiping gently "
            + "with a damp cloth."
        );
    }
}

// CircularSaw is a Tool that operates on mains power.
public class CircularSaw extends Tool implements MainsPoweredDevice {

    @Override
    public void connectPower() {
        // Circular saw's reaction to electrical power.
        IO.println("CircularSaw: Motor begins spinning the blade at 4000 rpm.");

        // Also call the superclass
        // use() method.
        super.use(1);
    }

    /**
     * Service the circular saw.
     *
     * @return Whether servicing  succeeded.
     */
    @Override
    public boolean service() {
        IO.println( "Servicing circular saw..."
            + "Sharpening blade and adjusting rotation speed."
        );
        return true;
    }
}

public abstract class KitchenAppliance {
    /**
     * Does the appliance contain heating elements?
     */
    boolean heating;

    /**
     * All kitchen appliances must be cleanable.
     */
    public abstract void clean();
}

public abstract class Tool {
    /**
     * Number of operating hours.
     */
    private int operatingHours = 0;

    /**
     * Use the tool.
     *
     * @param hours Number of hours the tool is used.
     */
    public void use(int hours) {
        this.operatingHours = hours;
    }

    /**
     * Service the tool.
     *
     * @return Whether servicing succeeded.
     */
    public abstract boolean service();
}

public class PowerOutlet {

    // Any mains-powered device
    // can be connected.
    // Outlot isn't intrested if it's toaster or TV
    public void connectDevice(MainsPoweredDevice device) {
        IO.println( "--- Power outlet supplies electricity ---");

        // The outlet calls the method defined by the contract.
        // Polymorphism occurs here:
        // each device reacts in its
        // own appropriate way.
        device.connectPower();
    }
}

As we learned in Chapter 3.2 Polymorphism, we don't actually need to declare the variables using their concrete types (Toaster and CircularSaw). Since we only care that the devices can be plugged into an outlet, both variables can be declared using the interface type instead.

public class HouseholdElectricity {

    public static void main(String[] args) {

        PowerOutlet kitchenOutlet = new PowerOutlet();

        // HIGHLIGHT_GREEN_BEGIN
        MainsPoweredDevice toaster = new Toaster();
        MainsPoweredDevice saw = new CircularSaw();
        // HIGHLIGHT_GREEN_END

        IO.println("--- Morning in the kitchen ---");
        kitchenOutlet.connectDevice( toaster);

        IO.println("\n--- Renovation begins ---");
        kitchenOutlet.connectDevice(saw);
    }
}

Programming to a Supertype

The practice described above—treating subclass objects as objects of a superclass or interface type—is very common and highly recommended in object-oriented programming. It is often referred to as: programming to an interface or programming to a supertype. This approach reduces coupling between program components and allows implementations to be substituted without changing the rest of the code.

Why Is Programming to a Supertype Useful? One reason is that it allows us to treat very different kinds of objects as a uniform collection. We already did something similar in the polymorphism examples. Consider our MainsPoweredDevice example. We can create a list containing different kinds of mains-powered devices and connect all of them to a power outlet in a loop.

List<MainsPoweredDevice> devices = List.of(
    new Toaster(),
    new CircularSaw(),
    new VacuumCleaner()
);

PowerOutlet outlet = new PowerOutlet();

for (MainsPoweredDevice device : devices) {
    outlet.connectDevice(device);
}

If each device were treated only as its concrete type, we might end up writing something like this instead (assuming KitchenAppliance and Tool are existing superclasses):

List<KitchenAppliance> kitchenAppliances = ...;
List<Tool> tools = ...;

PowerOutlet outlet = new PowerOutlet();

for (KitchenAppliance appliance : kitchenAppliances) {
    outlet.connectDevice(appliance);
}

for (Tool tool : tools) {
    outlet.connectDevice(tool);
}

Another advantage is easy substitutability, often referred to as loose coupling. When code uses an interface as the variable type, it is not tied to any specific implementation. This means we can replace one implementation with another without modifying the code that uses the interface.

Imagine we are building a program for testing electrical devices.

Toaster deviceUnderTest = new Toaster();

// ... test the device ...

// Switch to another device implementation
deviceUnderTest = new CircularSaw(); // Does not compile

This does not work because the types do not match. When the variable is declared using the interface type, replacing implementations becomes easy.

MainsPoweredDevice deviceUnderTest = new Toaster();
// ... test the device ...

// Switch to another implementation
deviceUnderTest = new CircularSaw();

// This works because both implement
// the MainsPoweredDevice interface.

A third reason relates to software design. When you declare a variable as MainsPoweredDevice, the compiler prevents you from calling methods that are specific only to a toaster (such as getHeatingLevel()) or only to a circular saw (such as setBladeHeight()). While this kind of self-imposed restriction may initially seem inconvenient, it helps keep code clean and prevents mistakes where an object is used in a way that is incompatible with the interface being relied upon.

The Liskov Substitution Principle

Closely related to loose coupling is the Liskov Substitution Principle (LSP). The Liskov Substitution Principle states that an object should be replaceable by another object implementing the same interface or contract without changing the correctness of the program. In practice, this means: a subclass should honor the contracts and behavioral expectations established by its superclass. A class implementing an interface should honor the contract defined by that interface.

Let's briefly return to the instrument example introduced in Chapter 3.2. Suppose we have an interface Instrument, which defines the ability to perform music for an audience through the method play().

public interface Instrument {
    /**
     * Performs a musical piece for an audience.
     */
    void play();
}

All instruments—such as Guitar, Piano, and DrumSet—implement this interface. A concert organizer wants to ensure that all instruments can perform, regardless of their specific type. Let's create a Concert class whose playAllInstruments() method instructs all instruments to play.

public class Concert {
    public void playAllInstruments(Instrument[] instruments) {
        for (Instrument instrument : instruments) {
            instrument.play();
        }
    }
}

Now let's create a new instrument called PracticePiano. This piano can only be played through headphones, meaning the audience cannot hear anything. It still implements the Instrument interface, but its behavior differs from the expectation established by the interface.

class PracticePiano implements Instrument {
    @Override
    public void play() {
        // Technically meaningful,
        // but violates the intended contract.
        IO.println("Practicing with headphones. The audience hears nothing."
        );
    }
}

Let's assemble a "concert" in the main program.

void main() {
    Instrument[] instruments = {
        new Guitar(),
        new Piano(),
        new PracticePiano()
    };

    Concert concert = new Concert();
    concert.playAllInstruments(instruments);
}

The code works perfectly well from a technical perspective. However, PracticePiano violates the contract implied by the Instrument interface. Its play() method does not actually "perform music for an audience"; it performs only for the player. The subclass's behavior might make sense in another context—in this case, practice sessions—but it does not satisfy the expectations established by the interface. In a well-designed class hierarchy, every object adheres to the contract promised by its superclass or interface. This allows polymorphism to be used reliably without requiring the programmer to know every concrete implementation in advance.

Our electrical device example relates to the same principle. Recall that we declared our toaster and circular saw variables as type MainsPoweredDevice. Because of this, we cannot call methods that are not part of the MainsPoweredDevice interface. For example: toaster.clean(); saw.service(); would not be allowed through MainsPoweredDevice references because those methods do not belong to the interface. If we genuinely need access to those methods, we should stop and ask why we are treating the object merely as a mains-powered device in the first place. From a software design perspective, such a situation suggests that we may be trying to solve two different problems in the same place.

In a good design, code that works with MainsPoweredDevice objects—such as an electricity meter or fuse box—is interested only in electrical behavior. It should not care whether the device is a toaster or a circular saw, and it certainly should not be responsible for cleaning or servicing them.

If we find ourselves needing the clean() method, we are probably "in the wrong room":

• Wrong abstraction level. If we are building application logic for cleaning kitchen equipment, we should not store devices in a List<MainsPoweredDevice>. Instead, we should use a List<KitchenAppliance>. Then every object in the list naturally provides the clean() method.

• Single Responsibility Principle. If the same method attempts both to measure electricity consumption (an interface concern) and clean the appliance (a kitchen-appliance concern), it is doing too much. A better solution is to separate responsibilities: one part of the program manages electrical devices through the MainsPoweredDevice interface, while another handles maintenance through KitchenAppliance or Tool types.

In summary, rather than trying to expose specialized features through a generic interface, we should choose the variable type according to the task at hand. An electrician sees a circular saw as a mains-powered device. A carpenter sees it as a tool. The code should reflect this distinction.

Abstract Class or Interface?

The table below summarizes the key differences between abstract classes and interfaces.

Exercises

Type Parameters and Generics

Learning Objectives

• Be able to use type parameters to implement reusable, generic classes and methods.

In your previous programming courses, you learned that parameters help reduce repetition by generalizing program behavior for different values. The idea behind parameters is to separate the logic of a computation from the actual values being processed. When we write a method, the computation only needs to be defined once. For example, if we wanted to determine the index where a number first appears without using parameters, we might write code like this:

void main() {
int[] array1 = {2, 3, 4};
// Search for the number 3
for (int i = 0; i < array1.length; i++) {
    if (array1[i] == 3) {
        IO.println("The number 3 first appears at index " + i);
        break;
    }
}

int[] array2 = {-20, 10, 2, 1};
// Search for the number 2
for (int i = 0; i < array2.length; i++) {
    if (array2[i] == 2) {
        IO.println("The number 2 first appears at index " + i);
        break;
    }
}
}

This works, but the code contains unnecessary duplication. Let's create a function that takes the array as a parameter.

int findIndex(int[] array, int target) {
    for (int i = 0; i < array.length; i++)
        if (array[i] == target) return i;
    return -1;
}

void main() {
    IO.println("The number 3 is at index " + findIndex(new int[] {2, 3, 4}, 3));
    IO.println("The number 2 is at index " + findIndex(new int[] {-20, 10, 2, 1}, 2));
}

You can think of this as using parameters at the value level: the method remains general, while the values vary.

However, we quickly discover that the same findIndex() method does not work for other numeric types such as long or float, nor for completely different types such as String. For those cases, we would need separate methods.

int findIndexLong(long[] array, long target) {
    for (int i = 0; i < array.length; i++)
        if (array[i] == target) return i;

    return -1;
}

int findIndexFloat(float[] array, float target) {
    for (int i = 0; i < array.length; i++)
        if (array[i] == target) return i;

    return -1;
}

int findIndexString(String[] array, String target) {
    for (int i = 0; i < array.length; i++)
        if (array[i].equals(target)) return i;

    return -1;
}

void main() {
    long[] longArray = {-10L, 5L, 1L};
    float[] floatArray = {-10.0f, 2.0f};
    String[] stringArray = {"Dog", "Cat", "Bird"};
    IO.println("The number -10 is at index " + findIndexLong(longArray, -10L));
    IO.println("The number 2.0 is at index " + findIndexFloat(floatArray, 2.0f));
    IO.println("The string \"Cat\" is at index " + findIndexString(stringArray, "Cat"));
}

Because Java is a statically typed language, we cannot write a single method that automatically works for all these types. Without a better solution, we easily end up with a collection of nearly identical methods: findIndexInt, findIndexDouble, findIndexString and so on. The code is practically the same; only the types differ.

The fundamental idea behind all these methods is really this:

int findIndex(TYPE[] array, TYPE target) {
    for (int i = 0; i < array.length; i++)
        if (array[i] == target) return i;

    return -1;
}

In Java, writing this kind of code is possible through type parameters.

Type Parameters

A type parameter is a parameter whose value is itself a data type. The purpose of type parameters is to reduce duplication in situations where the same code works for different types while preserving the benefits of static typing. Type parameters can also eliminate unnecessary type casts in many situations.

Type parameters can be defined for methods in addition to ordinary parameters. As a special feature, they can also be defined for classes. Together, method and class type parameters enable generic programming, that is, programming algorithms and data structures that are independent of a specific type.

Generic Methods

A method that defines one or more type parameters is called a generic method. In a generic method, the data type is not fixed when the method is defined. Instead, the type is represented by a symbol whose meaning is determined when the method is called. A method's type parameter is written inside angle brackets before the return type. By convention, single uppercase letters are often used. The most common is T, which stands for Type.

// Method "print" with one type parameter T
// and one ordinary parameter "value"
<T> void print(T value) {
    IO.println("Hello, I am '" + value + "' and I am an object of class '" + value.getClass() + "'!");
}

void main() {
    print(1.0);
    print(1);
    print("cat");
}

A generic method may be static, non-static, or a constructor. The type parameter can appear in the return type, method parameters, or both.

A method may have one or more type parameters. Multiple type parameters are written as a comma-separated list inside angle brackets, and each type parameter may represent an independent type.

For example we cahn have two type parameters T1 and T2:

<T1, T2> String combine(T1 value1, T2 value2) {
    return value1.toString() + ", " + value2.toString();
}

void main() {
    IO.println(combine(1, 2)); // T1 = Integer, T2 = Integer
    IO.println(combine(true, 1.0)); // T1 = Boolean, T2 = Double
}

The convention for naming type parameters is usually to use a single uppercase letter that reflects the role of the parameter: T (Type), E (Element), K (Key), V (Value) and N (Number). Occasionally numbers are appended, such as T1, T2, and T3.

Notice that in the examples above, type parameters are defined but are not explicitly supplied when calling the method. They could be:

<T> void print(T value) {
    IO.println("Hello, I am '" + value + "' and I am an object of class '" + value.getClass() + "'!");
}


void main() {
    this.<Double>print(1.0); // same as print(1.0)
    this.<String>print("cat"); // same as print("cat")
}

Normally, the type parameter is not provided explicitly because the compiler can infer it automatically. For example, in the call: print(1.0); the compiler sees that 1.0 is of type double and infers that T should be Double. It is nevertheless important to remember that a type parameter value does exist behind the scenes even when it is not written explicitly.

Let's see how our earlier searching problem can be solved using a generic method.

<T> int findIndex(T[] array, T target) {
    for (int i = 0; i < array.length; i++)
        if (array[i].equals(target)) return i;
    return -1;
}

void main() {
    Integer[] integers = {2, 3, 4};
    Double[] doubles = {-10.0, 2.0, 0.0, 5.5 };
    String[] animals = {"dog", "cat", "cheetah", "cat", "cheetah" };

    IO.println(findIndex(integers, 3));
    IO.println(findIndex(doubles, 5.4));
    IO.println(findIndex(animals, "cheetah"));
}

Notice that we had to make a couple of important changes.

First, the comparison is now performed using array[i].equals(target). This is because the type parameter T can represent any reference type, and reference values cannot generally be compared using the == operator.

Second, in the main method we must use the wrapper classes Integer, Double, and Long instead of the primitive types int, double, and long. This is because only reference types can be used as type parameters in Java. This restriction stems from the way Java implements generics internally. It is worth mentioning that Java is continually evolving, and it is quite possible that this limitation will disappear in the future.

Generic Classes and Generic Interfaces

Generics are not limited to methods. The real power of type parameters becomes evident when they are defined for classes or interfaces. In fact, we have already used type parameters throughout the course in classes such as ArrayList<T>. The list itself is generic, while the type of elements stored in it is specified later.

A generic class is particularly useful when a class stores values of a specific type and multiple methods operate on that same type parameter. For example, a Pair<T, U> class might store two values whose types should remain fixed throughout the object's lifetime.

public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(U second) {
        this.second = second;
    }
}

Using this class, we can create objects whose values may be of any types without writing separate classes for every possible combination. For example:

 public class Pair<T, U> {
     private T first;
     private U second;

     public Pair(T first, U second) {
         this.first = first;
         this.second = second;
     }

     public T getFirst() {
         return first;
     }

     public U getSecond() {
         return second;
     }

     public void setFirst(T first) {
         this.first = first;
     }

     public void setSecond(U second) {
         this.second = second;
     }
 }
void main() {
    Pair<String, Integer> nameAndAge = new Pair<>("Matti", 30);
    IO.println("Name: " + nameAndAge.getFirst() + ", Age: " + nameAndAge.getSecond());

    Pair<Double, Double> coordinates = new Pair<>(60.192059, 24.945831);
    IO.println("Latitude: " + coordinates.getFirst() + ", Longitude: " + coordinates.getSecond());
}

If we attempted to implement the same functionality using Object attributes and tried to compensate with generic methods, type safety would easily be lost and mandatory type casts would introduce potential runtime errors.

public class Pair {
    private final Object first;
    private final Object second;

    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }

    public <T> T getFirst() {
        return (T) first;
        // type cast, no compile-time verification
    }
}

In the example above, the supposedly generic method does not actually make the class type-safe because the object's state is still stored as Object, and type conversions occur only at runtime. The core idea of a generic class is that the type becomes attached to the class fields and their usage at compile time.

It is important to note that the choice between a generic method and a generic class does not depend on whether the method is static. Instead, it depends on whether the type belongs to the class's permanent structure or merely to a single operation. A method inside a generic class may still itself be generic, provided it uses its own type parameter and does not conflict with the class's type parameter.

static <T> T choose(T a, T b) {
    return a;
}

// choose(1, 1.0);
// COMPILATION ERROR:
// T cannot be inferred
Number n = <Number>choose(1, 1.0);
// OK: type supplied explicitly

Generics and Polymorphism

Generics and polymorphism (more precisely, subtype polymorphism) are two different mechanisms that complement one another. Although both increase code flexibility, they solve different problems and operate at different stages of program execution.

1. Polymorphism (subtyping) is a runtime mechanism. We studied it in Chapter 3. It allows objects to be handled through a superclass or interface, with the correct method implementation chosen at runtime.
2. Generics (parametric polymorphism) are a compile-time mechanism. Their purpose is to ensure type safety and reduce duplication while allowing the same code to work with different types without losing type information.
3. Plain polymorphism (without type safety) Before generics were introduced (Java 1.4 and earlier), collections relied entirely on polymorphism and the Object class.

void main(){
// Raw list (raw type) - No longer recommended
List list = new ArrayList();

list.add("text");
list.add(123); // Allowed because Integer is an Object

for (Object o : list) {
    // Calls each object's own toString()
    IO.println(o.toString());
}
}

Here polymorphism itself works, but the code is not type-safe. The compiler cannot prevent us (but it will kindly warn us) from inserting incorrect types into the list, which often leads to errors only when we later attempt to cast values back to their original types.

Generics introduce constraints that the compiler can verify.

import java.util.*;
void main(){
List<String> words = new ArrayList<>();
words.add("cat");
words.add("dog");
words.add(123); // COMPILATION ERROR!
}

In this example, generics prevent incorrect usage before the program is even run. Here we are not really utilizing polymorphism between our own classes; instead, we rely on the compiler's strict enforcement that the list contains only strings.

The most powerful approach is to combine both generics and polymorphism: generics restrict the allowed types to a particular family (for example, Number), while polymorphism handles the individual behavior of members of that family.

void main(){


// The list can contain any kind of number (Integer, Double, Long, ...)
List<Number> numbers = new ArrayList<>();
numbers.add(1);     // Integer is a Number
numbers.add(2.5);   // Double is a Number

for (Number n : numbers) {
    // Generics guarantee that 'n' is at least a Number.
    // Polymorphism (the implementation provided by Number subclasses)
    // handles the actual values.
    IO.println(n.doubleValue());
}
}

Type Bounds

Type parameters can be restricted so that only certain kinds of types may be used as arguments. This is done using the extends keyword when defining the type parameter. Bounds may be classes or interfaces, and they define the upper limit of the types that the type parameter may represent. Notice that extends is used here for both classes and interfaces, even though interfaces do not actually inherit from classes.

// Type parameter T can only be a subtype of Number
<T extends Number> void printNumber(T number) {
    IO.println("Number: " + number.doubleValue());
}

void main() {
    printNumber(10); // OK: Integer is a Number
    printNumber(3.14); // OK: Double is a Number
    // printNumber("cat"); // COMPILATION ERROR: // String is not a Number
}

Multiple bounds can be specified using the & operator. The type parameter must satisfy all specified requirements. The following method requires T to be both a subtype of Number and an implementation of Comparable<T>.

// T must be both Number and Comparable
<T extends Number & Comparable<T>> void compare(T a, T b) {
    if (a.compareTo(b) < 0) {
        IO.println(a + " is smaller than " + b);
    } else if (a.compareTo(b) > 0) {
        IO.println(a + " is larger than " + b);
    } else {
        IO.println( a + " is equal to " + b);
    }
}

void main() {
    compare(10, 20); // OK: Integer is Number and Comparable
    compare(3.14, 2.71); // OK: Double is Number and Comparable
    // compare("cat", "dog"); // COMPILATION ERROR: String is not a Number
}

Type restrictions can also be expressed using the wildcard symbol (?), which represents an unknown type. Wildcards make it possible to define upper and lower bounds for generic types. They are commonly used with collections when we want to express that a collection can be read from or written to using a certain family of types, even though the exact element type is not known beforehand. Consider the following examples.

// Accepts a list containing any subtype of Number.
// Values can be read as Numbers,
// but nothing can be added because
// the exact type is unknown.
void printNumbers(List<? extends Number> numbers) {
    for (Number n : numbers) {
        IO.println(n);  // Note, that we don't know the exact type.
    }
    // numbers.add(10); // COMPILATION ERROR, because we don't know the exact type
}
/*
 * Accepts a list whose element type is Number or one of its supertypes
 * (for example Object).
 * It is therefore safe to add Number values and subclasses of Number.
 */
void addNumbers( List<? super Number> list) {
    list.add(10); // OK: Integer is a Number
    list.add(3.14); // OK: Double is a Number
    // list.add("cat"); // COMPILATION ERROR: String isn't a Number
    // Integer first = list.getFirst(); // COMPILATION ERROR: exact type unknown
    // We can't presume it to be Integer
}

We will not discuss wildcards in more detail in this chapter, but you are encouraged to explore them independently in the Java documentation.

Invariance of Generic Types

Although Integer is a subtype of Number, List<Integer> is not a subtype of List<Number>. These are completely separate types and there is no inheritance relationship between them. This property is known as invariance. Generic types are invariant by default for safety reasons. The following example illustrates the idea.

void main(){
List<Integer> integers = new ArrayList<>();
integers.add(1);

// If generics were NOT invariant, we could do this:
List<Number> numbers = integers; // This is exactly what Java prevents.

// Both variables would now refer to the same list in memory.
// Since numbers has type List<Number>, we could add a floating-point value:
numbers.add(3.14);

// But integers still assumes it contains only Integer values!
Integer i = integers.get(1); // BOOM! Runtime error: ClassCastException
}

If we could treat a list of integers as a general list of numbers, we could accidentally insert floating-point values into it. Later, when the original code tries to read the list as integers, the program would fail. Interestingly, Java arrays behave differently. Arrays are covariant, meaning that an Integer[] array can be treated as a Number[] array. However, type safety is then checked only at runtime. If an element of the wrong type is stored, Java throws an ArrayStoreException.

void main(){
// This is allowed in Java:
Integer[] integers = {1, 2};
Number[] numbers = integers; // OK with arrays!

// But this fails at runtime:
numbers[0] = 3.14; // ArrayStoreException!
}

With arrays, Java accepts the risk and reports the error only when the program is running. One of the major goals of generics was to solve this problem by moving such errors to compile time.

If we want to utilize polymorphism between generic collections, we must use wildcards. For example, if we wish to treat a List<Integer> like a list of numbers, we can use List<? extends Number>.

void main(){
List<Integer> integers = Arrays.asList(1,2,4,8,16);
// Now this is allowed,
// but the list becomes effectively
// read-only for safety reasons.
List<? extends Number> numbers = integers;

for (Number n : numbers) {
    IO.println(n);  // Works
}
// numbers.set(0,5); // Compile error
}

Exercises

All Exercises in This Part

String encrypt(String message);
String decrypt(String encryptedMessage);

'a' -> '@'
'e' -> '3'
'i' -> '!'
'o' -> '0'

'a' -> 'b'
'b' -> 'c'
'k' -> 'l'

List<Person> people = Arrays.asList(
    new Person("Joukahainen"),
    new Person("Ilmatar"),
    new Person("Kyllikki"),
    new Person("Kokko")
);

List<Person> people = Arrays.asList(
        new Person("Pacius", "Fredrik"),
        new Person("Mozart", "Wolfgang Amadeus"),
        new Person("Mozart", "Leopold"),
        new Person("Chopin", "Frédéric")
);

Data Structures and Algorithms

Learning objectives

• You understand what a collection is and why collections are used in programming.
• You understand the basic structure of Java's Collections Framework.
• You are familiar with the most common data structures in Java and their key methods.
• You understand how a dynamic list is implemented internally.
• You can implement your own simple collection data structure.
• You understand why an object's equals and hashCode methods are particularly important.
• You can evaluate how different data structures affect performance in different situations.
• You understand how recursion works.

Collections

Learning Objectives

• Understand what a collection is and why collections are used in programming.
• Understand the basic structure of the Java Collections Framework.
• Be familiar with the methods provided by Java's Collection interface and know how to use them in programs.

At the heart of programming is often the task of organizing data into meaningful structures. Earlier, we used arrays and lists to store collections of similar values, such as temperatures or students. We have also learned object-oriented programming, which allows us to bundle data and related functionality together.

However, a simple list of values is not always enough. Although arrays and lists are useful, real-world problems often require more specific rules regarding how data is added, removed, or retrieved.

In Java, the term collection refers to an object whose purpose is to manage a group of other values or objects. A collection is not merely a container; it is a data structure that defines the rules for handling data. Choosing the correct data structure is an important skill for a programmer because it affects both program efficiency and code readability.

Here are some examples of situations where an array or a list is no longer the optimal solution:

• Queue: When you call a customer service center, incoming calls are placed in a queue. New callers join the end of the queue, and the customer service representative always serves the caller at the front. This "first in, first out" structure is called a queue. A queue is optimized for these kinds of insertions and removals, unlike a regular list. A stack, on the other hand, works in the opposite way: the last item added is the first one removed, much like a stack of plates.

• Set: In a service such as Discord or in a contact list, it usually does not make sense to add the same person as a friend twice. A structure that ensures each element appears only once (unique values) is called a set.

• Map: In a student information system, each student number corresponds to a particular grade. This is not simply a list; it involves keys (student numbers) and associated values (grades). A structure that allows data to be retrieved using a unique key is called a map or associative array.

In principle, we could implement all of this behavior using ordinary lists and a large amount of additional code, such as if statements to detect duplicates or loops to search for values. The Java Collections Framework provides ready-made, optimized, and easy-to-use tools for these situations.

The Java Collections Framework

Java provides a large collection of ready-made data structures as well as interfaces for creating new ones through the Java Collections Framework.

The Collections Framework is built around two main concepts:

• Collection interfaces, which define what operations can be performed on a collection (for example, List and Set).
• Concrete implementation classes, which implement one or more interfaces in a particular way (for example, ArrayList, HashSet, and HashMap).

For example, List is a collection interface. It defines the methods that a list should provide, but it does not specify how those methods are implemented. ArrayList, on the other hand, is a class that implements the List interface using an array internally. Other list implementations will be discussed later in Chapter 5.2.

The most important interface in the Collections Framework is Collection, which serves as a high-level general-purpose interface. The List interface inherits from Collection, so an ArrayList can be stored in a variable of type Collection.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("strawberry", "blueberry", "lingonberry", "cloudberry")
);

IO.println(berries);
}

The Collection interface makes no assumptions about the order of elements or the specific contents of the collection. A large number of Java's built-in collections implement the Collection interface. Next, let's look at the operations available through this interface.

Adding and Removing Elements

Elements are added using the add() method and removed using the remove() method. Both methods return true if the collection was modified.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("strawberry", "blueberry", "lingonberry", "cloudberry")
);

berries.add("cherry");
IO.println(berries);

berries.remove("strawberry");
IO.println(berries);
}

Adding an element does not always succeed in every collection implementation. For example, a Set does not allow duplicate elements, so add() may return false. Likewise, remove() removes the first element found using the equals() method and returns false if no matching element exists.

The Collection interface does not include the concept of indexes. Therefore, remove() removes elements based on value rather than position, such as "the third element." If you want to add or remove elements using indexes, you need the List interface instead.

In addition to removing individual elements, an entire collection can be emptied using the clear() method.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("strawberry", "blueberry", "lingonberry", "cloudberry")
);

berries.clear();
IO.println(berries);
}

Checking Whether an Element Exists

The Collection interface also defines the contains() method, which allows you to check whether a collection contains a particular element. The check is based on the equals() method. Therefore, when working with your own classes, equals() should be implemented appropriately. We will return to this topic in Chapter 5.2.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("blueberry", "lingonberry", "cloudberry", "cherry")
);

IO.println("Contains blueberry: " + berries.contains("blueberry"));

// Strawberry was removed earlier, so it should not be found.
IO.println("Contains strawberry: " + berries.contains("strawberry"));
}

Number of Elements and Emptiness

The Collection interface defines the methods size and isEmpty, which allow you to determine how many elements are stored in a collection and whether the collection is empty. The isEmpty() method is often a clearer way to express that you are only interested in whether the collection contains any elements.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("blueberry", "lingonberry", "cloudberry", "cherry")
);

IO.println("Number of berries: " + berries.size());
IO.println("Is the berry collection empty: " + berries.isEmpty());
}

Iterating Through Elements

The Collection interface inherits from the Iterable interface. Because of this, the elements of a collection can be traversed using a for-each loop.

void main() {
Collection<String> berries = new ArrayList<>(
    List.of("blueberry", "lingonberry", "cloudberry", "cherry")
);

for (String berry : berries) {
    IO.println("Berry: " + berry);
}
}

The Collection interface does not make any guarantees about the ordering of elements. As a result, iteration is not based on indexes, and the order of traversal always depends on the specific collection implementation being used. For example, ArrayList preserves insertion order, whereas HashSet does not guarantee any particular ordering.

As a side note, Collection truly does inherit the Iterable interface. We did not discuss interface inheritance earlier, but the idea works in interfaces just as it does with classes: every implementation of Collection must also satisfy the requirements defined by Iterable.

List Structures

The List interface describes a collection whose elements are stored in a specific order and can be accessed using an index. In many ways, this resembles an array, but it provides a significantly more flexible interface. As a side note, it would be more precise to say that we are dealing with the List<E> interface, where E represents the type of the list's elements. However, for the sake of readability, we will ignore generics in this discussion.

Imagine a program that stores student names in the order in which students enrolled in a course. In this situation, order matters, and the same name may appear multiple times because two different people can share the same name.

void main() {
List<String> students = new ArrayList<>();
students.add("Aino");
students.add("Ville");
students.add("Aino");

IO.println(students.get(1)); // Ville
}

Using a list feels natural because the data is viewed as a sequence: first, second, third. ArrayList is the most common choice because it provides fast access to elements through indexes. At this stage of the course, you can generally think of List as meaning ArrayList, unless there is a specific reason to use a different implementation.

The relative order of elements is preserved even when elements are removed. When one element is removed, all subsequent elements automatically shift one position toward the beginning of the list.

void main() {
List<String> students = new ArrayList<>();
students.add("Aino");
students.add("Ville");
students.add("Aino");
students.remove("Ville");
IO.println(students);
}

Every element in a list always has a particular position, called its index. Because of this, a list is always traversed in a predictable order. This makes lists suitable for situations where order matters, order should be modified or preserved, or duplicate elements are allowed.

Our Own List Implementation

Next, we will build a simple dynamic list structure on top of an array. The goal is to illustrate the basic principles behind how ArrayList works internally. The implementation will not be complete and will not cover the entire List interface, but it is sufficient for understanding the core ideas.

We begin by creating our own class List<T>, which contains an array for storing elements. The following code is provided:

public class List<T> {
    private T[] elements;
    private int size;

    @SuppressWarnings("unchecked")
    public List(int capacity) {
        this.elements = (T[]) new Object[capacity];
        this.size = 0;
    }
}

As a result, the elements array is initialized with capacity number of null values. At this point, it is necessary to explain why @SuppressWarnings("unchecked") is required. Java does not allow us to directly create a generic array of type T. A type parameter such as T exists only during compilation. At runtime, Java does not know what T actually represents. This phenomenon is known as type erasure. Arrays, however, are type-aware at runtime. When an array is created, the JVM knows exactly what type of elements may be stored in it. This creates a conflict: Java cannot create an array of type T because the real type of T is not available at runtime.

Therefore, the following is not allowed:

new T[10]; // Compilation error

The only way around this limitation is to create an array of the most general reference type, Object, and cast it into a generic array.

(T[]) new Object[capacity];

The compiler knows that this conversion is not completely safe. It cannot prove that elements of the wrong type will never end up in the array. The annotation @SuppressWarnings("unchecked") does not make the code safer or less safe. It merely tells the compiler that you are aware of this limitation and choose to accept it. Without the annotation, the program behaves exactly the same way, but the compiler displays a warning.

List<String> names = new List<>(10); // List, where T is string and length 10
Object o = names;
List<Integer> numbers = (List<Integer>) o; // unchecked cast

numbers.add(42); // assuming add() has been implemented

String s = names.get(0); // ClassCastException

Basic List Operations

The first operation we will implement is add(element), which adds an element to the end of the list. For now, we will ignore the situation where the array becomes full. If there is still space available in the array, adding an element is simple: place the element in the next available position and increase the size by one. If the array is already full, we simply return immediately without doing anything. We will improve this behavior later.

Because we cannot yet retrieve values from the list, we cannot programmatically verify that insertion worked correctly. However, we can use a debugger. Call the add method from the main program and place a breakpoint afterward.

void main() {
    List<String> list = new List<>(10);
    list.add("Aino");
    list.add("Ville");
    list.add("Matti");
    // Place a breakpoint at the closing brace
}

Start IntelliJ IDEA's debugger. Open the Threads and Variables view. You should now be able to inspect the list object and its elements array. The added names should appear at the beginning of the array. By default, IntelliJ IDEA hides the trailing null values in arrays. To display them, right-click the array, select "Customize Data View", and disable "Hide Null Elements".

Next, let's implement a method get(int index) that returns the element at a specified index, and a method set(int index, T element) that replaces the element at a particular index.

public T get(int index) {
  if (index < 0 || index >= size) {
    throw new IndexOutOfBoundsException("Index " + index + " is not in the range 0.." + (size - 1));
    }
    return elements[index];
}

public void set(int index, T element) {
  if (index < 0 || index >= size) {
    throw new IndexOutOfBoundsException("Index " + index + " is not in the range 0.." + (size - 1));
    }
    elements[index] = element;
}

We will discuss exceptions in more detail later, but it is useful to briefly explain what the line throw new ... means. List indexes start at zero and continue up to size - 1. If an attempt is made to access an index that is less than zero or greater than or equal to size, the index lies outside the bounds of the list. This is standard behavior in Java collections and should already be familiar from basic programming courses.

Dynamic Behavior

Although the List interface in Java does not strictly require dynamic resizing, in practice lists are expected to support adding and removing elements dynamically. This means that the size of a list can change while the program is running. This is a significant difference compared to arrays, whose size is fixed once they have been created.

Implementing dynamic behavior on top of an array requires a bit of additional logic. If there is still room in the array—that is, if size is smaller than the array length—adding a new element is straightforward: place the element in the next available position and increment the size by one. If the array is full, the usual approach is to create a new array, typically twice as large, copy all elements from the old array into the new one, and then add the new element to the new array. This process ensures that the list can continue growing whenever necessary.

Removing elements is slightly more complicated, because removing an element leaves an empty slot in the array. One possibility would be to leave the position as null. However, this would cause problems because the ordering of elements and their indexes would no longer match the logical structure of the list.