Chapter 1: Introduction to Java

Java is one of the few programming languages that has sustained its influence across generations of developers and computing platforms. First released in the mid-1990s, it has quietly become the backbone of modern software, from Android apps and enterprise servers to scientific systems and embedded devices. Its guiding promise, “write once, run anywhere,” remains more relevant than ever in a world of diverse hardware and cloud environments.

At its core, Java is about clarity, safety, and longevity. It was designed to combine the familiarity of C-style syntax with the discipline of object-oriented structure and the safety of automatic memory management. The result is a language that balances power with predictability: fast enough for large-scale systems, yet structured enough for long-term maintenance. Unlike languages that come and go with trends, Java continues to evolve deliberately, preserving compatibility while embracing features such as lambdas, streams, pattern matching, and modularity.

This book takes a practical and modern view of Java. It assumes you already understand basic programming ideas (variables, loops, functions) and want to become fluent in Java’s particular approach. We begin from first principles: installing the current Long-Term Support (LTS) release, writing and compiling your first program, and understanding how Java’s strict type system and virtual machine work together to make code both portable and robust.

The goal is not simply to list syntax rules but to help you see the language as a living design system; how its structure guides thought, how its type safety enforces clarity, and how its ecosystem supports everything from command-line utilities to cloud-native applications. Each chapter builds on the last, moving steadily from fundamentals to expressive features such as generics, concurrency, and the functional style introduced in modern Java.

By the end of this book you will have written and understood a broad range of examples that reflect how real Java is written today. You will also have the foundation to read, extend, and reason about almost any Java codebase with confidence. Whether you aim to master backend development, Android, data processing, or simply want a language that rewards disciplined thought, Java remains one of the most reliable paths to professional programming fluency.

Who this book is for

This book is written for anyone who already understands the basic ideas of programming and wants to gain a clear, complete understanding of how Java works. If you have coded before in another language such as Python, JavaScript, C, C++, or PHP, you will find the transition smooth. Many of the core concepts are familiar, but Java’s structure, typing system, and disciplined syntax give it a character of its own.

Java rewards clear thinking and organized design. It expects you to define your ideas precisely, but once you learn its rhythm, it helps you build programs that scale easily from small scripts to large applications. This book focuses on that balance between simplicity and structure, showing how to use Java’s features confidently, without getting lost in jargon or unnecessary complexity.

If you are new to programming, you will also find that Java is an excellent first language. Its strict rules about typing, scope, and structure help you develop good habits from the start, and its built-in libraries let you accomplish a great deal with concise, readable code. Each concept in this book is introduced gently, with examples that build from simple to practical, so you can follow along even if this is your first experience writing code.

Whether you are a student learning Java for coursework, a professional adding it to your skill set, or a self-taught programmer exploring a new platform, this book will guide you through the essentials of the language and its modern ecosystem. Every topic is explained in plain language, illustrated with short, focused examples, and connected to the bigger picture of how real programs are written and maintained.

What Java is and why it matters

Java is a high-level, general-purpose programming language created to make software portable, secure, and dependable across platforms. From its first release in 1995, its philosophy has been simple: write the code once, then run it anywhere a Java Virtual Machine (JVM) exists. That principle, known as platform independence, made Java the first language to achieve widespread, practical cross-platform development, an achievement that still defines its identity today.

Unlike languages that compile directly to machine code, Java compiles to bytecode, an intermediate form that runs inside the JVM. This approach lets the same program run unchanged on Windows, macOS, Linux, and many other systems. The JVM also manages memory automatically through garbage collection, reducing entire categories of programming errors and freeing developers to focus on logic rather than low-level housekeeping.

Another key reason Java has endured is its balance between simplicity and depth. The language was designed to be familiar to anyone who has used C-style syntax, yet it removed unsafe features like manual pointer manipulation and multiple inheritance of implementation. It enforces a clear object-oriented structure, so every piece of code lives within a class and follows predictable, readable patterns. As Java evolved, it gained modern features such as generics, annotations, lambda expressions, records, and modularity, extending its power while keeping its design consistent.

Today, Java runs on billions of devices and underpins much of the world’s software infrastructure. It powers enterprise systems, Android applications, data platforms, and cloud backends. Its standard library and enormous open-source ecosystem make it suitable for almost any domain, from small tools to distributed systems serving millions of users. Beyond its technology, Java’s greatest strength is its stability: code written years ago can often still compile and run with little or no modification.

For learners and professionals alike, Java represents a dependable skill that bridges theory and practice. Understanding Java means understanding how structured, strongly typed languages organize complexity. Once you know how Java works, you gain insight into a wide range of other modern languages that draw on its design.

Versions and setup

At the time of writing, the main Long-Term Support (LTS) version of Java is Java 25, representing the modern era of the language: stable, fully compatible with past code, and enhanced with new tools and syntax that simplify development. Unless you are maintaining legacy systems, you should begin with Java 25 (or newer) to take advantage of current language features and performance improvements.

Installing Java is straightforward. The most common distribution is the Open Java Development Kit (OpenJDK), which is completely free and maintained by the open-source community alongside vendors such as Oracle, Amazon, and Eclipse. You can download the latest LTS or current release for your platform directly from the official source: jdk.java.net

Each installation includes the Java compiler (javac) and runtime environment (java), which together let you compile and execute Java programs. Once installed, you can verify your setup from a terminal or command prompt:

java -version
javac -version

If both commands print version information, your environment is ready. You may also wish to install an Integrated Development Environment (IDE) such as one of those listed following. These tools provide syntax highlighting, autocompletion, project management, and integrated build support, all of which make development smoother and faster:

• IntelliJ IDEA: jetbrains.com/idea
• Eclipse: eclipseide.org
• VS Code (with Java extension pack): code.visualstudio.com/docs/java/extensions

Because the Java Platform is designed to be consistent across operating systems, your workflow will look nearly identical whether you use Windows, macOS, or Linux. You create your source file, compile it into bytecode, and run it under the JVM. The same steps apply regardless of where the program is executed, which is one reason Java became such a durable choice for cross-platform software.

Most developers also configure an environment variable named JAVA_HOME to point to their JDK installation directory. This makes it easier for build tools like Maven or Gradle to locate the compiler automatically. Your IDE can usually detect the JDK without manual setup, but defining JAVA_HOME ensures compatibility across different systems and command-line tools.

Compiling and running your first program

Once Java is installed and your environment is set up, you are ready to write your first program. Java code is written in plain text files that end with the .java extension. Each file contains one or more classes, and the file name must match the name of the public class it defines. This rule helps Java locate the correct entry point when compiling and running code.

To begin, create a new file named HelloJava.java in your working folder and open it in any text editor or IDE. Enter the following code:

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

This short program defines a class named HelloJava containing a single method called main. The main() method is special, since it is where every Java application begins execution. The line inside it calls System.out.println(), which prints a message followed by a line break to standard output.

To compile the program, open a terminal or command prompt in the same folder and run:

javac HelloJava.java

If there are no errors, the compiler produces a file named HelloJava.class in the same directory. This file contains the Java bytecode, an intermediate format executed by the Java Virtual Machine (JVM). To run the compiled program, type:

java HelloJava

You should see the following output:

Hello, Java!

When you run a program with the java command, you do not include the .class extension. The JVM automatically looks for that file and executes the compiled bytecode within it.

Many developers prefer to run Java programs directly from an IDE, where compilation and execution happen automatically with a single click. However, learning how to compile and run programs manually helps you understand how the toolchain works and ensures that you can always build and execute code from any environment.

Editing, formatting, and code style

Every programming language has its own visual rhythm, and Java’s is deliberate, structured, and designed for clarity. Following consistent formatting makes your code easier to read, debug, and share with others. Although the compiler ignores whitespace and indentation, human readers do not, so treat style as a form of communication.

Java source code is organized into classes, methods, and blocks, each enclosed in braces ({…}). Consistent indentation and spacing make these structures clear at a glance. The common convention is to use two (as in these examples) or four spaces for indentation (never tabs), with braces placed on their own lines or aligned with the opening statement. Both approaches are valid, but the key is consistency throughout your codebase.

// Example of standard Java/C style
public class Example {
  public static void main(String[] args) {
    int sum = 3 + 4;
    System.out.println("The sum is " + sum);
  }
}

// Example of less used Allman style
public class Example
{
  public static void main(String[] args)
  {
    int sum = 3 + 4;
    System.out.println("The sum is " + sum);
  }
}

Class names use PascalCase (also known as UpperCamelCase), method and variable names use camelCase, and constants use UPPER_CASE. These patterns are followed across nearly all Java projects, making code predictable and familiar to other developers.

class DataProcessor {
  static final int MAX_SIZE = 100;
  private int itemCount;

  public void addItem() {
    itemCount++;
  }
}

Line length should generally stay under about 100 characters, and blank lines can be used sparingly to separate logical sections of code. Comments begin with // for single lines, or /* … */ for multiple lines. For documentation, Java uses Javadoc comments (/** … */), which can be processed into formatted reference pages. For example:

/**
 * Returns the larger of two numbers.
 * @param a The first value
 * @param b The second value
 * @return The greater of a or b
 */
public static int max(int a, int b) {
  return (a > b) ? a : b;
}

Modern Java development environments also perform linting, which is the automatic checking of potential issues like unused variables, missing documentation, or unsafe type conversions. These checks encourage clean, maintainable code and help you learn good practices as you go.

Chapter 2: Foundations of the Java Language

Every programming language has its own internal logic; its way of expressing ideas through structure and rules. Java’s logic is grounded in clarity, order, and predictability. It was designed to help programmers think in terms of classes, objects, and strict type boundaries, while still feeling familiar to anyone who has worked with other C-like languages.

At its heart, Java encourages you to write code that is both explicit and self-explanatory. Its syntax may appear formal at first, but that discipline pays off in code that scales gracefully and remains understandable even after years of maintenance. Each program has a clear entry point, each variable a defined type, and each class a distinct purpose within a hierarchy of behavior and inheritance.

Understanding the foundations of Java means understanding how it thinks about structure. The language expects everything to live inside a class, and every piece of code to follow predictable rules about scope, access, and typing. This may feel more constrained than dynamically typed languages, but those constraints provide the consistency that makes large-scale Java systems reliable and maintainable.

This chapter introduces the building blocks that define how Java code works and how programs are interpreted by the Java Virtual Machine. You will learn how statements and expressions form the core of Java’s logic, how identifiers and variables are defined and scoped, and how primitive types, constants, and naming conventions shape the rhythm of the language. Together, these ideas create the framework upon which every Java application is built.

By mastering these fundamentals, you will develop an instinct for how Java organizes data and behavior, and why its design has remained steady for decades. Once these core principles feel natural, the rest of the language (its objects, generics, exceptions, and concurrency) will make far more sense, because they all follow the same consistent foundation introduced here.

Statements, expressions, and blocks

Every Java program is built from statements and expressions, the smallest units of meaning in the language. Understanding how these pieces interact is essential to reading and writing Java fluently. A statement performs an action. An expression produces a value. Together, they form the logical rhythm that drives all program flow.

Expressions

An expression is any piece of code that evaluates to a value. It can be as simple as a literal number or as complex as a nested method call. Expressions appear inside statements, parameters, and control structures. They do not perform actions on their own. Rather they simply compute and return something that can be used elsewhere.

int total = 3 + 4;          // An expression
boolean ready = total > 5;  // An expression
System.out.println(total);  // An expression used as an argument

Java evaluates expressions in a defined order, respecting operator precedence and parentheses. Each expression produces a value whose type is known at compile time. This predictability is part of Java’s static type system, ensuring that incompatible operations (like adding a number to a string) are caught before the program runs.

Statements

A statement is a complete instruction that tells the Java Virtual Machine to do something. Statements usually end with a semicolon (;) and can include expressions as part of their structure. Assignment, method calls, and control flow instructions like if and while are all statements.

int count = 0;              // declaration statement
count++;                    // expression statement
System.out.println(count);  // method call statement

In Java, each statement executes in sequence unless altered by control flow. Statements can appear alone or be grouped together into larger structures called blocks.

Blocks

A block is a group of one or more statements enclosed in braces ({…}). Blocks define scope, or regions of code where variables exist and can be accessed. They are used in method bodies, control structures, and class definitions. For example:

if (count > 0) {
  System.out.println("Positive count");
  count--;
}

Here, the two statements inside the braces form a block that executes only if the condition is true. Variables declared within a block exist only inside that block and are discarded once it ends.

Declarations vs. executable statements

Java distinguishes between declarations (which define variables, methods, or classes) and executable statements (which perform actions when the program runs). This separation makes Java’s flow easy to follow and its structure consistent. Declarations tell the compiler what exists; executable statements tell the runtime what to do.

Comments and documentation

Java code is meant to be read by people as well as compiled by the machine. Comments and documentation are how you explain intent, clarify design choices, and help future readers (including your future self) understand why the code was written the way it was. They never affect program execution but play an essential role in maintainability and teamwork.

Single-line and multi-line comments

Single-line comments begin with // and extend to the end of the line. They are ideal for short notes, explanations, or temporary reminders. Multi-line comments begin with /* and end with */, allowing you to span several lines or temporarily disable blocks of code during testing.

// This is a single-line comment
int count = 5; // You can also place it at the end of a statement

/*
  This is a multi-line comment.
  It can span several lines and is often used
  for larger explanations or code sections.
*/

Good comments explain why something is done, not what the code does. The code itself should make the “what” clear through naming and structure. Over-commenting every line makes code harder to read rather than easier.

Javadoc comments

Java introduced a formal documentation system called Javadoc, which allows you to create rich, searchable API documentation directly from the source code. A Javadoc comment begins with /** and ends with */. It is placed immediately before a class, method, or field declaration.

/**
 * Calculates the area of a rectangle.
 * @param width  The width of the rectangle
 * @param height The height of the rectangle
 * @return The area as an integer
 */
public int area(int width, int height) {
  return width * height;
}

Each tag (such as @param and @return) provides structured information that can be turned into formatted documentation by running the javadoc tool, which generates HTML pages for your classes and methods. This makes Javadoc comments part of the official interface for any library or project.

Best practices for documentation

• Write concise, accurate summaries in the first sentence of each Javadoc block.
• Keep parameter and return descriptions clear and free of repetition.
• Update comments whenever code changes, as outdated documentation can be worse than none.
• Reserve detailed explanations for complex logic or algorithms that cannot be made clearer through naming alone.

Many IDEs can generate Javadoc templates automatically as you type, prompting you to fill in parameter and return descriptions. For public APIs and reusable code, consistent Javadoc use is a sign of professional quality.

Identifiers, keywords, and naming rules

In Java, every variable, class, method, and constant is identified by a name called an identifier. Identifiers give structure and meaning to code, helping both the compiler and the reader understand what each element represents. Alongside these identifiers, Java reserves certain keywords that have predefined meanings and cannot be used as names. Together, they form the basic vocabulary of the language.

Identifiers

An identifier is a name you choose for something you define, such as a class, variable, or method. Identifiers must follow a few simple rules:

• They may contain letters, digits, underscores (_), or dollar signs ($).
• They must begin with a letter, underscore, or dollar sign, not a digit.
• They are case-sensitive: total, Total, and TOTAL are all distinct names.
• They cannot be the same as any reserved Java keyword.

Valid examples include:

int totalCount;
String customerName;
double _balance;
boolean $debugMode;

Although the dollar sign is technically allowed, it is rarely used except by tools that generate code automatically. For readability, prefer simple, descriptive names made of letters and digits.

Keywords

Java reserves a set of words for the language itself. These keywords define syntax and structure, and cannot be redefined or used as identifiers. Examples include class, public, static, void, if, else, return, for, switch, and many others.

A full list of keywords (as of Java 25) includes:

abstract  assert  boolean  break  byte  case  catch  char  class
const  continue  default  do  double  else  enum  extends  final
finally  float  for  if  implements  import  instanceof  int
interface  long  native  new  package  private  protected  public
return  short  static  strictfp  super  switch  synchronized  this
throw  throws  transient  try  void  volatile  while

Java also reserves true, false, and null as literals that cannot be used as identifiers. In addition, newer versions may introduce contextual keywords, which are words that behave like keywords only in specific situations (for example, var or yield).

Naming conventions

Beyond the basic rules, Java developers follow consistent conventions to make code readable and predictable. These conventions are not enforced by the compiler but are considered standard practice throughout the Java ecosystem:

• Classes and interfaces: Use PascalCase, where each word begins with a capital letter, such as DataProcessor or UserProfile.
• Methods and variables: Use camelCase, where the first word is lowercase, and subsequent words are capitalized, such as calculateTotal() or itemCount.
• Constants: Use UPPER_CASE_WITH_UNDERSCORES, such as MAX_SIZE or DEFAULT_TIMEOUT.
• Packages: Use all lowercase, often reversed domain notation, such as com.example.project.

package com.example.store;

public class Product {
  private double price;
  public static final double TAX_RATE = 0.2;

  public double calculateTotal() {
    return price + (price * TAX_RATE);
  }
}

These conventions help others immediately recognize the role of each name in your program. When everyone follows the same patterns, codebases become easier to navigate and maintain.

Primitive types and literals

All data in Java belongs to one of two broad categories: primitive types or reference types. Primitive types store simple values directly; numbers, characters, and truth values. Reference types store references to objects in memory. This section focuses on the eight primitive types, which form the foundation of all data handling in Java.

The eight primitive types

Java defines exactly eight primitive data types, each with a fixed size and specific range of values. This consistency ensures that Java behaves the same way across all platforms.

Because Java defines exact sizes for each type, a program that runs on one system behaves identically on another. This predictability is part of what makes Java portable across platforms and architectures.

Literals

A literal is a fixed value written directly into your code. Java supports several literal forms for each primitive type.

int count = 10;           // integer literal
long distance = 45_000L;  // underscores improve readability
double price = 19.99;     // decimal literal
float ratio = 0.75F;      // float literal requires F
char letter = 'J';        // single character literal
boolean success = true;   // boolean literal

Numeric literals can also be written in different bases:

int hex = 0xFF;    // hexadecimal (255)
int bin = 0b1010;  // binary (10)
int oct = 012;     // octal (10)

Underscores within numeric literals make large numbers easier to read, but they have no effect on value:

long population = 7_950_000_000L;

Type ranges and overflow

Each primitive type has a defined minimum and maximum value. When a value goes beyond that range, it overflows or underflows, wrapping around instead of producing an error.

byte b = 127;
b++;  // wraps around to -128

This behavior can lead to subtle bugs if not expected. Java does not raise an exception for overflow, so it is up to the programmer to ensure calculations stay within range or to use larger data types when necessary.

Default values

When primitive fields are declared inside a class but not initialized, Java assigns them default values automatically. Local variables inside methods, however, must be explicitly initialized before use.

This behavior simplifies class construction and ensures all fields start with predictable values.

Variables, constants, and scope

Variables are the named storage locations that hold your program’s data. Each variable in Java has a specific type, a name, and a lifetime. Understanding how variables are declared, how long they exist, and where they can be accessed (known as their scope) is essential to writing reliable and maintainable programs.

Declaring and initializing variables

Every variable in Java must be declared with a type before it can be used. The declaration tells the compiler what kind of data the variable will hold, allowing it to check that only valid operations are performed on it. You can declare and initialize a variable in one statement or separately:

int count;   // declaration
count = 10;  // initialization

String name = "Java";  // declaration and initialization together

Java also allows multiple variables of the same type to be declared on one line, but this is best reserved for simple cases:

int x = 1, y = 2, z = 3;

Variable types and mutability

Variables can represent different kinds of data. Primitive variables store values directly (like numbers or characters), while reference variables store a reference to an object in memory. Both kinds of variables can be reassigned unless declared as constants using the final keyword.

int score = 100;
score = 120;  // allowed

final int MAX_SCORE = 200;
MAX_SCORE = 250;
// error: cannot assign a value to final variable

Declaring a variable as final makes it immutable, such that it cannot be reassigned once a value is set. Constants are typically written in uppercase letters with underscores separating words.

Variable scope

The scope of a variable defines where it can be accessed within a program. In Java, scope is determined by the block structure created with braces ({…}). A variable declared inside a block exists only within that block and is destroyed when the block ends.

public class ScopeExample {
  public static void main(String[] args) {
    int outer = 10;
    {
      int inner = 5;
      System.out.println(outer + inner);
      // both visible here
    }
    // System.out.println(inner);
    // error: inner no longer exists
  }
}

This block-based scoping helps prevent naming conflicts and keeps variables local to where they are needed. Variables declared at the class level (outside any method) are known as fields, while those declared inside methods or blocks are local variables.

Local, instance, and class variables

Java defines three main categories of variables, based on where they are declared:

• Local variables these are declared inside methods or blocks and exist only during execution of that code.
• Instance variables these are declared within a class but outside any method; each object of that class has its own copy.
• Class variables these are declared with the static keyword; shared among all instances of the class.

public class Counter {
  static int totalCount = 0;  // class variable
  int value;                  // instance variable

  public Counter(int start) {
    value = start;
    totalCount++;
  }

  public void increment() {
    int step = 1;             // local variable
    value += step;
  }
}

Here, totalCount belongs to the class itself, value belongs to each individual object, and step exists only while the increment() method runs.

Variable lifetime

Each variable’s lifetime is tied to its scope. Local variables exist only while their method or block executes. Instance variables persist as long as the object they belong to remains in memory. Class variables persist for as long as the program or class loader keeps the class loaded.

Java’s garbage collector automatically reclaims memory when objects are no longer referenced. You never need to manually free variables, but you should always limit their scope and lifetime to what is necessary. Doing so keeps your programs efficient and reduces the chance of errors.

Chapter 3: Operators and Expressions

Operators are the symbols and keywords that allow you to perform calculations, make comparisons, and manipulate data in Java. They are the building blocks of expressions, which in turn are the heart of almost every statement you write. Understanding how operators work, how they interact, and how expressions are evaluated is essential to mastering the flow of logic in any Java program.

In this chapter you will explore Java’s full set of operators: arithmetic and assignment, comparison and logical, bitwise and shift, and the rules that determine how they combine through precedence and associativity. You will also learn how Java automatically promotes types during mixed calculations and how to control conversions explicitly through casting.

Operators work on values and variables, while expressions combine them into units of meaning that the compiler can evaluate. For example, the simple line int total = 3 + 4; contains both assignment and arithmetic operators, forming an expression that computes a value and stores it in a variable. Java evaluates such expressions from left to right according to strict precedence rules, ensuring consistent and predictable behavior across all platforms.

As you progress through this chapter, you will see how operators shape both the arithmetic and logical structure of programs. By the end, you will not only know what each operator does, but also how to combine them safely, read them fluently, and recognize subtle effects such as type promotion and evaluation order that influence every Java expression you write.

Arithmetic and assignment operators

Arithmetic and assignment operators are the core tools for performing mathematical operations and storing results in variables. They handle everything from simple addition and subtraction to compound updates that combine computation and assignment in one concise expression.

Basic arithmetic operators

Java supports the standard arithmetic operators found in most programming languages. These work on numeric types such as int, double, float, and long.

Division between integers always produces an integer result. If either operand is a floating-point value, the result will be a floating-point number:

int a = 5 / 2;      // 2
double b = 5 / 2.0; // 2.5

Unary operators can also change the sign or increment values directly:

The prefix and postfix forms of ++ and -- differ in when the value changes. Prefix updates the variable before its value is used; postfix updates it after.

int x = 5;
System.out.println(++x); // 6 (prefix: increments, then prints)
System.out.println(x++); // 6 (postfix: prints, then increments)
System.out.println(x);   // 7

Assignment operators

Assignment operators store values in variables. The simplest is the = operator, which copies the result of an expression into a variable. Compound assignment operators combine an operation with assignment, simplifying repeated updates.

Compound assignments are especially useful for counters, accumulators, or iterative calculations.

int total = 10;
total += 5;  // total = 15
total *= 2;  // total = 30

Order of evaluation

Arithmetic expressions are evaluated according to standard mathematical precedence. Multiplication, division, and modulus come before addition and subtraction. Parentheses can be used to override this order.

int result = 2 + 3 * 4;    // 14
int fixed  = (2 + 3) * 4;  // 20

Assignments, by contrast, are evaluated from right to left, meaning the value on the right-hand side is always computed before it is stored in the variable on the left.

int x = 5;
int y = x = 10;  // both x and y become 10

Comparison and logical operators

Comparison and logical operators allow Java programs to make decisions. They evaluate relationships between values and combine true or false results into meaningful conditions for control structures such as if, while, and for. Together, they form the foundation of conditional logic.

Comparison operators

Comparison (or relational) operators compare two values and produce a boolean result, either true or false. These operators can be used with numeric, character, and some object types such as String (when compared with specific methods like equals()).

These operators work reliably for primitive types. When comparing object references (for example, two String values), == checks whether both references point to the same object in memory, not whether their contents match. To compare object content, use the equals() method instead.

String a = "Java";
String b = new String("Java");

System.out.println(a == b);       // false (different objects)
System.out.println(a.equals(b));  // true  (same text)

Logical operators

Logical operators combine or invert boolean values. They are used to form complex conditions in control flow statements. Each operator returns true or false depending on the logical relationship between operands.

Java uses short-circuit evaluation for && and ||. This means that evaluation stops as soon as the outcome is known. For example, in (x > 0 && y / x > 2), if x is not greater than zero, the second expression is never executed, preventing a potential division-by-zero error.

int x = 0;
int y = 5;
if (x != 0 && y / x > 1) {
  System.out.println("Safe to divide");
}
// No error because the second condition is skipped

Combining comparison and logic

Conditions often combine comparison and logical operators to create meaningful decisions. Parentheses can group expressions and control evaluation order, improving clarity.

int age = 25;
boolean hasLicense = true;

if (age >= 18 && hasLicense) {
  System.out.println("You may drive.");
}

Logical operators can also be nested or chained to handle more complex decision trees:

boolean eligible = (age >= 18 && age <= 70) || hasLicense;

This expression evaluates to true if the person is between 18 and 70 years old, or already holds a valid license.

Ternary conditional operator

The ternary operator (?:) is a compact form of if that selects one of two values based on a condition. It is useful for short expressions where full control structures would add clutter.

int age = 20;
String access = (age >= 18) ? "granted" : "denied";
System.out.println("Access " + access);

The expression before the question mark is the condition. If it evaluates to true, the expression immediately after the ? is chosen; otherwise, the one after the : is used.

Bitwise and shift operators

Bitwise and shift operators work at the level of individual bits within integer types such as byte, short, int, and long. They are used for low-level programming tasks, including data encoding, cryptography, graphics, and performance-sensitive computations. Although they may seem specialized, understanding them deepens your knowledge of how Java represents numbers internally.

Bitwise operators

Bitwise operators treat their operands as binary values and perform logical operations on each corresponding bit. The result is another integer whose bits reflect the chosen operation.

To understand how these work, it helps to visualize binary representations:

int a = 5;  // 0101
int b = 3;  // 0011

System.out.println(a & b); // 0001 → 1
System.out.println(a | b); // 0111 → 7
System.out.println(a ^ b); // 0110 → 6
System.out.println(~a);    // 1010 → -6 (two’s complement)

These operations are purely bitwise and do not perform logical short-circuiting as && and || do. Each bit position is compared independently.

Bit masking and flags

A common use of bitwise operators is creating and testing bit masks. A mask is an integer where specific bits represent on/off states. You can combine masks with |, test with &, and toggle with ^.

final int READ  = 1;                            // 0001
final int WRITE = 2;                            // 0010
final int EXEC  = 4;                            // 0100

int permissions = READ | WRITE;                 // 0011

boolean canWrite = (permissions & WRITE) != 0;
System.out.println(canWrite);                   // true

permissions ^= WRITE;                           // toggle WRITE
System.out.println((permissions & WRITE) != 0); // false

By combining bit masks, you can store multiple binary states efficiently within a single variable. This approach is common in systems and game programming, where performance and memory layout are critical.

Shift operators

Shift operators move the bits of a number left or right. Shifting left effectively multiplies by powers of two, while shifting right divides by powers of two. Java provides three shift operators:

The left shift (<<) multiplies by two for each shift position, while the arithmetic right shift (>>) divides by two and keeps the sign for negative numbers. The logical right shift (>>>) fills empty bits with zeros, treating the number as unsigned.

int n = 5;   // 00000101
System.out.println(n << 1);  // 10  (00001010)
System.out.println(n >> 1);  // 2   (00000010)

int m = -8;  // 11111000
System.out.println(m >> 2);  // -2  (11111110)
System.out.println(m >>> 2); // 1073741822 (sign bit cleared)

Practical uses of bitwise operations

Bitwise and shift operations appear throughout performance-oriented and embedded Java applications. Some common examples include:

• Flags and configuration values stored compactly in a single integer.
• Hash functions that mix and combine bits for uniform distribution.
• Graphics operations where pixel colors or channel values are packed into integers.
• Compression or encoding schemes that manipulate bits directly.

// Combine RGB color values into a single 32-bit integer
int r = 120, g = 200, b = 255;
int color = (r << 16) | (g << 8) | b;
System.out.printf("0x%06X%n", color); // 0x78C8FF

Operator precedence and associativity

When an expression contains multiple operators, Java follows a strict set of rules to determine the order in which operations are evaluated. These rules are known as operator precedence. Operators with higher precedence are evaluated before those with lower precedence. When operators have the same precedence, associativity determines the direction in which they are applied (left-to-right or right-to-left).

Understanding precedence and associativity ensures that expressions behave as intended. Without parentheses to clarify order, even a small assumption can lead to unexpected results.

int result = 2 + 3 * 4;   // 14, not 20 (multiplication first)
int fixed  = (2 + 3) * 4; // 20 (parentheses change the order)

Highest to lowest precedence

Associativity rules

Most operators in Java are evaluated from left to right. However, a few (notably assignment and the ternary conditional operator) are right-associative. The following table summarizes the general pattern:

Right-associative operators are evaluated from the innermost right-hand expression first. For example:

int a = 2;
int b = 3;
int c = 4;
int result = a = b = c;  // assigns 4 to b, then to a
System.out.println(a);   // 4

Parentheses and clarity

Even though Java’s precedence rules are consistent, experienced developers rely on parentheses to make code readable. This not only avoids mistakes but also signals intention clearly to others maintaining the code.

boolean test = (x > 5 && y < 10) || (z == 0);

Such grouping makes the logic obvious at a glance. The compiler would interpret the same expression correctly even without parentheses, but human readers might not.

Type promotion and casting

When expressions in Java involve values of different types, the language automatically converts them to a common type before performing the operation. This process is called type promotion. It ensures that the result is accurate and consistent, even when mixing integers and floating-point numbers. When automatic promotion is not what you want, you can use casting to explicitly convert one type to another.

Automatic type promotion

Java promotes smaller numeric types to larger ones to prevent data loss during operations. For example, if you add an int to a double, the int is automatically promoted to double before the addition occurs. The general promotion order (from smallest to largest) is:

byte → short → int → long → float → double

Character values are also promoted to integers when used in arithmetic expressions, since char is stored as a 16-bit Unicode number.

int result = 'A' + 1;  // 'A' is 65 → result is 66

When multiple different types appear in a single expression, Java promotes them to the widest type involved:

int i = 5;
double d = 2.5;
double total = i + d;  // int promoted to double

Integer division and promotion

When dividing integers, Java performs integer division even if the result is not whole. To obtain a floating-point result, at least one operand must be a floating-point type.

int a = 5, b = 2;
System.out.println(a / b);    // 2 (integer division)
System.out.println(a / 2.0);  // 2.5 (automatic promotion to double)

This rule is important to remember when writing formulas, as the wrong type can silently change the outcome of your calculations.

Explicit casting

Casting is the process of manually converting one type into another. It is used when you want to control how data is interpreted or when you must narrow a value to a smaller type. Casting is written by placing the target type in parentheses before the value or expression.

double value = 9.8;
int rounded = (int) value;  // converts 9.8 → 9

Because narrowing conversions can lose data, Java requires an explicit cast to make sure you are aware of the risk.

long big = 12345678900L;
int small = (int) big;      // value truncated to fit into int
System.out.println(small);  // unpredictable numeric result

Casting between object types

In addition to primitive conversions, Java allows reference casting between related object types. This occurs within inheritance hierarchies, where a subclass object can be treated as its superclass (upcasting) or vice versa (downcasting).

Object obj = "Java";         // upcast: String → Object
String text = (String) obj;  // downcast: Object → String

Upcasting is always safe because every subclass instance is also an instance of its superclass. Downcasting, however, must be done carefully. If the object is not actually an instance of the target type, a ClassCastException will occur at runtime.

Object num = Integer.valueOf(42);
String s = (String) num;  // runtime error

Type inference with var

Since Java 10, the var keyword allows the compiler to infer a variable’s type from its initializer. It does not change the rules of promotion or casting, but it makes declarations more concise while maintaining type safety.

var count = 10;       // inferred as int
var name = "Java";    // inferred as String
var ratio = 5.0 / 2;  // inferred as double

The inferred type is still static and fixed at compile time. You cannot later assign a different type to the same variable.

Together, type promotion, casting, and inference form the backbone of Java’s strong and predictable type system. They let the compiler detect errors early while giving developers the control needed for precision when it matters.

Chapter 4: Control Flow

Programs rarely run in a straight line from top to bottom. Most of the time, they make decisions, repeat actions, and handle exceptions depending on conditions that arise during execution. This ability to branch, loop, and react dynamically is what makes programming expressive. In Java, these mechanisms are known collectively as control flow.

Control flow structures let you determine which parts of your code run and when. You can execute code only if certain conditions are met, repeat sections until a task is complete, or skip specific parts entirely. Java provides several categories of control flow statements, including if and else constructs, switch expressions, looping structures like for and while, and keywords that alter execution such as break and continue.

At a higher level, control flow is how logic takes shape in a program. It transforms raw instructions into behavior: testing data, reacting to input, and producing meaningful results. Even a simple decision, such as whether a number is positive or negative, is an example of control flow in action.

if (number > 0) {
  System.out.println("Positive");
} else {
  System.out.println("Non-positive");
}

This short code fragment demonstrates one of Java’s most common patterns; selective execution based on a condition. As programs grow, you will combine these patterns into loops, nested branches, and structured exception handling to manage complex operations predictably.

This chapter explores the main tools that shape program logic. You will learn how to make decisions with if and else, simplify them with ternary expressions, use pattern matching with switch, control repetition with loops, and handle exceptions gracefully. Each of these structures builds on the same foundation of truth values and expression evaluation introduced earlier, turning simple statements into structured, adaptable programs.

if, else if, and else constructs

The if statement is the foundation of all decision making in Java. It allows your program to execute different code depending on whether a condition evaluates to true or false. Along with its optional else if and else branches, it lets you express multiple possible paths of execution clearly and predictably.

The basic if statement

An if statement tests a condition, which must evaluate to a boolean value (true or false). If the condition is true, the code inside the block ({…}) executes; if false, it is skipped.

int temperature = 30;

if (temperature > 25) {
  System.out.println("It's warm today.");
}

Here, the message prints only if the condition temperature > 25 is true. If the condition is false, the statement inside the braces is ignored and execution continues after the if block.

Adding an else branch

The else clause provides an alternative path when the condition of an if statement is false. It ensures that one and only one of the two blocks executes.

if (temperature > 25) {
  System.out.println("It's warm today.");
} else {
  System.out.println("It's cooler today.");
}

Only one branch executes per evaluation. The first block runs if the condition is true; otherwise, the else block runs. Both blocks are mutually exclusive.

Using else if chains

When you need to test multiple related conditions, you can chain them together with else if. Each condition is checked in sequence until one evaluates to true; remaining branches are skipped once a match is found.

int score = 85;

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

These conditional chains are read top to bottom. Only the first true condition’s block executes, even if later ones would also be true.

Nested if statements

You can place one if statement inside another to test multiple layers of logic. This is called nesting. While sometimes necessary, too many nested conditions can make code difficult to read.

boolean loggedIn = true;
boolean admin = false;

if (loggedIn) {
  if (admin) {
    System.out.println("Welcome, administrator.");
  } else {
    System.out.println("Welcome, user.");
  }
} else {
  System.out.println("Please log in first.");
}

Here, the outer if checks whether a user is logged in, and the inner one checks whether that user is an administrator. Each level of logic narrows the possible outcomes.

Boolean expressions and best practices

Any expression that returns a boolean value can be used as an if condition. This includes comparisons, method calls, and logical combinations.

if (ready && hasPermission()) {
  executeTask();
}

Because Java’s if expects a boolean, there is no need to compare directly to true or false. For example, instead of writing if (ready == true), simply write if (ready).

Switch expressions and pattern matching

When a variable or expression can take on multiple possible values, a long chain of if and else if statements can become repetitive. Java’s switch construct provides a clearer way to select one of several actions based on a single value. Modern Java also extends this idea with switch expressions and pattern matching, which make branching more concise and expressive.

Traditional switch statements

The classic switch statement tests a single expression against a list of constant cases. When a match is found, execution continues from that point until a break statement is encountered, or until the switch block ends.

int day = 3;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  default:
    System.out.println("Unknown day");
}

Each case must be a constant expression and of the same type as the value being switched on. The default label is optional and executes when no other case matches.

Enhanced switch syntax (Java 14+)

Modern Java introduces a cleaner form of switch that avoids fall-through and can be used as an expression that returns a value. This version uses the -> symbol instead of :, and each branch ends automatically.

int day = 3;
String name = switch (day) {
  case 1 -> "Monday";
  case 2 -> "Tuesday";
  case 3 -> "Wednesday";
  default -> "Unknown";
};
System.out.println(name);

This form eliminates the need for break statements, prevents unintended fall-through, and can directly assign or return a value.

String category = switch (score / 10) {
  case 10, 9 -> "Excellent";
  case 8 -> "Good";
  case 7 -> "Fair";
  default -> "Needs improvement";
};

Using yield for multi-statement cases

Sometimes a case requires more than one line of code to produce a result. In a switch expression, you can use yield to return a value from a block enclosed in braces.

int month = 2;
int days = switch (month) {
  case 1, 3, 5, 7, 8, 10, 12 -> 31;
  case 4, 6, 9, 11 -> 30;
  case 2 -> {
    boolean leap = true;
    yield leap ? 29 : 28;
  }
  default -> 0;
};
System.out.println(days);

The yield keyword signals the value that the switch expression should produce for that case. It replaces older workarounds that required temporary variables.

Pattern matching in switch (Java 17+)

From Java 17 onward, switch supports pattern matching, a powerful feature that tests both type and value simultaneously. This allows more expressive branching when dealing with objects of different types.

Object obj = "Hello";

String result = switch (obj) {
  case String s -> "String of length " + s.length();
  case Integer i -> "Integer value " + i;
  case null -> "Null reference";
  default -> "Unknown type";
};

System.out.println(result);

Each case can specify both a type and an identifier, letting you immediately use the casted variable within the case block. This avoids the need for separate instanceof checks and manual casts.

When to use switch

Use switch when you need to choose between several fixed, distinct options based on a single expression. It is ideal for enumerations, menu systems, or data categories, and modern syntax makes it both concise and expressive.

Day today = Day.FRIDAY;

String mood = switch (today) {
  case MONDAY -> "Focused";
  case FRIDAY -> "Excited";
  case SATURDAY, SUNDAY -> "Relaxed";
  default -> "Steady";
};

Loops: for, while, do while

Loops let your program repeat sections of code until a condition changes. They are essential for tasks like processing lists, reading files, performing calculations, or waiting for user input. Java provides three primary looping structures: for, while, and do-while. Each achieves repetition in a slightly different way but follows the same core idea, which is to execute a block of code multiple times while a condition remains true.

The while loop

The while loop evaluates its condition before each iteration. If the condition is true, the block executes. If false, the loop stops immediately.

int count = 0;

while (count < 3) {
  System.out.println("Count: " + count);
  count++;
}

Here, the code prints numbers from 0 to 2. The condition count < 3 is checked before each iteration, so if it is initially false, the loop body will never run.

The do while loop

The do-while loop is similar to while, except that the condition is tested after the body executes. This guarantees that the loop runs at least once, regardless of whether the condition is initially true or false.

int number = 0;

do {
  System.out.println("Number: " + number);
  number++;
} while (number < 3);

In this example, the loop prints Number: 0, Number: 1, and Number: 2. Even if the condition had been false from the start, the body would still execute once before stopping.

The for loop

The for loop is ideal when you know exactly how many times you need to repeat an action. It includes an initialization step, a loop condition, and an update expression, all written in one concise line.

for (int i = 0; i < 5; i++) {
  System.out.println("i = " + i);
}

The for statement performs these steps in order:

1. Initialize a counter variable (int i = 0).
2. Check the condition (i < 5).
3. If true, execute the loop body.
4. Update the counter (i++).
5. Repeat until the condition becomes false.

When the condition fails, execution continues after the loop block.

The enhanced for loop

Introduced in Java 5, the enhanced for loop (also known as the “for-each” loop) provides a simpler way to iterate over arrays and collections without using an index variable.

String[] names = { "Java", "Python", "C++" };

for (String name : names) {
  System.out.println(name);
}

This loop automatically retrieves each element in sequence. It is read-only. While it can access elements, it cannot modify the underlying collection structure directly.

Nested loops

Loops can be nested inside one another to perform repeated operations over multiple dimensions, such as iterating through a matrix or comparing every pair of items in a list.

for (int i = 1; i <= 3; i++) {
  for (int j = 1; j <= 2; j++) {
    System.out.println("i=" + i + ", j=" + j);
  }
}

This example prints each combination of i and j values. The outer loop controls the number of rows, while the inner loop controls the columns.

Infinite loops

A loop that never ends is called an infinite loop. While often a mistake, it can be useful in certain cases, such as event-driven programs or continuously running background tasks. To create one intentionally, use a condition that is always true.

while (true) {
  System.out.println("Running...");
  break;  // use break or another condition to exit
}

Every infinite loop must have a controlled exit path, such as a break statement or external event trigger. Otherwise, the program will continue indefinitely and consume system resources.

Loop control: break, continue, return

In addition to defining how loops begin and repeat, Java provides several keywords that let you control when and how they end. These are break, continue, and return. Each alters the normal flow of a loop in a specific way; stopping it, skipping an iteration, or exiting a method entirely. Used thoughtfully, they make loops more flexible and expressive.

The break statement

The break statement immediately terminates the nearest enclosing loop (or switch block). Program execution continues with the first statement after the loop.

for (int i = 0; i < 10; i++) {
  if (i == 5) {
    break;
  }
  System.out.println("i = " + i);
}
System.out.println("Loop ended");

This example prints values from 0 to 4, then exits the loop once i equals 5. The message “Loop ended” appears immediately after the break.

Labeled break statements

Java also allows labeled breaks, which can exit an outer loop directly from within a nested loop. To use one, place a label before the outer loop, followed by a colon, and refer to that label in the break statement.

outer:
for (int i = 1; i <= 3; i++) {
  for (int j = 1; j <= 3; j++) {
    if (i * j == 4) {
      break outer;  // exit both loops
    }
    System.out.println(i + " × " + j + " = " + (i * j));
  }
}
System.out.println("Exited outer loop");

Here, when the product of i and j equals 4, control jumps out of both loops. Without the label, only the inner loop would terminate.

The continue statement

The continue statement skips the rest of the current iteration and proceeds directly to the next one. It is useful when you want to ignore certain cases but keep the loop running.

for (int i = 1; i <= 5; i++) {
  if (i == 3) {
    continue;
  }
  System.out.println("i = " + i);
}

This prints 1, 2, 4, and 5. When i equals 3, the loop jumps immediately back to its condition check, skipping the print statement for that iteration.

Labeled continue statements

Like break, continue can also use labels to skip directly to the next iteration of an outer loop from within a nested one.

outer:
for (int i = 1; i <= 3; i++) {
  for (int j = 1; j <= 3; j++) {
    if (j == 2) {
      continue outer;  // skip to next outer iteration
    }
    System.out.println("i=" + i + ", j=" + j);
  }
}

Here, when j equals 2, control jumps to the next outer iteration of i, skipping the rest of both inner and outer loop bodies for that pass.

The return statement in loops

The return statement exits not just the loop but the entire method. It is often used when a specific result has been found and no further work is needed.

public static boolean containsZero(int[] numbers) {
  for (int n : numbers) {
    if (n == 0) {
      return true;  // exit method immediately
    }
  }
  return false;
}

In this example, the method stops as soon as a zero is found, avoiding unnecessary iterations. Once return executes, no further statements in the method are run.

Choosing between break, continue, and return

Although all three affect control flow, they serve distinct purposes:

• break ends the current loop or switch block.
• continue skips the current iteration and moves to the next.
• return exits the entire method immediately.

Used together, they allow fine-grained control over program execution. The key is clarity. Loops should read naturally, with interruptions only where they simplify logic or improve efficiency.

Basic exception handling

Even the most carefully written programs encounter unexpected situations—invalid input, missing files, network errors, or arithmetic problems such as division by zero. Java handles these events through a structured system called exception handling. Rather than letting a program crash when something goes wrong, you can detect and respond to problems gracefully using the try, catch, and finally blocks.

What exceptions are

An exception is a signal that something has interrupted normal program flow. When an exceptional condition occurs, Java creates an Exception object and throws it. If the exception is not handled, the program terminates and prints an error stack trace. Exception handling gives you a controlled way to catch and respond to these events instead of letting them propagate unchecked.

int result = 10 / 0;  // throws ArithmeticException
System.out.println("This line never runs");

Without handling, this division by zero stops the program immediately. With a proper try and catch, you can prevent termination and handle the issue safely.

Using try and catch

A try block wraps code that may generate an exception. One or more catch blocks follow it, each specifying the type of exception to handle. If a matching exception is thrown, the corresponding catch block executes; otherwise, the program ends with an error.

try {
  int result = 10 / 0;
  System.out.println("This line is skipped");
} catch (ArithmeticException e) {
  System.out.println("Cannot divide by zero.");
}
System.out.println("Program continues normally.");

Here, the ArithmeticException is caught, and the program continues without crashing. You can have multiple catch blocks to handle different exception types.

try {
  int[] data = {1, 2, 3};
  System.out.println(data[5]);
} catch (ArrayIndexOutOfBoundsException e) {
  System.out.println("Index out of range.");
} catch (Exception e) {
  System.out.println("General error: " + e.getMessage());
}

The finally block

The finally block contains code that always runs, whether or not an exception occurred. It is typically used to release resources such as files, network connections, or database handles.

try {
  System.out.println("Opening resource...");
  int value = 5 / 0;
} catch (ArithmeticException e) {
  System.out.println("Error: " + e.getMessage());
} finally {
  System.out.println("Closing resource.");
}

Even though the exception occurs, the finally block executes, ensuring the resource is closed properly. This helps prevent leaks and guarantees cleanup operations are always performed.

Nested and rethrown exceptions

Exception handling blocks can be nested, allowing more specific handling inside broader contexts. In some cases, you may want to rethrow an exception to signal that the error should be handled elsewhere.

try {
  try {
    int n = Integer.parseInt("abc");
  } catch (NumberFormatException e) {
    System.out.println("Invalid number format.");
    throw e;  // rethrow to outer handler
  }
} catch (Exception e) {
  System.out.println("Outer handler caught: " + e);
}

Here, the inner catch detects the specific error, while the outer one performs general handling or logging. This pattern keeps code modular and separates responsibilities.

Checked and unchecked exceptions

Java divides exceptions into two broad categories:

• Checked exceptions are verified at compile time. You must either handle them with try/catch or declare them with a throws clause. Examples include IOException and SQLException.
• Unchecked exceptions (also called runtime exceptions) occur during execution and do not need to be declared or caught. Examples include NullPointerException and ArithmeticException.

Unchecked exceptions usually represent programming errors, while checked ones often represent recoverable conditions that your program should anticipate.

The role of exception handling

As well as being about preventing crashes, exception handling is also about building predictable, resilient software. By isolating risky operations in try blocks and handling problems clearly, you ensure your program behaves consistently, even when something goes wrong.

try {
  readFile("data.txt");
  processData();
} catch (IOException e) {
  System.out.println("File error: " + e.getMessage());
} finally {
  System.out.println("Operation complete.");
}

This structure defines a clear beginning, middle, and end for potentially fragile operations. Later chapters will revisit exceptions in detail, exploring custom exception classes, propagation, and advanced handling patterns.

Chapter 5: Methods and Parameters

Methods are at the heart of every Java program. They define the specific actions an object or class can perform, encapsulating logic into reusable and well-named units. Each method represents a single task or idea, and together, methods form the vocabulary through which your program expresses behavior.

Java methods are similar to functions in other languages, but with an important distinction: every method belongs to a class. Even the main() entry point is simply a static method that happens to be called first. This object-centric approach ensures that every operation takes place in a clear structural context, whether at the instance or class level.

In this chapter you will learn how to define methods, declare parameters, return values, and control visibility with access modifiers. You will also see how Java handles argument passing, method overloading, and variable-length parameter lists. By the end, you will understand how to design methods that are concise, predictable, and easy to maintain.

Well-structured programs rely on clear, self-contained methods. Each one should do exactly one thing and do it well. When methods grow too large or try to handle too many tasks, they become harder to read, test, and reuse. Java’s method system encourages modular design, allowing complex behavior to emerge from small, well-defined building blocks.

Next, we will explore how to declare a method, define its body, and understand how parameters and return values flow between the caller and the method itself.

Declaring and defining methods

Every method in Java follows a strict structure that defines how it can be called and what it returns. A method declaration specifies its access level, whether it belongs to an instance or the class itself, what type of value it returns, its name, and any parameters it accepts. The method body, enclosed in braces ({…}), contains the statements that perform its task.

access_modifier [static] return_type methodName(parameter_list) {
  // method body
}

This general form describes all Java methods, from simple utilities to complex class behaviors. The parts of a typical method declaration are as follows:

• Access modifier: Defines visibility to other classes, usually public, protected, or private.
• Static modifier (optional): Indicates that the method belongs to the class rather than to any instance.
• Return type: Specifies the type of value the method produces. Use void if nothing is returned.
• Method name: A descriptive identifier following Java’s camelCase naming convention.
• Parameter list: Zero or more variables enclosed in parentheses, separated by commas, representing input to the method.

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

Here, the add() method is public, returns an integer, and takes two integer parameters. When called, it executes its body and returns the result of the addition.

Example: A simple utility method

The following class defines a simple method that greets a user by name. The method takes a String parameter and returns nothing:

public class Greeter {
  public void greet(String name) {
    System.out.println("Hello, " + name + "!");
  }
}

You can call this method by first creating an instance of the Greeter class, then invoking it with a suitable argument:

Greeter g = new Greeter();
g.greet("Java learner");

This prints:

Hello, Java learner!

Returning values

When a method specifies a return type other than void, it must contain a return statement that provides a value of the correct type. The return statement also immediately ends execution of the method.

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

Methods can contain multiple return statements, but only one executes in any given call, depending on control flow:

public String classify(int number) {
  if (number > 0) return "positive";
  if (number < 0) return "negative";
  return "zero";
}

Method naming and clarity

Good method names make code self-explanatory. In Java, method names conventionally start with a lowercase letter and describe an action or query. For example, getName(), setPrice(), and calculateAverage() are all clear and consistent names.

Keep method names concise but meaningful, and ensure they describe what the method does rather than how it works internally. Consistent naming across related methods makes code easier to understand and maintain.

Parameters and arguments

Methods often need information to perform their work. In Java, this information is passed through parameters, which are variables declared inside the parentheses of a method definition. When you call the method, you supply arguments, which are the actual values or expressions that get assigned to those parameters.

public void printSum(int a, int b) {
  System.out.println("Sum: " + (a + b));
}

printSum(3, 4);  // Arguments 3 and 4 are passed to parameters a and b

Each argument is evaluated before the method is called, and the resulting value is copied into the corresponding parameter. The number, order, and types of arguments in a method call must exactly match the parameter list in its definition.

Passing by value

Java always passes arguments by value, meaning the method receives a copy of the value, not the original variable itself. For primitive types (such as int, double, or boolean), this means the method cannot change the caller’s variable.

public void modifyValue(int x) {
  x = x * 2;
}

int n = 10;
modifyValue(n);
System.out.println(n);  // Still 10

Because x is a copy of n, modifying x inside the method has no effect on the original variable.

Passing object references

When a method parameter refers to an object, the reference (not a new object) is passed by value. This allows the method to access and modify the object’s fields, since both the caller and the method point to the same memory location.

public void rename(Person p) {
  p.name = "Updated";
}

Person person = new Person();
person.name = "Original";
rename(person);
System.out.println(person.name);  // Prints "Updated"

In this example, the rename() method changes the name field of the same Person object. However, if the method tries to assign a new object to p, that change will not affect the caller’s variable.

public void reassign(Person p) {
  p = new Person();
  p.name = "New";
}

Person person = new Person();
person.name = "Old";
reassign(person);
System.out.println(person.name);  // Still "Old"

Multiple parameters and order

Methods can accept any number of parameters, each with its own type. When calling a method, arguments must be supplied in the same order and type sequence as the parameters were declared.

public void displayInfo(String name, int age, double height) {
  System.out.println(name + " is " + age + " years old and " + height + "m tall.");
}

displayInfo("Alex", 29, 1.82);

If you supply the wrong type or wrong number of arguments, the compiler will raise an error. Java enforces this rule strictly to ensure type safety.

Default and optional values

Unlike some languages, Java does not support default parameter values directly. Each method call must supply all required arguments. However, you can achieve similar behavior using method overloading, by defining multiple methods with the same name but different parameter lists.

public void greet(String name) {
  System.out.println("Hello, " + name + "!");
}

public void greet() {
  greet("Guest");
}

The second greet() method calls the first one, providing a default argument. This pattern is common in Java when optional values are needed.

Method overloading

In Java, multiple methods can share the same name as long as their parameter lists differ. This feature, called method overloading, allows you to define variations of a method that perform similar actions but accept different types or numbers of arguments. Overloading improves flexibility and keeps related logic grouped under one meaningful name.

public class Printer {
  public void print(String message) {
    System.out.println(message);
  }

  public void print(int number) {
    System.out.println(number);
  }

  public void print(double value) {
    System.out.println(value);
  }
}

Here, three print() methods share the same name but differ in parameter types. The Java compiler automatically selects the correct version based on the arguments provided at the call site.

Printer p = new Printer();
p.print("Hello");
p.print(42);
p.print(3.14);

Each call resolves to the appropriate version of print() according to argument type. This is known as compile-time polymorphism, because the correct method is determined when the code is compiled, not at runtime.

Rules for overloading

To overload a method successfully, its signature must differ from others of the same name within the same class. The method signature includes the method name and the number and types of its parameters, but not the return type.

• Different parameter types: print(int n) vs print(String s)
• Different number of parameters: sum(int a, int b) vs sum(int a, int b, int c)
• Different parameter order: display(String s, int n) vs display(int n, String s)

Changing only the return type does not count as a valid overload, since it would not provide enough information for the compiler to choose between methods.

public int calculate() { return 0; }
public double calculate() { return 0.0; }  // Error: same signature

Automatic type promotion

When no exact match is found among overloaded methods, Java may automatically promote smaller numeric types to larger ones. For example, byte and short can be promoted to int, and float can be promoted to double.

public void show(int n) {
  System.out.println("int version");
}

public void show(double d) {
  System.out.println("double version");
}

show(5);    // int version
show(5.0);  // double version
byte b = 3;
show(b);    // promoted to int version

If both widening and autoboxing could apply (for example, int → Integer vs int → long), the compiler follows defined precedence rules to resolve ambiguity. However, ambiguous calls can still occur if multiple overloads are equally valid.

Varargs and overloading

Variable-length parameter lists (varargs, see the next section) also participate in overloading. A varargs method can accept zero or more arguments of a given type, but it may compete with other overloads during method selection.

public void log(String message) {
  System.out.println("Single: " + message);
}

public void log(String... messages) {
  System.out.println("Multiple: " + messages.length);
}

log("Hello");        // Calls the single-argument version
log("A", "B", "C");  // Calls the varargs version

The compiler always prefers an exact match before considering a varargs overload. This ensures that single-argument calls remain unambiguous even when a variable-length version exists.

Best practices for overloading

• Ensure that overloaded methods perform logically related tasks.
• Keep argument lists short and intuitive.
• Use documentation or Javadoc to explain differences between overloads.
• Avoid mixing too many overloads with similar parameter types, as this increases ambiguity.

Method overloading is most powerful when it enhances readability. Properly designed overloads let users of your class call methods naturally without memorizing variant names.

Variable-length arguments (varargs)

Sometimes you cannot predict how many arguments a method will need. In such cases, Java provides variable-length argument lists, known as varargs. A varargs parameter allows a method to accept zero or more arguments of a specified type, simplifying the interface and avoiding the need to manually create arrays.

public void listNames(String... names) {
  for (String name : names) {
    System.out.println(name);
  }
}

This method can be called with any number of String arguments:

listNames("Alice");
listNames("Alice", "Bob", "Charlie");
listNames();  // Valid, prints nothing

Inside the method, the names parameter behaves like an array of String values, so you can loop through it using an enhanced for loop or traditional indexing.

Defining varargs

The syntax for declaring a varargs parameter is simple: write an ellipsis (...) after the type and before the parameter name. A method can have only one varargs parameter, and it must always be the last parameter in the list.

public void printData(String label, int... values) {
  System.out.print(label + ": ");
  for (int v : values) {
    System.out.print(v + " ");
  }
  System.out.println();
}

This allows flexible calls such as:

printData("Scores", 10, 20, 30, 40);
printData("Empty list");

Passing existing arrays

Since a varargs parameter is treated as an array, you can also pass an existing array directly. Java does not distinguish between explicit arrays and varargs lists in this context.

int[] numbers = {1, 2, 3};
printData("Numbers", numbers);

This flexibility allows the same method to work with both static data structures and dynamic argument lists.

Combining varargs with overloading

Varargs can coexist with overloaded methods, but care is needed to prevent ambiguity. If one overload accepts a fixed number of arguments and another uses varargs, Java will prefer the exact match when possible.

public void show(String s) {
  System.out.println("Single: " + s);
}

public void show(String... s) {
  System.out.println("Multiple: " + s.length);
}

show("Test");        // Calls single version
show("A", "B", "C"); // Calls varargs version

However, ambiguous cases can occur if multiple varargs overloads exist or when autoboxing and type promotion intersect with varargs.

Varargs and arrays in practice

Because varargs translate directly to arrays, all familiar array operations are available. You can use indexing, length checks, and even pass the parameter onward to other methods that expect an array of the same type.

public void printAll(String... items) {
  System.out.println("Count: " + items.length);
  for (int i = 0; i < items.length; i++) {
    System.out.println("Item " + (i + 1) + ": " + items[i]);
  }
}

Varargs make many API designs cleaner. For instance, Java’s own printf() and String.format() methods use varargs to accept an arbitrary number of formatting arguments:

System.out.printf("Name: %s, Age: %d%n", "Alex", 30);

This pattern combines simplicity for common cases with flexibility for more complex input.

Static methods and access control

Java distinguishes between methods that belong to individual objects and those that belong to the class itself. The latter are known as static methods. They can be called without creating an instance of the class and are often used for utility operations or shared logic that does not depend on any particular object’s state.

public class MathTools {
  public static int square(int x) {
    return x * x;
  }
}

int result = MathTools.square(5);  // 25

Static methods are loaded once when the class is first used and remain available throughout the program’s lifetime. They cannot access instance variables or instance methods directly because they do not operate on any specific object. However, they can freely use other static members of the same class.

Accessing static vs. instance methods

Static methods are called using the class name, while instance methods are called on objects created from the class:

public class Counter {
  private int count = 0;
  private static int total = 0;

  public void increment() {
    count++;
    total++;
  }

  public static int getTotal() {
    return total;
  }
}

Counter a = new Counter();
Counter b = new Counter();
a.increment();
b.increment();

System.out.println(Counter.getTotal());  // 2

Here, getTotal() reports a value shared among all instances, while increment() changes both the individual and shared counters.

Access modifiers

Every method in Java can specify how visible it is to other classes and packages using an access modifier. These keywords control which parts of a program can use the method, helping enforce encapsulation and modularity.

Access control defines the boundaries of your program’s design. It ensures that internal details remain hidden, while exposing only the parts meant for external use.

public class Account {
  private double balance;

  public void deposit(double amount) {
    balance += amount;
  }

  protected double getBalance() {
    return balance;
  }
}

Here, deposit() is public so it can be called externally, but getBalance() is protected, making it accessible only to subclasses or classes within the same package. The balance field remains private, preserving control over direct modification.

Encapsulation and method design

Encapsulation is one of the core principles of object-oriented programming. By hiding internal data behind methods, you control how that data is accessed and modified. Methods serve as the interface through which the outside world interacts with your class.

public class Temperature {
  private double celsius;

  public void setCelsius(double c) {
    if (c < -273.15) {
      c = -273.15;  // limit to absolute zero
    }
    celsius = c;
  }

  public double getCelsius() {
    return celsius;
  }

  public double getFahrenheit() {
    return celsius * 9 / 5 + 32;
  }
}

This design hides the raw field and enforces validation rules within the setter. External code cannot corrupt internal state by bypassing those checks.

Combining static methods with encapsulation

Static methods are especially useful when creating utility-style classes that do not need to hold state. For example, the standard Java library’s Math class contains only static methods:

double root = Math.sqrt(16);   // 4.0
double area = Math.PI * Math.pow(3, 2);  // 28.27...

You can follow the same pattern for your own helper classes—collecting general-purpose routines that operate independently of any object’s data. When combined with proper access modifiers, this approach keeps code organized, predictable, and easy to maintain.

Chapter 6: Objects and Classes

Everything in Java revolves around objects. From the smallest string to the most complex data structure, every entity is represented as an instance of a class. Classes define the blueprint; objects are the living instances created from that blueprint. Understanding how they work together is the foundation of object-oriented programming in Java.

Java was designed from the ground up as an object-oriented language. This means that instead of writing disconnected functions and data, you describe types of things (classes) that combine both state (fields) and behavior (methods). When your program runs, it creates objects from those classes, each with its own data but sharing the same structure and abilities.

Object-oriented design helps you organize code logically, reduce duplication, and build systems that scale. Once you learn how to define classes, construct objects, and control their visibility and interaction, you will be able to write programs that model real-world systems cleanly and efficiently.

In this chapter, you will learn how to declare and instantiate classes, define constructors and fields, control access with modifiers, and design immutable or encapsulated objects. You will also explore the most common methods that all Java objects share, such as toString(), equals(), and hashCode().

Declaring classes and creating objects

In Java, a class defines the structure and behavior of objects. It describes what data each object can hold (its fields) and what actions it can perform (its methods). A class acts as a blueprint from which any number of objects can be created, each with its own independent state.

public class Car {
  String model;
  int year;

  void start() {
    System.out.println("Engine started");
  }
}

This simple Car class defines two fields and one method. To use it, you create an object (an instance of that class) using the new keyword.

Car myCar = new Car();
myCar.model = "Tesla Model 3";
myCar.year = 2025;
myCar.start();

Here, myCar is an object of type Car. The new keyword allocates memory for the object and calls a special method called a constructor (which you will learn about in the next section). Each object created from the class can store different data in its fields, even though they all share the same structure and methods.

The anatomy of a class

A class definition can include several kinds of members:

• Fields (or attributes): variables that store object data.
• Methods: blocks of code that perform operations or return results.
• Constructors: special methods that initialize new objects.
• Access modifiers: keywords that control visibility to other classes.

Here is a slightly more complete example:

public class Book {
  String title;
  String author;
  int year;

  void describe() {
    System.out.println(title + " by " + author + " (" + year + ")");
  }
}

When you create a new Book object, each field starts with its default value (null for strings, 0 for integers) until you assign something explicitly:

Book b = new Book();
b.title = "This is Java";
b.author = "Robin Nixon";
b.year = 2025;
b.describe();

This is Java by Robin Nixon (2025)

Objects, references, and memory

In Java, variables like myCar or b do not store the actual object but rather a reference to it. The object itself lives on the heap, and the variable points to its memory location. When a variable no longer refers to an object, Java’s garbage collector automatically reclaims that memory.

Book a = new Book();
Book b = a;
b.title = "Shared Object";
System.out.println(a.title);  // Prints "Shared Object"

Both a and b refer to the same object in memory. Changing one affects the other, because they share a reference.

Public and package-level classes

Java source files can contain multiple classes, but only one may be declared public, and its name must match the filename. For example, a file named Car.java must contain a public class named Car. Additional classes in the same file are automatically given package-private access, meaning they are visible only within their package.

// File: Car.java
public class Car { }

class Engine { }

This restriction ensures predictable compilation and organization across large projects, where each public class forms a clear entry point for its file.

Fields, methods, and access modifiers

Every class combines fields (to hold data) and methods (to perform actions). Together they define what an object is and what it can do. Access modifiers control how those members are seen and used from other parts of the program.

Fields: storing object state

Fields (also known as instance variables) hold the data that represents an object’s state. Each object has its own independent copy of these values. Fields are usually declared at the top of the class, optionally with access modifiers and initial values.

public class Person {
  private String name;
  private int age;

  public void showInfo() {
    System.out.println(name + " is " + age + " years old.");
  }
}

Here, name and age are private, meaning they can only be accessed from within the Person class itself. This enforces encapsulation by hiding internal details from the outside world.

Methods: defining behavior

Methods are blocks of code that define what an object can do. They can perform calculations, modify fields, or return information. Most methods operate on the fields of their own object, using the implicit reference this to access them if needed.

public class Counter {
  private int count;

  public void increment() {
    count++;
  }

  public int getCount() {
    return count;
  }
}

Each time you call increment(), it increases the value of count stored inside that particular Counter object. Another instance of the same class will have its own count value unaffected by others.

Access modifiers

Java uses access modifiers to control visibility of class members (fields and methods). These keywords define how accessible each part of your class is from other parts of the program:

Access modifiers apply both to fields and methods, and can be mixed within the same class to create clear, layered visibility. The usual pattern is to keep fields private and expose only controlled access through public methods.

public class BankAccount {
  private double balance;

  public void deposit(double amount) {
    if (amount > 0) balance += amount;
  }

  public double getBalance() {
    return balance;
  }
}

Class-level vs. instance-level members

Java distinguishes between instance members and class (static) members. Instance members belong to specific objects, while static members belong to the class itself and are shared across all objects.

public class Student {
  private String name;
  private static int count = 0;

  public Student(String name) {
    this.name = name;
    count++;
  }

  public static int getCount() {
    return count;
  }
}

Student s1 = new Student("Alice");
Student s2 = new Student("Bob");
System.out.println(Student.getCount());  // 2

Here, each Student object has its own name, but they all share the same static count. Static members are ideal for values or methods that conceptually belong to the class rather than any particular instance.

Combining fields and methods effectively

A well-designed class uses fields to represent data and methods to manage that data safely. The goal is to provide a clear public interface that lets users of the class perform necessary operations without exposing unnecessary internal details.

public class Light {
  private boolean on;

  public void turnOn() {
    on = true;
  }

  public void turnOff() {
    on = false;
  }

  public boolean isOn() {
    return on;
  }
}

This structure keeps the on state private but offers methods to control and query it. External code can interact with the object without ever needing to know how it works internally.

Encapsulation and immutability

Encapsulation and immutability are two of the most important ideas in object-oriented programming. They determine how data is protected inside objects and how predictable those objects remain once created. Together, they form the foundation of safe, maintainable Java design.

Encapsulation: hiding internal details

Encapsulation means keeping an object’s internal data private and exposing it only through controlled methods. This prevents external code from directly changing an object’s internal state, which helps maintain consistency and prevents bugs.

public class Account {
  private double balance;

  public void deposit(double amount) {
    if (amount > 0) {
      balance += amount;
    }
  }

  public void withdraw(double amount) {
    if (amount > 0 && amount <= balance) {
      balance -= amount;
    }
  }

  public double getBalance() {
    return balance;
  }
}

Here, the balance field is private and cannot be changed directly from outside the class. All updates must go through the deposit() and withdraw() methods, which enforce rules and protect data integrity.

Encapsulation is usually achieved through the combination of private fields and public getter and setter methods. This pattern gives flexibility to change internal details without breaking external code.

public class Temperature {
  private double celsius;

  public void setCelsius(double c) {
    if (c < -273.15) c = -273.15;
    celsius = c;
  }

  public double getCelsius() {
    return celsius;
  }

  public double getFahrenheit() {
    return (celsius * 9 / 5) + 32;
  }
}

Even if the internal storage changes in the future (for example, switching to Fahrenheit internally), external code using the getter and setter will continue to work exactly the same way.

Immutability: preventing modification

Immutability takes encapsulation one step further. An immutable object’s state cannot change once it is created. Instead of modifying fields, you create new objects whenever different data is needed. This approach simplifies reasoning about code and prevents side effects.

public final class Point {
  private final int x;
  private final int y;

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

  public int getX() { return x; }
  public int getY() { return y; }

  public Point move(int dx, int dy) {
    return new Point(x + dx, y + dy);
  }
}

Each time move() is called, it returns a new Point object instead of modifying the existing one. The original remains unchanged. This is the same principle used in classes such as String, which are immutable in Java.

Point p1 = new Point(3, 4);
Point p2 = p1.move(2, -1);

System.out.println(p1.getX());  // 3
System.out.println(p2.getX());  // 5

Here, p1 remains unchanged, demonstrating that immutability protects original data from alteration, even when passed between methods or threads.

When to use mutable vs. immutable objects

Not every class needs to be immutable. Mutable objects are useful when you need to update data frequently, such as in collections or models representing real-world entities. Immutable objects, on the other hand, are ideal for values that should never change after creation, such as onfiguration data, coordinates, or string values.

• Use mutable objects for entities that evolve during program execution.
• Use immutable objects for stable values that represent fixed data.

Java’s standard library mixes both approaches: String, Integer, and LocalDate are immutable, while ArrayList and HashMap are mutable.

Combining encapsulation and immutability

Encapsulation and immutability often work best together. Encapsulation hides how data is stored, while immutability ensures that it cannot be altered once set. Together, they create objects that are predictable, robust, and easy to reason about.

public final class User {
  private final String username;
  private final int id;

  public User(String username, int id) {
    this.username = username;
    this.id = id;
  }

  public String getUsername() { return username; }
  public int getId() { return id; }
}

Such classes are safe to share, simple to test, and immune to most synchronization issues. They embody the clean, disciplined design principles that make Java code long-lasting and dependable.

toString(), equals(), and hashCode()

Every Java class inherits three fundamental methods from the base Object class: toString(), equals(), and hashCode(). These methods control how objects describe themselves, compare for equality, and interact with hash-based collections like HashMap or HashSet. Understanding and overriding them correctly is an essential part of designing reliable classes.

The toString() method

The toString() method returns a human-readable representation of an object. By default, it produces a technical string such as Person@2a139a55, which is not very informative. Overriding it lets you provide meaningful descriptions that help with debugging and logging.

public class Person {
  private String name;
  private int age;

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

  @Override
  public String toString() {
    return name + " (" + age + ")";
  }
}

Person p = new Person("Mary", 42);
System.out.println(p);  // Prints: Mary (42)

Whenever an object is printed, concatenated with a string, or logged, Java automatically calls toString() behind the scenes. Clear, concise implementations make your output much easier to interpret.

The equals() method

The equals() method determines whether two objects are considered logically equal. The default implementation inherited from Object compares memory references, meaning two variables are only equal if they refer to the same instance. Most real-world classes, however, should compare based on their field values.

public class Book {
  private String title;
  private String author;

  public Book(String title, String author) {
    this.title = title;
    this.author = author;
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof Book)) return false;
    Book other = (Book) obj;
    return title.equals(other.title) && author.equals(other.author);
  }
}

Now, two Book objects with the same title and author are considered equal, even if they occupy different memory locations.

Book a = new Book("This is Java", "Robin Nixon");
Book b = new Book("This is Java", "Robin Nixon");
System.out.println(a.equals(b));  // true

The hashCode() method

The hashCode() method returns an integer value used by hash-based collections to group and retrieve objects efficiently. Whenever you override equals(), you must also override hashCode() to ensure consistency. Otherwise, objects that are logically equal may not behave correctly in HashMap or HashSet.

@Override
public int hashCode() {
  return Objects.hash(title, author);
}

The Objects.hash() utility (introduced in Java 7) simplifies generating hash codes from multiple fields. It ensures that objects with the same field values produce identical hash codes.

Set<Book> library = new HashSet<>();
library.add(a);
library.add(b);
System.out.println(library.size());  // 1

Because a and b are equal and have the same hash code, the set stores only one entry, as expected.

Putting them together

Well-designed classes usually override all three methods together. Doing so makes them easier to inspect, compare, and use in collections. A concise, consistent implementation improves both performance and readability.

public class User {
  private final String username;
  private final int id;

  public User(String username, int id) {
    this.username = username;
    this.id = id;
  }

  @Override
  public String toString() {
    return username + " [" + id + "]";
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj) return true;
    if (!(obj instanceof User)) return false;
    User other = (User) obj;
    return id == other.id && username.equals(other.username);
  }

  @Override
  public int hashCode() {
    return Objects.hash(username, id);
  }
}

This class now behaves predictably in every situation where comparison or printing is involved, such as collection membership, debugging, or logging.

Chapter 7: Inheritance and Polymorphism

Inheritance and polymorphism are two of the core ideas that give object-oriented programming its power and flexibility. Together, they let you define new classes that build on existing ones, share common behaviour, and adapt that behaviour to new contexts without rewriting code. Inheritance expresses relationships between classes, while polymorphism allows those related classes to be used interchangeably in consistent and predictable ways.

In Java, every class except Object inherits from exactly one superclass. This single-inheritance model keeps hierarchies clear and avoids the ambiguity that can arise when multiple parents define overlapping members. A subclass automatically gains the accessible fields and methods of its parent, can extend or replace them, and can add its own specialisations. Through this mechanism, large systems evolve as trees of related types that share a common foundation but differ in detail.

Polymorphism complements inheritance by letting a reference to a superclass hold an object of any subclass. When a method defined in the superclass is overridden in the subclass, Java automatically selects the correct version at runtime. This behaviour, known as dynamic dispatch, allows programs to remain general at the top level yet specific in execution. It is what enables a single interface or abstract type to represent many concrete implementations.

Together, inheritance and polymorphism form the architectural glue that connects every object-oriented Java program. They allow code to be structured for reuse, clarity, and evolution, so that systems can grow without duplication or chaos. Mastering these concepts is essential to writing code that scales naturally from small examples to real-world applications.

Extending classes and using superclasses

Inheritance in Java is achieved by defining a new class that extends an existing one. The new class, known as the subclass or derived class, inherits all the accessible fields and methods of its superclass (also called the base class). This means you can reuse and expand on existing functionality instead of duplicating it.

The syntax for inheritance uses the extends keyword, followed by the name of the superclass. For example:

class Animal {
  void speak() {
    System.out.println("The animal makes a sound.");
  }
}

class Dog extends Animal {
  void bark() {
    System.out.println("The dog barks.");
  }
}

Here, the Dog class inherits the speak() method from Animal and also defines its own bark() method. This allows an instance of Dog to use both methods:

Dog d = new Dog();
d.speak();  // Inherited from Animal
d.bark();   // Defined in Dog

All classes in Java (except Object) implicitly extend a single superclass. If you do not specify one, Java automatically assumes extends Object, which gives every class access to methods like toString(), equals(), and hashCode().

Accessing superclass members

A subclass can call methods or access fields from its superclass using the super keyword. This is useful when you want to invoke a superclass implementation that has been overridden, or when you need to initialise inherited fields through the parent’s constructor.

class Animal {
  void speak() {
    System.out.println("The animal makes a sound.");
  }
}

class Dog extends Animal {
  void speak() {
    super.speak();  // call the superclass version
    System.out.println("The dog barks.");
  }
}

When speak() is called on a Dog object, both versions run in sequence, demonstrating how subclass methods can extend behaviour rather than completely replace it.

Calling superclass constructors

If a superclass defines one or more constructors, the subclass must explicitly call one of them as the first statement of its own constructor using super(…). This ensures that the inherited part of the object is properly initialised before the subclass adds its own setup.

class Animal {
  String name;

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

class Dog extends Animal {
  Dog(String name) {
    super(name);  // call Animal constructor
  }
}

If the superclass has a default (no-argument) constructor, the compiler inserts a call to it automatically when you do not specify one. However, if no such constructor exists, you must explicitly call one of the available constructors using super(…).

Overriding methods and using the super keyword

When a subclass defines a method with the same name, return type, and parameters as one in its superclass, the subclass version overrides the parent version. This is a cornerstone of polymorphism, allowing a subclass to provide behaviour that better fits its specific role while keeping the same external interface.

class Animal {
  void speak() {
    System.out.println("The animal makes a sound.");
  }
}

class Dog extends Animal {
  @Override
  void speak() {
    System.out.println("The dog barks.");
  }
}

Here, Dog overrides the speak() method of Animal. When the method is called on a Dog object, Java automatically invokes the subclass version instead of the parent’s, even if the reference type is Animal:

Animal a = new Dog();
a.speak();  // Outputs: The dog barks.

The @Override annotation is optional but strongly recommended. It tells the compiler that the method is intended to override one from a superclass, and generates an error if no such method exists. This prevents subtle mistakes such as misspelling a method name or mismatching its signature.

Calling the superclass version

Sometimes a subclass needs to extend rather than completely replace a method’s behaviour. In such cases, you can call the superclass version inside the overriding method using super.methodName(). This lets you build on the inherited implementation instead of discarding it.

class Animal {
  void speak() {
    System.out.println("The animal makes a sound.");
  }
}

class Dog extends Animal {
  @Override
  void speak() {
    super.speak();  // Call superclass version
    System.out.println("The dog barks.");
  }
}

When speak() is invoked on a Dog object, both lines execute in order, combining the superclass message with the subclass-specific one. This pattern is common in frameworks and libraries that expect subclasses to add to base functionality.

Rules for overriding

When overriding a method in Java, several important rules apply:

• The method name, parameter list, and return type must exactly match those of the superclass method (except that the return type may be a subclass of the original type, known as covariant return).
• The overriding method cannot have a more restrictive access level than the original (for example, a public method in the superclass cannot be overridden as protected).
• Only inherited, non-final, non-static methods can be overridden. final methods are explicitly marked to prevent changes, and static methods belong to the class, not instances.

class Vehicle {
  public void start() {
    System.out.println("Vehicle starting...");
  }

  public final void stop() {
    System.out.println("Vehicle stopped.");
  }
}

class Car extends Vehicle {
  @Override
  public void start() {
    System.out.println("Car engine starting...");
  }

  // void stop() { } // error: cannot override a final method
}

Overriding and exception handling

When overriding a method that declares checked exceptions, the subclass version cannot declare broader exceptions than the original. It may, however, declare narrower exceptions or none at all. This ensures that code using the superclass reference remains valid and predictable.

class FileReader {
  void read() throws IOException {
    System.out.println("Reading file...");
  }
}

class SafeFileReader extends FileReader {
  @Override
  void read() {
    System.out.println("Reading safely, no exception thrown.");
  }
}

This rule maintains compatibility: a FileReader reference that expects read() to potentially throw an IOException can still safely call read() on a SafeFileReader instance without additional handling.

Abstract classes and methods

Sometimes you need a class that defines a common framework for its subclasses but should not itself be instantiated. In Java, this is achieved using abstract classes. An abstract class can contain both fully implemented methods and abstract methods (methods declared without a body) that subclasses must provide.

abstract class Shape {
  abstract double area();  // abstract method

  void describe() {
    System.out.println("This is a geometric shape.");
  }
}

class Circle extends Shape {
  double radius;

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

  @Override
  double area() {
    return Math.PI * radius * radius;
  }
}

Here, Shape defines a common interface for geometric forms but leaves the exact implementation of area() to each subclass. The Circle class provides that implementation while inheriting the concrete describe() method from Shape.

Shape s = new Circle(5);
s.describe();
System.out.println(s.area());

You cannot create an object directly from an abstract class. Attempting to do so results in a compile-time error:

Shape s = new Shape(); // error: Shape is abstract; cannot be instantiated

Declaring abstract methods

An abstract method has no body and ends with a semicolon instead of braces. It serves as a placeholder for behaviour that subclasses must implement. Any class containing one or more abstract methods must itself be declared abstract.

abstract class Animal {
  abstract void speak(); // must be implemented by subclasses
}

Subclasses of an abstract class must either implement all inherited abstract methods or also be declared abstract themselves. This rule ensures that any class you can instantiate has complete implementations for all its behaviours.

class Dog extends Animal {
  @Override
  void speak() {
    System.out.println("Woof!");
  }
}

Mixing abstract and concrete members

Abstract classes can freely combine abstract methods with fully defined ones. This flexibility allows you to provide default or shared logic that all subclasses inherit, while still requiring them to implement the unique parts.

abstract class Device {
  void powerOn() {
    System.out.println("Powering on...");
  }

  abstract void operate(); // subclasses define how
}

class Printer extends Device {
  @Override
  void operate() {
    System.out.println("Printing document...");
  }
}

When you call powerOn() on a Printer, the method runs exactly as defined in Device, while operate() runs the subclass-specific version.

Abstract vs. interface

Abstract classes and interfaces both define contracts for other classes to follow, but they serve slightly different purposes. An abstract class can contain state (fields) and concrete method implementations, while an interface (covered in the next chapter) defines only method signatures and constants.

Choosing between them depends on intent: use an abstract class when you want to share code and structure, and an interface when you want to define capabilities that can apply across unrelated class hierarchies.

Interfaces and multiple inheritance

Interfaces in Java define contracts that classes can implement, describing what they must do without specifying how. An interface is similar to an abstract class that contains only abstract methods and constants, but unlike classes, interfaces allow a form of multiple inheritance. A class can implement several interfaces, combining behaviours from different sources while keeping its single superclass relationship intact.

interface Speakable {
  void speak();
}

interface Movable {
  void move();
}

class Dog implements Speakable, Movable {
  public void speak() {
    System.out.println("The dog barks.");
  }

  public void move() {
    System.out.println("The dog runs.");
  }
}

Here, Dog implements two interfaces, Speakable and Movable. Each interface defines a capability that Dog must provide. The methods are declared public because all interface methods are implicitly public abstract, and must be implemented with equal or greater visibility.

Defining and implementing interfaces

An interface is declared with the interface keyword. Unlike classes, interfaces cannot have instance fields or constructors, because they do not represent actual objects. They define method signatures that implementing classes must provide.

interface Shape {
  double area();
}

To use an interface, a class must explicitly declare that it implements it and then supply implementations for all its methods:

class Circle implements Shape {
  double radius;

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

  public double area() {
    return Math.PI * radius * radius;
  }
}

If a class does not implement all the methods of an interface, it must itself be declared abstract. This ensures that only complete, concrete classes can be instantiated.

Default and static methods

Since Java 8, interfaces can include default methods (which provide an implementation) and static methods (which belong to the interface itself). These additions make interfaces more flexible while keeping backward compatibility with older designs.

interface Logger {
  default void log(String msg) {
    System.out.println("[LOG] " + msg);
  }

  static void info(String msg) {
    System.out.println("[INFO] " + msg);
  }
}

class ConsoleLogger implements Logger { }

ConsoleLogger c = new ConsoleLogger();
c.log("Starting system...");  // uses default method
Logger.info("Ready");         // calls static method

Default methods help evolve interfaces without breaking existing code. You can add new behaviour by defining a default method, so classes that already implement the interface do not need immediate changes.

Extending interfaces

Interfaces can also extend other interfaces, inheriting all their abstract and default methods. This allows complex contracts to be built from smaller, more focused ones.

interface Readable {
  void read();
}

interface Writable {
  void write();
}

interface FileAccess extends Readable, Writable { }

class FileHandler implements FileAccess {
  public void read() {
    System.out.println("Reading file...");
  }

  public void write() {
    System.out.println("Writing file...");
  }
}

Here, FileAccess combines the capabilities of Readable and Writable. Any class implementing FileAccess must provide both read() and write() methods, effectively inheriting multiple behaviours.

Interfaces and polymorphism

Just like abstract classes, interfaces support polymorphism. A variable declared with an interface type can refer to any object of a class that implements that interface.

Movable m = new Dog();
m.move();  // The dog runs.

This allows programs to treat different objects uniformly based on shared capabilities rather than class hierarchies. For example, a method accepting a Movable parameter can work with any movable object, whether it is an animal, vehicle, or machine.

void startMoving(Movable m) {
  m.move();
}

Multiple inheritance of behaviour

While Java does not support multiple inheritance of classes, interfaces make it possible to achieve multiple inheritance of type and behaviour. By combining interfaces, a class can inherit from one superclass and any number of interfaces, allowing clean composition of features.

class SmartDog extends Animal implements Speakable, Movable {
  public void speak() {
    System.out.println("The smart dog talks.");
  }

  public void move() {
    System.out.println("The smart dog walks gracefully.");
  }
}

This model avoids the “diamond problem” that plagues languages with full multiple inheritance. Because interfaces contain no shared instance data, there is no ambiguity over which state or method implementation to use.

Dynamic dispatch and polymorphic behavior

Dynamic dispatch is the mechanism that allows Java to decide at runtime which implementation of a method to call when multiple versions exist in a class hierarchy. It is the foundation of polymorphic behavior and one of the main reasons Java programs can remain both flexible and type-safe. When a superclass reference is used to call an overridden method, the Java Virtual Machine determines which version to execute based on the actual type of the object, not the declared type of the reference.

class Animal {
  void speak() {
    System.out.println("The animal makes a sound.");
  }
}

class Dog extends Animal {
  @Override
  void speak() {
    System.out.println("The dog barks.");
  }
}

class Cat extends Animal {
  @Override
  void speak() {
    System.out.println("The cat meows.");
  }
}

public class Demo {
  public static void main(String[] args) {
    Animal a;

    a = new Dog();
    a.speak();  // The dog barks.

    a = new Cat();
    a.speak();  // The cat meows.
  }
}

Although both calls are made through an Animal reference, the correct subclass method runs each time. This dynamic resolution of method calls at runtime is what gives polymorphism its power. It lets programs remain general in structure but specific in behavior.

Method tables and runtime resolution

Under the hood, each Java class maintains a method table that maps method names to their actual implementations. When you invoke a method on an object, the JVM looks up the method in that table and jumps to the correct implementation. This process is efficient and fully automatic, providing dynamic behavior without sacrificing performance.

Animal ref = new Dog();
ref.speak();  // JVM dispatches to Dog.speak() via method table

Because this resolution happens at runtime, Java can support flexible architectures such as plugin systems, frameworks, and dependency injection, where the exact class being used may not be known until execution.

Polymorphic assignments

Polymorphism allows variables of a superclass type to reference subclass objects. These references can be reassigned freely among related types, and method calls will continue to resolve correctly according to the actual object type.

Animal animal = new Dog();
animal.speak();  // Dog version

animal = new Cat();
animal.speak();  // Cat version

This ability makes it possible to create collections or arrays of superclass types that hold a mixture of subclass instances, each behaving appropriately when accessed.

Animal[] pets = { new Dog(), new Cat(), new Dog() };

for (Animal pet : pets) {
  pet.speak();
}

Benefits of dynamic dispatch

• Eliminates the need for large conditional statements that test types explicitly.
• Allows new subclasses to be added without changing existing code.
• Supports modular, extensible design where behavior can be varied through subclassing.
• Enables clean separation between interface and implementation.

Dynamic dispatch is what turns inheritance hierarchies into living systems. It ensures that objects act according to their real identity, even when viewed through general references, and that programs remain open to extension but closed to modification.

Chapter 8: Packages and Modules

As Java projects grow, organization becomes essential. Classes alone are not enough to keep large systems manageable, so Java provides two complementary mechanisms for structuring code: packages and modules. Packages group related classes and interfaces into named namespaces, preventing conflicts and improving clarity. Modules, introduced in Java 9, build on this idea by defining explicit boundaries and dependencies between those packages, turning a collection of classes into a self-contained, versionable unit.

Packages are the foundation of code organization in Java. Every class belongs to a package, whether explicitly declared or implicitly placed in the unnamed default package. Packages make code easier to navigate, reuse, and distribute. They also form the basis for access control between classes, since Java’s visibility rules extend across package boundaries.

Modules take this one step further. A module declares which packages it exports for use by other modules, and which other modules it depends on. This structure gives large applications a clear architecture, where internal implementation details remain hidden and only well-defined interfaces are exposed. The Java Platform Module System (JPMS) enforces these relationships at both compile time and runtime, improving reliability and security.

Together, packages and modules transform a flat collection of source files into a layered, maintainable ecosystem. Whether you are writing a small utility or a multi-module application, understanding how these features interact will help you design software that scales cleanly and compiles with confidence.

Package structure and naming

A package in Java is a namespace that groups related classes, interfaces, and subpackages together under a common name. Packages provide organization, prevent name clashes, and form the basis for access control across different parts of a program. They mirror the folder structure on disk, creating a clear correspondence between code and file layout.

You declare a package at the top of a source file using the package keyword, followed by its fully qualified name. For example:

package com.example.project.utils;

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

This declaration tells the compiler that MathHelper belongs to the package com.example.project.utils. The source file must therefore be stored in a matching folder structure:

com/
  example/
    project/
      utils/
        MathHelper.java

When compiled, the output .class file is placed in the same structure within the output directory. This physical organization ensures that large codebases remain predictable and navigable.

Default and explicit packages

If you do not declare a package at the top of a source file, the class belongs to the default package. While this can be useful for very small programs or examples, it should be avoided in professional code because classes in the default package cannot be imported into other packages.

// default package (no declaration)
public class Hello { … }

Explicitly naming every package makes your code more modular and avoids future conflicts as projects grow. It also allows tools and IDEs to organize files correctly and manage dependencies more effectively.

Package naming conventions

Java’s package naming conventions follow clear, global rules that make code from different sources work together seamlessly:

• Use all lowercase letters, with words separated by periods (.).
• Begin with your organization’s reversed Internet domain name (for example, com.example or org.apache).
• Follow with project or module identifiers, then specific functionality or components.
• Avoid using Java keywords or existing standard library package names.

package com.nixonpublishing.thisisjava.ch08.examples;

Package naming consistency allows developers to understand a project’s structure immediately and reduces the risk of class name collisions across different libraries.

Organizing packages by responsibility

Large projects often use packages to separate code by purpose or functionality. For example, a typical application might be divided as follows:

com.example.app
  ├─ model       // Data structures and domain classes
  ├─ view        // User interface components
  ├─ controller  // Application logic and flow
  ├─ util        // Helper and utility classes
  └─ test        // Unit tests and resources

This structure mirrors the logical architecture of the program, allowing teams to work on different components independently while maintaining a coherent layout. IDEs and build tools (such as Maven or Gradle) recognize these conventions automatically.

Importing classes and static imports

To use a class or interface from another package, you must either refer to it by its fully qualified name or import it into your source file. Imports make code more readable by allowing you to refer to classes directly without repeatedly writing their full package paths.

import com.example.project.utils.MathHelper;

public class Calculator {
  public static void main(String[] args) {
    int sum = MathHelper.add(5, 7);
    System.out.println(sum);
  }
}

Without the import statement, you would need to use the full package name each time:

int sum = com.example.project.utils.MathHelper.add(5, 7);

Imports do not copy code or create dependencies beyond what the compiler already needs. They are purely a convenience feature that tells the compiler where to find class definitions when translating source code.

Wildcard imports

You can use the asterisk (*) to import all public classes from a package:

import com.example.project.utils.*;

This allows access to all public members of that package without listing them individually. However, wildcard imports are resolved only at compile time—they do not import subpackages or increase load time.

While convenient, wildcard imports can sometimes obscure where a class comes from, especially when multiple packages contain classes with the same name.

Automatic imports

Every Java source file automatically imports two groups of classes:

• All classes in the same package.
• All classes from java.lang (for example, String, System, Math).

This means you can use core classes without explicit imports:

String text = "Hello";
System.out.println(Math.sqrt(9));

However, anything outside java.lang or your current package must be imported explicitly.

Static imports

Introduced in Java 5, static imports let you import static members (fields or methods) from a class so that they can be used without qualifying their class name. This can make code cleaner in cases where static constants or utility methods are used frequently.

import static java.lang.Math.PI;
import static java.lang.Math.pow;

public class Circle {
  public static double area(double radius) {
    return PI * pow(radius, 2);
  }
}

Without static imports, you would need to write Math.PI and Math.pow() each time. Static imports are especially common in testing frameworks like JUnit, where they allow cleaner assertions:

import static org.junit.jupiter.api.Assertions.assertEquals;

assertEquals(10, calculate());

Import order and conflicts

If two imported packages contain classes with the same name, you must refer to the ambiguous class by its fully qualified name. For example, both java.util and java.sql contain a class named Date:

import java.util.*;
import java.sql.*;

Date d = new Date();            // error: ambiguous
java.util.Date d1 = new java.util.Date();  // correct
java.sql.Date d2 = new java.sql.Date(0);   // correct

Java does not allow importing two classes with identical names into the same namespace, so qualified names must be used whenever such conflicts occur.

Encapsulation across packages

Encapsulation is one of the key principles of object-oriented design, and in Java it extends beyond individual classes to include entire packages. Packages act as visibility boundaries, allowing you to control which parts of your code are accessible to other parts of the program. This helps keep internal details hidden while exposing only the elements intended for external use.

Access control in Java is managed through access modifiers: public, protected, private, and package-private (the default when no modifier is used). These determine how fields, methods, and classes can be seen or used from other packages.

By combining these modifiers with package structure, you can design APIs that are clear and safe to use, while preventing access to internal implementation classes that are not meant to be part of the public interface.

Package-private access

Any class, method, or field declared without an explicit access modifier has package-private visibility. This means it can be accessed freely by other classes in the same package but not by classes outside it, even if they are subclasses.

package com.example.shapes;

class CircleHelper {  // package-private
  static double circumference(double r) {
    return 2 * Math.PI * r;
  }
}

public class Circle {
  double radius;
  public double area() {
    return Math.PI * radius * radius;
  }
}

Here, CircleHelper is invisible outside com.example.shapes but fully accessible to other classes within that package. This technique keeps utility or implementation details internal to the package.

Protected access and subclassing

The protected modifier allows visibility within the same package and also to subclasses in other packages. This makes it useful for creating extensible class hierarchies while still keeping some encapsulation.

package com.example.animals;

public class Animal {
  protected void speak() {
    System.out.println("Generic animal sound");
  }
}

package com.example.animals.mammals;
import com.example.animals.Animal;

public class Dog extends Animal {
  public void bark() {
    speak();  // allowed: protected method in superclass
    System.out.println("The dog barks");
  }
}

Although speak() is not public, the subclass can still call it because it inherits from Animal. However, a non-subclass in another package would not be able to access it.

Public APIs and internal classes

When designing libraries or large systems, it is best practice to separate public API classes (those intended for use by other packages or developers) from internal implementation classes (those used only within the package). You can enforce this separation through access modifiers and careful package structure.

com.example.library
  ├─ api
  │   └─ Library.java
  └─ internal
      └─ LibraryHelper.java

Only the classes in com.example.library.api are public, while those in internal remain package-private. External code imports only from the api package, keeping internal details hidden and safe from misuse.

Encapsulation and the module system

Before Java 9, package-level encapsulation was the strongest available boundary. With the introduction of the Java Platform Module System (JPMS), modules can now explicitly control which packages are visible to other modules, providing a more robust form of encapsulation at a higher level.

When you declare a module, you can export only the packages you wish to make accessible, while keeping the rest private to that module. This ensures that even public classes are not globally visible unless their packages are explicitly exported.

Java modules

Modules were introduced in Java 9 as part of the Java Platform Module System (JPMS). They provide a higher-level way to organise code than packages, allowing you to define clear boundaries between components, declare dependencies explicitly, and control which packages are accessible to other parts of a program.

Each module has a special descriptor file named module-info.java, placed in the root of its source hierarchy. This file defines the module’s name, the packages it exports, and the other modules it requires.

module com.example.library {
  exports com.example.library.api;
  requires java.sql;
}

In this example, the module is named com.example.library. It makes the package com.example.library.api available to other modules and declares a dependency on the java.sql module from the Java standard library. All other packages remain hidden by default, even if they contain public classes.

Structure of a modular project

A typical modular project mirrors the hierarchy of its packages, with the module-info.java file sitting alongside the top-level package directory:

src/
  com.example.library/
    module-info.java
    com/
      example/
        library/
          api/
            Library.java
          internal/
            Helper.java

The compiler uses module-info.java to verify dependencies and ensure that code cannot access non-exported packages. This explicit structure helps prevent accidental coupling between unrelated parts of large systems.

The requires and exports directives

The requires directive declares a dependency on another module. It ensures that the dependent module is available both during compilation and at runtime.

requires java.xml;
requires com.example.utils;

The exports directive declares which packages in the current module are visible to other modules:

exports com.example.library.api;

All other packages remain inaccessible outside the module, even if they contain public classes. This enforces strong encapsulation and makes module boundaries explicit.

Transitive dependencies

Sometimes, a module depends on another module that itself requires additional modules. To make those secondary dependencies automatically available to modules further up the chain, use the requires transitive directive.

module com.example.library {
  requires transitive com.example.utils;
  exports com.example.library.api;
}

This ensures that any module depending on com.example.library also has access to com.example.utils without having to declare it explicitly.

Opening packages for reflection

Some libraries, such as frameworks or dependency injectors, use reflection to access private members. Because modules restrict access by default, such frameworks can no longer freely reflect on all classes. To allow reflection selectively, you can use the opens directive.

opens com.example.library.internal to com.fasterxml.jackson.databind;

This grants reflective access to the specified package, but only for the named module (com.fasterxml.jackson.databind in this case). You can also open a package to all modules:

opens com.example.library.internal;

Combining exports and opens

It is common to export API packages and open internal ones for reflection. A single module-info.java file can contain both directives:

module com.example.library {
  exports com.example.library.api;
  opens com.example.library.internal to com.fasterxml.jackson.databind;
  requires java.sql;
}

This configuration exposes only the API package for normal use, while permitting controlled reflective access to internal classes during serialization or runtime inspection.

Compiling and running modular programs

Working with modules changes how Java source code is compiled, packaged, and executed. Unlike traditional classpath-based projects, modular programs use a module path, which explicitly lists the locations of compiled modules. This separation allows the compiler and runtime to verify dependencies and prevent unwanted access to non-exported packages.

Compiling a modular project

To compile a modular project, use the javac command with the --module-source-path option. This tells the compiler where to find the module source directories. Each module must have its own folder containing a module-info.java file and its source packages.

project/
  └─ src/
     ├─ com.example.library/
     │   ├─ module-info.java
     │   └─ com/example/library/api/Library.java
     └─ com.example.app/
         ├─ module-info.java
         └─ com/example/app/Main.java

To compile both modules into a separate output directory named mods:

javac -d mods --module-source-path src $(find src -name "*.java")

This command compiles every source file within the src tree, preserving the module structure inside mods. Each module will have its own directory in the output, for example:

mods/
  ├─ com.example.library/
  └─ com.example.app/

Running modular applications

To run a modular program, use the java command with the --module-path option, specifying where compiled modules are located, followed by the --module (or -m) option to identify which module and main class to launch.

java --module-path mods -m com.example.app/com.example.app.Main

The syntax after -m consists of the module name, a slash, and the fully qualified class name containing the main() method. The JVM verifies dependencies and ensures that all required modules are present before execution begins.

Combining modular and non-modular code

During the transition to modular development, projects may mix modular and legacy code. The Java module system supports this through the unnamed module and the automatic module features.

• Unnamed module: Classes placed directly on the classpath belong to the unnamed module. They can read all named modules, but named modules cannot read them in return.
• Automatic module: A JAR placed on the module path without a module-info.java file is treated as an automatic module. Its name is derived from its JAR filename, and all its packages are exported automatically.

These mechanisms simplify migration from older codebases while gradually introducing modularity.

java --module-path mods:libs -m com.example.app/com.example.app.Main

Here, mods contains compiled named modules, and libs contains third-party automatic modules. The JVM resolves both during startup.

Packaging and distributing modules

Once compiled, a module can be packaged into a standard JAR file. To make it modular, include the compiled module-info.class file in the JAR’s root directory:

jar --create --file dist/com.example.library.jar -C mods/com.example.library .

This produces a modular JAR that other projects can reference via the module path. You can verify the module’s metadata using the jar or jdeps tools:

jar --describe-module --file dist/com.example.library.jar

To run a modular JAR directly:

java --module-path dist -m com.example.library/com.example.library.Main

Advantages of modular execution

• Improved dependency management and clearer architecture.
• Smaller runtime images using jlink to include only required modules.
• Enhanced encapsulation and security through controlled package exports.
• More predictable compilation and runtime behaviour across environments.

By compiling and running programs as modules, you gain control over both structure and dependencies. The module system transforms how large Java applications are built, shared, and maintained, bringing consistency and clarity to every stage of development.

Chapter 9: Strings and Text Handling

Text is at the heart of most modern software, and Java provides rich, reliable tools for working with it. From simple messages printed to the console to complex document processing and data exchange, strings play a central role in every kind of Java application. Because text is such a common form of data, the Java platform offers a robust, efficient, and secure set of features for creating, manipulating, and comparing strings.

Unlike languages that treat strings as primitive data types, Java defines them as full-fledged objects of the String class. This design provides immutability (meaning once a string is created it cannot be changed), which guarantees consistency, simplifies reasoning about code, and improves performance through shared internal storage. When you modify a string in Java, you are really creating a new one, a fact that shapes many common programming patterns.

Alongside the String class, Java also provides mutable alternatives like StringBuilder and StringBuffer, which allow efficient construction or modification of text in memory. These classes make it easy to assemble dynamic messages, build file paths, or generate large data blocks without the overhead of creating new string objects each time.

This chapter explores how to create and use strings, how to perform concatenation and comparison, and how to work with text using methods from the standard library. You will also learn about common encoding considerations, such as Unicode and character sets, which ensure that Java programs can handle text in any human language with consistency and reliability.

By mastering Java’s string handling, you will be prepared to work confidently with input and output, file data, formatted text, and any feature that relies on precise control of characters and words. Whether you are processing user input, generating reports, or parsing structured data, understanding strings is essential to writing expressive, correct, and international-ready Java code.

String literals and immutability

In Java, strings are represented by the String class, and the most common way to create one is with a string literal. A string literal is a sequence of characters enclosed in double quotes, for example "Java" or "Hello, world!". When the compiler encounters a string literal, it automatically creates a String object for it in a special area of memory called the string pool.

String greeting = "Hello, world!";
String language = "Java";

Strings created with the same literal value are automatically shared in the string pool. This means that two identical literals refer to the same object, conserving memory and improving performance. The following example demonstrates this behavior:

String a = "Java";
String b = "Java";

System.out.println(a == b);       // true (same pooled object)
System.out.println(a.equals(b));  // true (same content)

Although both a and b contain the same value, the important distinction is that they point to the same object instance in memory. Java ensures that identical literals are interned and reused rather than recreated.

One of the defining features of Java strings is immutability. Once a String object has been created, its contents can never be changed. Any operation that appears to modify a string actually produces a new String object instead.

String name = "Java";
name = name + " Language";

System.out.println(name);  // "Java Language"

Here, concatenating " Language" does not alter the original "Java" string. Instead, a new String object containing "Java Language" is created, and the variable name now refers to it. The original string remains unchanged in memory until it is garbage collected.

This design makes strings thread-safe and predictable, since no code can accidentally alter their contents once created. It also allows the Java runtime to reuse string objects safely without fear of unintended modification.

StringBuilder and StringBuffer

When you need to construct or modify text repeatedly, creating new String objects each time can be inefficient. Because strings are immutable, every concatenation or insertion creates a new object and copies existing data, which wastes both time and memory in large or iterative operations. To solve this, Java provides two mutable alternatives: StringBuilder and StringBuffer.

Both classes let you build and modify strings efficiently by maintaining a resizable buffer of characters. You can append, insert, delete, and replace text directly within the same object, avoiding the overhead of constantly creating new strings. The main difference between the two lies in thread safety.

• StringBuilder is not synchronized and is therefore faster. It should be used in single-threaded code where no concurrent access occurs.
• StringBuffer is synchronized, meaning its methods are thread-safe. It is suitable for situations where multiple threads may access or modify the same buffer.

// Using StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("Java");
sb.append(" ");
sb.append("Language");
String result = sb.toString();
System.out.println(result); // Java Language

The same task could be done with StringBuffer in exactly the same way:

// Using StringBuffer
StringBuffer sbuf = new StringBuffer();
sbuf.append("Hello");
sbuf.append(", ");
sbuf.append("world!");
System.out.println(sbuf.toString()); // Hello, world!

In most modern programs, StringBuilder is preferred because its performance is better in single-threaded environments, which covers the majority of cases. The StringBuffer class exists mainly for backward compatibility with older Java code that required synchronization.

String query = new StringBuilder()
  .append("SELECT * FROM users WHERE name = '")
  .append("Alice")
  .append("' AND active = 1;")
  .toString();

System.out.println(query);

When you call toString(), the buffer’s current contents are converted into an immutable String. You can continue modifying the builder afterward without affecting the string already produced.

Formatting text with printf and format

Java provides built-in tools for producing formatted text using the printf() and format() methods. These methods work similarly to C-style formatting functions, allowing you to insert variable values into strings using format specifiers. They are especially useful when generating structured output such as reports, tables, or logs.

The System.out.printf() method prints formatted text directly to standard output, while String.format() creates and returns a formatted string that you can store or reuse later.

int count = 5;
double price = 9.99;
String item = "Widget";

System.out.printf("You bought %d %s(s) for a total of $%.2f%n", count, item, count * price);

Here, each format specifier (beginning with %) represents a placeholder for a value:

Each specifier can include optional flags and width controls to align and format output neatly:

System.out.printf("|%10s|%5d|%8.2f|%n", "Item", 12, 4.5);
System.out.printf("|%-10s|%5d|%8.2f|%n", "Item", 12, 4.5);

The first example right-aligns text within a 10-character field, while the second left-aligns it using -. These formatting options make it easy to produce tabular text layouts directly from code.

String message = String.format("User %s has %d new notifications.", "Alice", 3);
System.out.println(message);

Formatting specifiers also support advanced options for locale-aware output, letting you automatically adapt number and date formats to regional conventions. This is done by providing a Locale argument:

import java.util.Locale;

double value = 1234.56;
System.out.println(String.format(Locale.FRANCE, "Value: %,.2f", value));
System.out.println(String.format(Locale.US, "Value: %,.2f", value));

In this example, the comma and period are swapped depending on locale conventions (1 234,56 in France versus 1,234.56 in the US). The , flag adds grouping separators to large numbers automatically.

Regular expressions

Regular expressions, often called regex, are a concise and powerful way to describe and manipulate patterns in text. They allow you to search, match, and replace sequences of characters according to rules you define. Java’s java.util.regex package provides a complete implementation of regular expressions through two main classes: Pattern and Matcher.

With regex, you can validate input (such as email addresses or postcodes), extract structured data from text, or perform advanced find-and-replace operations. Because Java’s regex engine is integrated directly into the standard library, you can use it anywhere without external dependencies.

The pattern and matcher classes

The Pattern class represents a compiled regular expression, while the Matcher class applies that pattern to a given input string. To use them, you first compile a pattern, then create a matcher to search within text.

import java.util.regex.*;

String text = "The year is 2025.";
Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
  System.out.println("Found number: " + matcher.group());
}

This code finds and prints the first sequence of digits in the text. The double backslashes are required because Java string literals also use backslashes for escape sequences, so "\\d+" represents the regex \d+ (one or more digits).

Common regex patterns

Regular expressions use a combination of literal characters and special symbols (called metacharacters) to define patterns. Here are some of the most useful constructs:

Combining these constructs lets you describe complex text structures concisely. For example:

// Match a simple email address
Pattern email = Pattern.compile("[\\w.-]+@[\\w.-]+\\.\\w+");
Matcher m = email.matcher("contact@example.com");

if (m.matches()) {
  System.out.println("Valid email");
}

Searching and replacing

The Matcher class provides methods such as find(), matches(), group(), and replaceAll() for practical text operations. For instance, you can extract or transform multiple matches within a string:

String text = "cat, dog, bird";
Pattern pattern = Pattern.compile("\\w+");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
  System.out.println("Animal: " + matcher.group());
}

You can also perform replacements directly using regular expressions:

String input = "2025-10-26";
String result = input.replaceAll("-", "/");
System.out.println(result); // 2025/10/26

More complex replacements can use groups, where parts of the matched text are captured and reinserted using $1, $2, and so on:

String name = "Nixon, Robin";
String formatted = name.replaceAll("(\\w+), (\\w+)", "$2 $1");
System.out.println(formatted); // Robin Nixon

Flags and options

Regular expressions in Java can be compiled with flags that alter their behavior. You can combine flags using the bitwise OR (|) operator.

Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("I love Java!");
System.out.println(m.find()); // true

Encoding, Unicode, and character sets

Modern software must handle text from many languages, scripts, and symbol systems. To do this reliably, Java uses the Unicode standard for all character data, ensuring that programs can represent and process text from any part of the world. Every char in Java and every character in a String is a Unicode value, not a raw byte. This design makes Java inherently portable and internationalized.

Unicode assigns a unique code point to every character, covering alphabets, ideograms, punctuation, emoji, and even control symbols. Code points are usually written in hexadecimal, prefixed with U+. For example, U+0041 represents the letter A, and U+1F600 represents the grinning face emoji 😀.

char letter = 'A';              // U+0041
char symbol = '\u03A9';         // Greek capital omega (Ω)
String emoji = "\uD83D\uDE00";  // 😀 (represented as a surrogate pair)

Java’s internal string representation uses UTF-16 encoding, meaning that most common characters occupy a single 16-bit char, while characters outside the Basic Multilingual Plane (BMP) use two 16-bit units known as a surrogate pair. This allows Java to represent the full range of Unicode characters transparently.

Character encoding and byte conversion

Although Java represents text internally as Unicode, data stored in files or transmitted over networks must eventually be converted into bytes. This conversion depends on a character encoding, such as UTF-8 or ISO-8859-1. The encoding determines how Unicode characters are mapped to byte sequences.

The String and java.nio.charset APIs provide methods to control this process explicitly. For example:

import java.nio.charset.StandardCharsets;

String text = "Café";
byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
String decoded = new String(bytes, StandardCharsets.UTF_8);

System.out.println(decoded); // Café

This code converts a string to a UTF-8 byte array and back again safely. Using a fixed, explicit charset avoids platform-dependent behavior and ensures consistent results across systems.

Working with character sets

The Charset class in java.nio.charset provides access to all available encodings supported by the Java runtime. You can query and list them or use them when reading and writing files.

import java.nio.charset.Charset;

for (String name : Charset.availableCharsets().keySet()) {
  System.out.println(name);
}

Some of the most commonly used encodings are:

• UTF-8 — The dominant encoding for web and cross-platform text; variable length and efficient for ASCII-based data.
• UTF-16 — Java’s internal representation; fixed width for most characters, two units for extended symbols.
• ISO-8859-1 — Latin-1; a legacy single-byte encoding for Western European languages.
• US-ASCII — 7-bit encoding for basic English characters only.

Unicode awareness in strings and characters

Because of UTF-16’s use of surrogate pairs, a single visual character may consist of more than one char. This distinction matters when iterating over strings or measuring their lengths.

String smile = "😀";
System.out.println(smile.length());  // 2 (two UTF-16 units)
System.out.println(smile.codePointCount(0, smile.length()));
// 1 (one Unicode code point)

To work safely with Unicode text, use the codePointAt() and codePoints() methods instead of direct character indexing. These handle surrogate pairs correctly and prevent cutting characters in half during iteration or substring operations.

smile.codePoints().forEach(cp -> 
  System.out.println(Integer.toHexString(cp))
);

Chapter 10: Arrays and Collections

Programs often need to manage groups of related values rather than single variables. Whether storing a list of numbers, a set of objects, or a mapping between keys and values, Java provides structured ways to organize and manipulate data efficiently. These are the arrays and collections of the Java language and standard library.

Arrays are the simplest form of data grouping in Java. They hold a fixed number of elements of the same type and provide fast, direct access to each element by index. Arrays are ideal for predictable, compact storage when the size of the data is known in advance. However, because they cannot grow or shrink dynamically, more flexible tools are often needed for real-world applications.

To handle dynamic data structures, Java introduces the Collections Framework, a unified system of interfaces and classes for storing and manipulating groups of objects. It includes familiar structures such as ArrayList, HashSet, and HashMap, each designed for specific use cases like ordered lists, unique sets, or key–value pairs. Collections bring together performance, consistency, and ease of use under a common API that works seamlessly with modern Java features like generics, streams, and lambda expressions.

This chapter introduces arrays and the core collection types, showing how to create, populate, and iterate over them. You will learn when to use each structure, how to choose between them for efficiency, and how generics make type-safe collections possible without repetitive code. Together, arrays and collections form the backbone of most Java programs, allowing you to organize information clearly and process it at scale.

Array creation and initialization

An array in Java is a fixed-size sequence of elements, all of which share the same type. Arrays provide indexed access to their contents, beginning at index 0 and extending to length - 1. Because their size is fixed when created, arrays are efficient for storing known quantities of data but cannot grow or shrink dynamically after initialization.

You declare an array by specifying the type of its elements followed by square brackets, and then create it using the new keyword:

int[] numbers = new int[5];
String[] names = new String[3];

These examples create arrays capable of holding five integers and three strings respectively. When an array is created, all elements are automatically initialized to default values based on their type: 0 for numeric types, false for booleans, and null for object references.

System.out.println(numbers[0]); // 0
System.out.println(names[0]);   // null

Individual elements are accessed using their index, and can be assigned values just like ordinary variables:

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

System.out.println(numbers[1]); // 20

Alternatively, arrays can be initialized with predefined values using an array initializer. This syntax both declares and fills the array in one step:

int[] primes = {2, 3, 5, 7, 11};
String[] colors = {"red", "green", "blue"};

When you use an initializer, Java automatically determines the array’s length from the number of provided elements. You can also separate the declaration and initialization if preferred:

int[] scores;
scores = new int[] {90, 80, 70, 60};

Attempting to access an element outside the valid index range will cause a java.lang.ArrayIndexOutOfBoundsException. This is a runtime error that immediately stops program execution, so index checks are important when iterating over arrays.

int[] data = {1, 2, 3};
System.out.println(data[3]); // Error: index out of bounds

Multidimensional arrays

Java supports arrays of arrays, known as multidimensional arrays. These allow you to represent structured data such as matrices, grids, or tables. Although they are sometimes called “two-dimensional arrays,” in Java they are actually arrays whose elements are themselves arrays, which provides flexibility but also means that rows can have different lengths if needed.

The most common form is the two-dimensional array, which you can declare and create like this:

int[][] matrix = new int[3][4];

This creates an array of three rows and four columns. All elements are initialized to 0. You can assign or access values using two indices, the first for the row and the second for the column:

matrix[0][0] = 10;
matrix[1][2] = 25;

System.out.println(matrix[1][2]);  // 25

You can also initialize multidimensional arrays directly with nested braces:

int[][] numbers = {
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9}
};

Each inner brace defines a row. The outer array contains three elements (rows), each of which is an array of three integers. You can mix different lengths for inner arrays to create a jagged array:

int[][] jagged = {
  {1, 2, 3},
  {4, 5},
  {6, 7, 8, 9}
};

In this case, jagged[0].length is 3, jagged[1].length is 2, and so on. This flexibility can be useful for representing irregular data sets.

Iterating over multidimensional arrays

You can use nested loops to iterate through all elements of a multidimensional array. The outer loop handles rows, and the inner loop handles columns:

for (int i = 0; i < matrix.length; i++) {
  for (int j = 0; j < matrix[i].length; j++) {
    System.out.print(matrix[i][j] + " ");
  }
  System.out.println();
}

Alternatively, the enhanced for-each loop provides a simpler and more readable form when you do not need explicit indices:

for (int[] row : numbers) {
  for (int value : row) {
    System.out.print(value + " ");
  }
  System.out.println();
}

Collections Framework overview

The Java Collections Framework is a unified architecture for storing and manipulating groups of objects. It provides a set of interfaces and classes that make it easy to manage dynamic data, such as lists of items, sets of unique values, queues, and mappings between keys and values. Unlike arrays, collections can grow and shrink automatically as elements are added or removed, offering flexibility without manual resizing or index management.

At the heart of the framework are a few core interfaces that define common operations, and a number of classes that implement them in different ways for performance and behavior. The main interfaces include:

• Collection<E> — The root interface for most data containers. It defines methods such as add(), remove(), contains(), and size().
• List<E> — An ordered collection that allows duplicate elements and provides positional access via indexes.
• Set<E> — A collection that does not allow duplicates and ignores insertion order (unless otherwise specified).
• Map<K,V> — A structure that stores key–value pairs for efficient lookup and retrieval.
• Queue<E> and Deque<E> — Interfaces for ordered collections that process elements in specific sequences (FIFO, LIFO, etc.).

These interfaces form a hierarchy under java.util, which all concrete collection classes follow. This design allows you to switch between implementations (such as from ArrayList to LinkedList) without rewriting surrounding code, since both share the same interface.

import java.util.*;

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

for (String name : names) {
  System.out.println(name);
}

This example works the same way if you change ArrayList to LinkedList, because both implement List<E>. The uniform API makes it easy to focus on logic rather than data structure details.

Common collection implementations

Key benefits of the Collections Framework

• Consistency: All collections share common method names and conventions.
• Flexibility: You can change implementations without changing your code’s logic.
• Performance: Each class is optimized for specific use cases, letting you choose the right one for your needs.
• Interoperability: Collections integrate smoothly with streams, iterators, and enhanced for-loops.

Lists, Sets, and Maps

The three most widely used types of collections in Java are lists, sets, and maps. Each serves a distinct purpose and offers a different way to organize data. Understanding their differences is essential for choosing the right structure for your needs.

Lists

A List<E> is an ordered collection that allows duplicate elements. Each element has a defined position (index) starting at 0, and the order of elements is preserved as they are added. Lists are ideal when you need sequential access or when duplicates matte. For example, for storing items in the order they were entered or maintaining a history of actions.

The two most common implementations are ArrayList and LinkedList:

import java.util.*;

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.add("Alice"); // duplicates allowed

System.out.println(names.get(1)); // Bob

for (String name : names) {
  System.out.println(name);
}

ArrayList uses an internal array, offering fast random access (get()) but slower insertions or deletions in the middle of the list. LinkedList uses linked nodes, making it efficient for frequent insertions and removals but slower for indexed access.

Sets

A Set<E> is a collection that does not allow duplicate elements. Sets are useful when you only care about whether an item exists, not how many times it appears. They also ignore insertion order unless you use an implementation that preserves it.

The main set implementations are HashSet, LinkedHashSet, and TreeSet:

import java.util.*;

Set<String> colors = new HashSet<>();
colors.add("red");
colors.add("green");
colors.add("blue");
colors.add("red"); // ignored, already present

System.out.println(colors.size()); // 3
System.out.println(colors.contains("green")); // true

• HashSet stores elements in no particular order and offers fast add(), remove(), and contains() operations.
• LinkedHashSet preserves the order in which elements were added.
• TreeSet stores elements in sorted order, according to natural ordering or a provided comparator.

Maps

A Map<K,V> associates unique keys with corresponding values. Maps are not technically part of the Collection hierarchy but are a fundamental part of the Collections Framework. You can think of them as dictionaries or lookup tables, where each key maps to exactly one value.

import java.util.*;

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
ages.put("Charlie", 35);

System.out.println(ages.get("Bob")); // 25
System.out.println(ages.containsKey("Alice")); // true

Keys in a map must be unique. If you insert a new value using an existing key, the previous value is replaced. The three main map implementations are HashMap, LinkedHashMap, and TreeMap:

• HashMap offers constant-time lookups for most operations but does not preserve order.
• LinkedHashMap remembers the order of insertion or access, making it suitable for caches or predictable iteration order.
• TreeMap maintains its keys in sorted order.

for (String key : ages.keySet()) {
  System.out.println(key + " is " + ages.get(key));
}

Iterators and enhanced for loops

Java provides several ways to step through the elements of a collection. The most flexible is the Iterator interface, which works with any type that implements Collection<E>. For simpler, read-only traversal, the enhanced for loop (also called the for-each loop) offers a cleaner and more concise syntax. Understanding both approaches will help you navigate and manipulate collections effectively.

Using an Iterator

An Iterator provides sequential access to the elements of a collection without exposing its internal structure. It supports three key methods:

• hasNext() — Returns true if there is another element to read.
• next() — Returns the next element in the sequence.
• remove() — Removes the last element returned by next() (optional operation).

import java.util.*;

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

Iterator<String> it = names.iterator();

while (it.hasNext()) {
  String name = it.next();
  System.out.println(name);
}

The iterator automatically handles the details of collection traversal. When the end is reached, hasNext() returns false and the loop exits. Calling next() after that point will throw a NoSuchElementException.

Iterator<String> it = names.iterator();
while (it.hasNext()) {
  String name = it.next();
  if (name.startsWith("B")) {
    it.remove();  // safe removal during iteration
  }
}

Enhanced for loops

The enhanced for loop offers a simpler, more readable way to iterate through arrays and collections when you do not need to modify their structure. It automatically retrieves each element in order and works with any class that implements the Iterable<E> interface.

List<Integer> numbers = List.of(10, 20, 30, 40);

for (int n : numbers) {
  System.out.println(n);
}

This form eliminates the need to call iterator() or use index variables, reducing the risk of off-by-one errors and improving readability. The enhanced for loop can also be used with arrays:

int[] scores = {90, 80, 70};

for (int s : scores) {
  System.out.println(s);
}

Iterating over maps

Maps do not directly implement Iterable because they store key–value pairs rather than single elements. However, you can iterate over their entries, keys, or values through specific views returned by methods like entrySet(), keySet(), and values().

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 88);
scores.put("Charlie", 92);

// Iterate through keys
for (String name : scores.keySet()) {
  System.out.println(name);
}

// Iterate through values
for (int score : scores.values()) {
  System.out.println(score);
}

// Iterate through key–value pairs
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
  System.out.println(entry.getKey() + ": " + entry.getValue());
}

Chapter 11: Generics and Type Safety

As Java evolved, one of its most important advancements was the introduction of generics in Java 5. Generics allow you to define classes, interfaces, and methods that operate on types specified as parameters. This feature provides both flexibility and type safety, ensuring that programs can handle a wide range of data without sacrificing compile-time error checking.

Before generics, Java relied heavily on Object references and explicit casting, which often led to runtime errors and unclear code. With generics, those casts are eliminated because the compiler enforces type correctness. For example, a List<String> can only hold strings, and attempting to insert an incompatible object will cause a compile-time error rather than an exception at runtime.

Generics make your code more expressive and self-documenting. Instead of writing multiple versions of the same class or method for different data types, you can write a single generic version that adapts to any type the caller specifies. This concept lies at the heart of modern Java’s design philosophy: type safety without redundancy.

Generics are now central to Java’s Collections Framework, stream APIs, and most modern libraries. Understanding how to declare, use, and constrain them with bounds is essential for writing robust, reusable, and maintainable Java code.

Generic classes and methods

Generics extend Java’s type system by allowing you to define classes and methods that can work with different data types while maintaining type safety. Instead of writing a class that operates on a specific type, you can define it with one or more type parameters, which act as placeholders for real types supplied when the class or method is used.

A generic class is declared by adding angle brackets (<>) after the class name, containing one or more type parameters. The convention is to use single uppercase letters such as T (type), E (element), K (key), and V (value), depending on context.

// A simple generic class
public class Box<T> {
  private T value;

  public void set(T value) {
    this.value = value;
  }

  public T get() {
    return value;
  }
}

Here, T is a placeholder for any type. When you create a Box object, you specify what T should be:

Box<String> textBox = new Box<>();
textBox.set("Hello, Java!");
String message = textBox.get();

Box<Integer> numberBox = new Box<>();
numberBox.set(42);
int number = numberBox.get();

The compiler ensures that each Box instance only stores and returns objects of the declared type. This eliminates the need for casting and prevents type errors at runtime.

Methods can also be made generic, even inside non-generic classes. To declare a generic method, place the type parameter list before the return type. This allows the method to work with any data type independently of the class itself.

public class Util {
  public static <T> void printTwice(T item) {
    System.out.println(item);
    System.out.println(item);
  }
}

When calling a generic method, the compiler infers the type argument automatically based on the argument provided:

Util.printTwice("Hello");
Util.printTwice(123);

In both calls above, the same method works seamlessly with different types because the type parameter T adapts to the value passed in each case. This flexibility makes generics especially useful for utility classes and data structures that must handle many kinds of objects.

Bounded type parameters

In many cases, a generic type parameter can represent any type at all. However, sometimes you need to restrict it so that only certain kinds of types are allowed. Java provides this control through bounded type parameters, which define upper or lower limits on the types that may be used as arguments.

An upper bound restricts a type parameter to be a specific class or any subclass of it. This is done using the extends keyword (which applies to both classes and interfaces). For example, you might want to create a method that works only with numeric types:

// Upper-bounded type parameter
public class MathUtil {
  public static <T extends Number> double square(T value) {
    return value.doubleValue() * value.doubleValue();
  }
}

Here, T can represent any class that extends Number (such as Integer, Double, or Float). This allows the method to use Number methods like doubleValue() safely, because the compiler guarantees that T will have them.

System.out.println(MathUtil.square(4));    // 16.0
System.out.println(MathUtil.square(2.5));  // 6.25

You can also set multiple bounds by separating them with an ampersand (&). The first bound must be a class (if any), followed by one or more interfaces. For example:

public class DataProcessor<T extends Number & Comparable<T>> {
  public boolean isGreater(T a, T b) {
    return a.compareTo(b) > 0;
  }
}

In this case, T must be both a Number and implement Comparable<T>. This combination lets you work safely with values that are both numeric and comparable.

A lower bound restricts a type parameter to be a specific class or any superclass of it. This is defined using the super keyword and appears most often with wildcards rather than named parameters (covered later). Lower bounds are useful when you need to write to a collection or ensure that an object can safely accept values of a certain type or its subclasses.

// Example with lower-bounded wildcard
public static void addNumber(List<? super Integer> list) {
  list.add(10);
  list.add(20);
}

Here, ? super Integer means the list may be of type Integer or any of its supertypes (such as Number or Object), ensuring that adding Integer elements is always safe.

Wildcards and variance

Wildcards are a special feature of Java generics that allow a degree of flexibility when working with parameterized types. They are represented by a question mark (?) and stand for “an unknown type.” Wildcards are particularly important when defining methods that should accept collections or objects of related types without losing type safety.

Consider this example:

List<Integer> ints = List.of(1, 2, 3);
List<Number> nums = ints;  // compile-time error

Although Integer is a subclass of Number, List<Integer> is not a subclass of List<Number>. Java generics are invariant, meaning that generic types with different type parameters are considered unrelated, even if those parameters have an inheritance relationship.

Wildcards solve this problem by introducing controlled forms of variance through extends and super bounds.

Upper-bounded wildcards

An upper-bounded wildcard uses the extends keyword to specify that the unknown type must be a specific class or subclass of it. This allows reading from a structure safely, because all elements are guaranteed to be at least of that type.

public static double sumList(List<? extends Number> list) {
  double total = 0;
  for (Number n : list) {
    total += n.doubleValue();
  }
  return total;
}

This method can accept a List<Integer>, List<Double>, or any list of a subclass of Number. However, you cannot add elements to list inside the method because the compiler cannot be sure of the exact subtype.

Lower-bounded wildcards

A lower-bounded wildcard uses the super keyword to restrict the unknown type to be a given class or any of its supertypes. This is useful when you want to write data into a collection.

public static void addNumbers(List<? super Integer> list) {
  list.add(1);
  list.add(2);
}

Here, the list may be a List<Integer>, List<Number>, or List<Object>. All of them can safely accept Integer values because Integer is compatible with each of those supertype relationships.

Unbounded wildcards

When no bound is specified, a simple ? can be used to indicate a parameterized type of any kind:

public static void printList(List<?> list) {
  for (Object item : list) {
    System.out.println(item);
  }
}

This version can accept any List, regardless of its element type, but since the exact type is unknown, you can only treat elements as Object within the method.

The PECS rule

The classic guideline for choosing between extends and super is the PECS rule: Producer Extends, Consumer Super. Use ? extends when your code reads values from a structure, and ? super when it writes values into it.

// Producer: you only read from it
List<? extends Number> source = List.of(1, 2, 3);
double total = sumList(source);

// Consumer: you only write to it
List<? super Integer> target = new ArrayList<>();
addNumbers(target);

Type inference

Java’s type system is strongly and statically typed, but it has evolved to reduce unnecessary repetition in code. Type inference allows the compiler to deduce a variable’s type automatically from its context. This keeps programs concise without losing the safety guarantees of explicit typing.

There are two main forms of type inference in modern Java: the diamond operator (<>) and the var keyword. Both rely on the compiler’s ability to determine types based on usage, rather than requiring you to spell them out explicitly.

The diamond operator

Before Java 7, every generic class instantiation required repeating the full type on both sides of an assignment:

List<String> names = new ArrayList<String>();

From Java 7 onward, the diamond operator (<>) lets the compiler infer the type arguments automatically from the variable declaration:

List<String> names = new ArrayList<>();

Here, the compiler examines the left-hand side (List<String>) and infers that the new ArrayList should also store String objects. The resulting bytecode is identical to the longer form, but the syntax is cleaner and easier to maintain.

The var keyword

Introduced in Java 10, the var keyword allows local variables to be declared without explicitly naming their type. The compiler infers the type from the initializer expression on the same line.

var message = "Hello, Java";         // inferred as String
var count = 42;                      // inferred as int
var list = new ArrayList<String>();  // inferred as ArrayList<String>

Type inference occurs entirely at compile time. Once compiled, each variable has a fixed, concrete type—var does not make Java dynamically typed. You cannot declare a var without an initializer, because the compiler needs that value to determine the type.

var name; // error: cannot infer type without initializer

Combining inference with generics

Type inference becomes especially useful when combined with generics. It allows you to focus on the logic rather than repeating lengthy type information:

var map = new HashMap<String, List<Integer>>();
map.put("scores", List.of(10, 20, 30));

Here, the compiler infers map as HashMap<String, List<Integer>>. This is both safe and clear because the right-hand side contains enough information to deduce the type unambiguously.

Type inference reflects Java’s modern balance between safety and expressiveness. It keeps code clean while preserving the compiler’s full understanding of types, ensuring that mistakes are caught early without adding visual clutter to everyday code.

Common generic utilities

Generics are deeply integrated into the Java ecosystem, and many core utilities rely on them to provide flexible yet type-safe functionality. Understanding how these generic utilities work helps you write cleaner, more reusable code and take advantage of the Java Standard Library’s full expressive power.

Collections Framework

The most visible use of generics is in the Collections Framework. Every collection interface and implementation—such as List<E>, Set<E>, Map<K, V>, and Queue<E>—is parameterized, allowing you to define what types of objects a collection holds.

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 87);

The compiler enforces that each collection contains only the specified element types. This prevents class cast errors and improves code readability by making type expectations explicit.

Generic helper methods

Many Java utility classes use generic methods to work with objects of arbitrary types while maintaining strong typing. For example, java.util.Collections provides methods like sort() and binarySearch() that operate generically on lists of comparable elements.

List<Integer> numbers = Arrays.asList(5, 1, 3);
Collections.sort(numbers);  // infers T as Integer

int index = Collections.binarySearch(numbers, 3);
System.out.println("Found at index: " + index);

These methods use type bounds internally (such as <T extends Comparable<? super T>>) to ensure that only sortable objects are accepted, enforcing correctness at compile time.

Generic factory methods

Factory methods that return typed instances are another common generic pattern. For example, the List.of() and Map.of() methods introduced in Java 9 are generic factories that infer the types of their elements automatically:

var list = List.of("red", "green", "blue");  // List<String>
var map  = Map.of("A", 1, "B", 2, "C", 3);   // Map<String, Integer>

These methods demonstrate the combination of generics and type inference, producing strongly typed collections with minimal syntax.

The Optional class

The Optional<T> class, introduced in Java 8, is another powerful generic utility. It represents a value that may or may not be present, helping you avoid null-related bugs in a type-safe way.

Optional<String> name = Optional.of("Alice");
name.ifPresent(System.out::println);

Optional<String> empty = Optional.empty();
System.out.println(empty.orElse("Unknown"));

Because Optional is generic, the compiler enforces that only a value of type T can be contained or returned, ensuring consistency throughout your code.

Streams and lambda expressions

The Stream<T> API also relies heavily on generics. Each stream is parameterized by the type of elements it processes, and intermediate operations preserve type information throughout the pipeline.

List<String> names = List.of("Alice", "Bob", "Charlie");

names.stream()
     .filter(n -> n.length() > 3)
     .map(String::toUpperCase)
     .forEach(System.out::println);

Each operation returns another Stream<T> or Stream<R>, depending on whether the operation transforms the data type. The compiler checks that each lambda expression or method reference matches the expected type signature, keeping the entire stream type-safe.

From collections to streams, factory methods, and optionals, generics form the backbone of modern Java design. They let you express intent clearly, prevent common errors, and enable the creation of reusable libraries that adapt safely to any data type.

Chapter 12: Exception Handling in Depth

Even in well-written programs, unexpected conditions occur: a file might not exist, network connections can fail, user input may be invalid, or an array index could fall outside its bounds. Java provides a structured, consistent way to handle such problems through its exception handling system. Exceptions let your code detect and respond to errors gracefully rather than crashing or producing undefined behavior.

At its core, exception handling separates normal program logic from error recovery. When something goes wrong, Java generates an exception object that describes the problem. This object is then thrown up the call stack until a suitable piece of code catches it and takes appropriate action. This mechanism ensures that errors can be managed predictably, without littering every line of code with manual checks.

Java’s exception model is one of its defining features, balancing safety with flexibility. It enforces compile-time checking for certain kinds of recoverable problems while allowing others to propagate naturally at runtime. This dual system (checked and unchecked exceptions) encourages developers to handle foreseeable errors explicitly while still maintaining performance and readability.

This chapter explores Java’s exception hierarchy, how to use try, catch, and finally blocks effectively, and how to create and throw custom exceptions when the standard types do not fit. You will also learn how exceptions interact with resources, methods, and class design, and how best practices help keep your error handling clear, efficient, and reliable.

Checked vs unchecked exceptions

Java divides exceptions into two main categories: checked and unchecked. This distinction determines whether the compiler requires you to handle a particular kind of exception explicitly. Understanding the difference is fundamental to writing clear and robust Java code.

Checked exceptions

Checked exceptions represent conditions that a well-written program should anticipate and handle. These are typically external or recoverable problems, such as missing files, failed network connections, or invalid input formats. The compiler enforces that checked exceptions are either caught in a try block or declared in a method’s throws clause.

import java.io.*;

public class ReaderExample {
  public static void main(String[] args) {
    try {
      BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
      System.out.println(reader.readLine());
      reader.close();
    } catch (IOException e) {
      System.out.println("Error reading file: " + e.getMessage());
    }
  }
}

Here, FileReader and readLine() may throw an IOException. The compiler will not allow the program to compile unless the exception is either caught or declared with throws IOException. This ensures that developers acknowledge and plan for predictable external errors.

Unchecked exceptions

Unchecked exceptions represent programming errors or logic faults that generally cannot or should not be recovered from. These derive from RuntimeException and include common issues such as dividing by zero, null references, or invalid array indexes.

public class DivisionExample {
  public static void main(String[] args) {
    int a = 10;
    int b = 0;
    System.out.println(a / b);  // throws ArithmeticException
  }
}

The compiler does not require you to catch or declare ArithmeticException, NullPointerException, or similar runtime errors. They can still be caught if desired, but Java assumes that these usually reflect bugs rather than expected conditions, and therefore should be fixed rather than handled.

The Throwable hierarchy

All exceptions in Java inherit from the class Throwable. It has two direct subclasses: Error and Exception. The Error branch represents serious problems (like OutOfMemoryError) that applications usually cannot recover from, while Exception covers both checked and unchecked errors that your code can potentially handle.

Throwable
 ├── Error
 │    ├── OutOfMemoryError
 │    └── StackOverflowError
 └── Exception
      ├── IOException                    // checked
      ├── SQLException                   // checked
      └── RuntimeException
           ├── NullPointerException      // unchecked
           ├── ArithmeticException       // unchecked
           └── IndexOutOfBoundsException // unchecked

This hierarchy makes it easy to understand where different exceptions fit in the language model. In practice, checked exceptions signal recoverable conditions, while unchecked exceptions signal programming faults.

Throwing and propagating exceptions

When an exceptional condition occurs, Java signals it by throwing an exception. Throwing creates an exception object that travels up the call stack until a suitable catch block handles it, or until the program terminates if none is found. This process is known as propagation.

Throwing exceptions

You can throw an exception manually using the throw statement. The exception must be an instance of a class derived from Throwable.

public class Division {
  public static int divide(int a, int b) {
    if (b == 0) {
      throw new ArithmeticException("Cannot divide by zero");
    }
    return a / b;
  }

  public static void main(String[] args) {
    System.out.println(divide(10, 0));
  }
}

Here, if b is zero, an ArithmeticException is created and thrown. The program terminates unless a catch block in the call stack handles it. Throwing exceptions deliberately allows you to communicate specific problems from within methods to their callers.

Declaring exceptions with throws

If a method can throw a checked exception, it must declare this in its signature using the throws keyword. This informs callers that they must either handle or propagate the exception.

import java.io.*;

public class FileUtil {
  public static String readFile(String name) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader(name));
    String line = reader.readLine();
    reader.close();
    return line;
  }
}

Any method that calls readFile() must now either handle the IOException in a try/catch block or declare it again with throws IOException. This rule ensures that checked exceptions are never ignored accidentally.

public static void main(String[] args) {
  try {
    System.out.println(FileUtil.readFile("data.txt"));
  } catch (IOException e) {
    System.out.println("File error: " + e.getMessage());
  }
}

Propagation through the call stack

When an exception is thrown, Java looks for a matching catch block starting in the current method. If none exists, the exception propagates upward to the method that called it, continuing until a handler is found or until the JVM terminates the program.

public class ChainExample {
  static void levelOne() { levelTwo(); }

  static void levelTwo() {
    throw new RuntimeException("Something went wrong");
  }

  public static void main(String[] args) {
    levelOne();
  }
}

Since levelTwo() throws an unchecked exception and levelOne() does not catch it, the exception propagates to main(). Because no handler exists there either, the program ends and prints a stack trace showing where the problem originated and how it propagated.

Rethrowing exceptions

Sometimes a method catches an exception only to perform some cleanup or logging before rethrowing it. This is known as rethowing the exception. You can either throw the same instance or wrap it in another exception to add context.

try {
  riskyOperation();
} catch (IOException e) {
  System.err.println("I/O error while processing file");
  throw e;  // rethrow same exception
}

Alternatively, you can wrap the caught exception in another to preserve the original cause:

try {
  riskyOperation();
} catch (IOException e) {
  throw new RuntimeException("Failed during operation", e);
}

This approach keeps the original exception available for inspection via getCause(), while allowing you to convert a checked exception into an unchecked one when appropriate.

Creating custom exceptions

Although Java provides a rich set of built-in exceptions, there are times when you need to signal problems that are specific to your application or domain. In these cases, you can define your own custom exception classes. Custom exceptions make your code more readable and self-documenting by expressing precise failure conditions through meaningful names.

Defining a custom checked exception

To create a checked exception, extend the class Exception (or a subclass of it). Checked exceptions represent problems that the caller is expected to handle explicitly.

public class InvalidAgeException extends Exception {
  public InvalidAgeException(String message) {
    super(message);
  }
}

This new exception can now be thrown from a method and must be declared or handled wherever it is used:

public class UserValidator {
  public static void validateAge(int age) throws InvalidAgeException {
    if (age < 0 || age > 120) {
      throw new InvalidAgeException("Age must be between 0 and 120");
    }
  }

  public static void main(String[] args) {
    try {
      validateAge(150);
    } catch (InvalidAgeException e) {
      System.out.println("Validation error: " + e.getMessage());
    }
  }
}

Because InvalidAgeException extends Exception, it is checked, and the compiler ensures it is properly declared or caught.

Defining a custom unchecked exception

For programming or logical errors that callers are not expected to recover from, extend RuntimeException instead. These exceptions are unchecked and do not need to be declared in method signatures.

public class ConfigurationException extends RuntimeException {
  public ConfigurationException(String message) {
    super(message);
  }

  public ConfigurationException(String message, Throwable cause) {
    super(message, cause);
  }
}

Unchecked exceptions are useful for conditions that represent bugs, invalid state transitions, or violations of assumptions that should not occur in correct code.

public class ConfigLoader {
  public static void load(String path) {
    if (path == null) {
      throw new ConfigurationException("Configuration path cannot be null");
    }
    // Load configuration...
  }
}

Best practices for custom exceptions

• Choose clear, descriptive names that reflect the specific failure condition (for example, InvalidOrderStateException, UserNotFoundException).
• Group related exceptions under a common superclass if your application defines many custom types.
• Provide constructors that accept a message and optionally a cause to preserve stack traces.
• Document when and why your custom exceptions are thrown.
• Prefer checked exceptions for recoverable conditions and unchecked ones for programming logic errors.

public class DataException extends Exception {
  public DataException(String message) { super(message); }
  public DataException(String message, Throwable cause) { super(message, cause); }
}

public class MissingRecordException extends DataException {
  public MissingRecordException(String message) { super(message); }
}

This small hierarchy expresses domain-specific problems clearly while maintaining consistency with Java’s exception model.

Try-with-resources and AutoCloseable

Many Java operations involve resources that must be released after use—such as files, sockets, streams, or database connections. Failing to close these resources properly can lead to memory leaks or locked system handles. The try-with-resources statement, introduced in Java 7, automates this process by ensuring that each resource is closed safely and reliably, even if an exception occurs.

The traditional approach

Before try-with-resources, developers had to close resources manually in a finally block, which often made code verbose and error-prone:

BufferedReader reader = null;
try {
  reader = new BufferedReader(new FileReader("data.txt"));
  System.out.println(reader.readLine());
} catch (IOException e) {
  System.out.println("Error reading file: " + e.getMessage());
} finally {
  try {
    if (reader != null) {
      reader.close();
    }
  } catch (IOException e) {
    System.out.println("Error closing reader");
  }
}

This pattern works but clutters the logic and increases the risk of forgetting to close a resource properly.

Using try-with-resources

The try-with-resources statement simplifies cleanup by automatically closing any resource that implements the AutoCloseable interface. Resources are declared in parentheses after the try keyword and are closed in reverse order when the block exits, regardless of whether an exception occurs.

try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
  System.out.println(reader.readLine());
} catch (IOException e) {
  System.out.println("Error reading file: " + e.getMessage());
}

When execution leaves the try block, reader.close() is called automatically. This makes resource management concise, reliable, and less error-prone.

The AutoCloseable interface

The AutoCloseable interface defines a single method, close(), which is called automatically at the end of a try-with-resources block. Any class implementing this interface can participate in automatic cleanup.

public class Resource implements AutoCloseable {
  public void use() {
    System.out.println("Using resource");
  }

  @Override
  public void close() {
    System.out.println("Closing resource");
  }

  public static void main(String[] args) {
    try (Resource r = new Resource()) {
      r.use();
    }
  }
}

This prints:

Using resource
Closing resource

Even if use() throws an exception, close() is still called automatically.

Combining with custom resources

You can implement AutoCloseable in your own classes to manage any resource-like object that needs cleanup. For example, a simple timer that reports its runtime when closed:

public class Timer implements AutoCloseable {
  private final long start = System.currentTimeMillis();

  @Override
  public void close() {
    long elapsed = System.currentTimeMillis() - start;
    System.out.println("Elapsed time: " + elapsed + " ms");
  }
}

try (Timer t = new Timer()) {
  Thread.sleep(500);
}

When the try block ends, close() is called automatically, printing the elapsed time.

The try-with-resources feature encourages a cleaner, more declarative approach to resource management, freeing developers from repetitive boilerplate and ensuring that cleanup is handled consistently and safely across all code paths.

Defensive programming patterns

Exception handling is most effective when combined with defensive programming; a mindset that anticipates problems before they occur. Defensive programming patterns make code more resilient, predictable, and self-checking, reducing the frequency and severity of runtime failures. Instead of relying solely on catching exceptions, defensive code prevents them where possible and handles the unavoidable ones gracefully.

Validating inputs early

One of the simplest and most important patterns is validating method arguments as soon as they are received. Detecting invalid or unexpected input early prevents subtle bugs later in execution and provides clearer error messages.

public static int squareRoot(int n) {
  if (n < 0) {
    throw new IllegalArgumentException("Cannot compute square root of a negative number");
  }
  return (int)Math.sqrt(n);
}

This approach prevents invalid data from propagating through the program. The exception clearly identifies the cause of the failure and where it occurred, simplifying debugging.

Failing fast

Fail-fast design means detecting and reporting problems immediately when they occur rather than allowing corrupted state or invalid data to persist. This helps isolate bugs and ensures that errors are caught close to their source.

public class Account {
  private double balance;

  public void withdraw(double amount) {
    if (amount <= 0) {
      throw new IllegalArgumentException("Withdrawal amount must be positive");
    }
    if (amount > balance) {
      throw new IllegalStateException("Insufficient funds");
    }
    balance -= amount;
  }
}

Here, logical errors are detected and reported right away. The program fails clearly rather than continuing in an undefined or unsafe state.

Avoiding silent failures

Swallowing exceptions without handling or reporting them hides problems and makes systems unreliable. Every exception should either be handled meaningfully or allowed to propagate. Silent catch blocks are a common anti-pattern:

// Poor practice: hides the problem completely
try {
  saveData();
} catch (IOException e) {
  // ignored
}

Instead, log the exception or convert it to a meaningful higher-level error:

try {
  saveData();
} catch (IOException e) {
  throw new RuntimeException("Failed to save user data", e);
}

Wrapping and contextualizing exceptions

When catching exceptions that originate deep within libraries or APIs, you can wrap them in application-specific exceptions that provide more context about the failure. This preserves the root cause while giving higher layers meaningful information.

try {
  processDatabaseQuery();
} catch (SQLException e) {
  throw new DataAccessException("Database query failed", e);
}

This approach avoids leaking low-level exception types throughout your code and keeps the public interface of your application clean and consistent.

Using finally or try-with-resources for cleanup

Defensive programs ensure that cleanup actions (such as closing files or releasing locks) happen even when exceptions are thrown. The finally block and try-with-resources statement both guarantee this consistency.

FileReader reader = null;
try {
  reader = new FileReader("data.txt");
  // process file
} catch (IOException e) {
  System.err.println("I/O error: " + e.getMessage());
} finally {
  if (reader != null) {
    try { reader.close(); } catch (IOException ignore) {}
  }
}

In modern Java, prefer try-with-resources, which handles this automatically and cleanly.

Graceful degradation

In systems where reliability is critical, you can design fallback mechanisms that keep the application responsive even when parts fail. Instead of crashing, the program continues with limited functionality or default values.

try {
  return loadConfiguration();
} catch (IOException e) {
  System.err.println("Failed to load config, using defaults");
  return new DefaultConfiguration();
}

This pattern is especially useful in user-facing software or services that must remain available despite transient failures.

By validating inputs, failing fast, avoiding silent failures, and cleaning up resources predictably, you build programs that behave consistently even under stress. Combined with structured exception handling, these patterns form the backbone of robust Java application design.

Chapter 13: Functional Features and Lambdas

Modern Java supports a clean, expressive functional style that complements its object-oriented core. Lambdas, method references, and the standard java.util.function interfaces let you pass behavior as data, compose small operations into clear pipelines, and write concise code that focuses on what should happen rather than how it is performed. These features arrived to make everyday tasks simpler and safer, while preserving Java’s clarity and type safety.

In this chapter you will learn how to declare and use lambdas, how functional interfaces define the contracts they implement, and how method references provide a compact alternative when an existing method already matches the required shape. You will also see how variable capture works, why parameters and captured locals are effectively final in lambda bodies, and how this model avoids many subtle bugs that occur with shared mutable state.

Functional techniques shine when combined with streams, since operations like map, filter, and reduce accept functions to describe transformations and decisions. We will introduce the most useful function types from java.util.function, and show how they integrate seamlessly with both collections and stream pipelines.

Lambda expressions and functional interfaces

A lambda expression is an anonymous block of code that can be passed around and executed later. It represents a function without requiring a named method or enclosing class. Lambdas simplify situations where you would otherwise write a short implementation of an interface containing only one abstract method.

Such interfaces are known as functional interfaces. The Java standard library defines many of them in the java.util.function package, including Predicate<T>, Function<T,R>, Supplier<T>, and Consumer<T>. You can also define your own using the @FunctionalInterface annotation.

// A simple functional interface
@FunctionalInterface
interface Greeting {
  void sayHello(String name);
}

// Using a lambda to implement it
Greeting g = (name) -> System.out.println("Hello, " + name);
g.sayHello("Alice");

Lambdas can have zero, one, or multiple parameters. If there is exactly one parameter and its type can be inferred, you may omit parentheses. The body can be a single expression or a block of statements enclosed in braces.

// Single-expression lambda
Runnable r = () -> System.out.println("Running...");

// Multi-statement lambda
Comparator<String> cmp = (a, b) -> {
  int result = a.length() - b.length();
  return (result != 0) ? result : a.compareTo(b);
};

Method references

A method reference provides a compact way to refer to an existing method instead of writing a full lambda expression that simply calls it. They improve readability when a lambda’s body does nothing more than delegate to a method already defined elsewhere.

Method references use the :: operator to separate the type or object from the method name. There are four main forms:

• ClassName::staticMethod — reference to a static method
• instance::instanceMethod — reference to an instance method of a specific object
• ClassName::instanceMethod — reference to an instance method of an arbitrary object of a given type
• ClassName::new — reference to a constructor

// Static method reference
Function<String, Integer> parser = Integer::parseInt;
int value = parser.apply("42");

// Instance method reference (specific object)
String prefix = "Hello, ";
Function<String, String> greeter = prefix::concat;
System.out.println(greeter.apply("world"));

// Instance method reference (arbitrary object)
List<String> names = List.of("alice", "bob", "carol");
names.replaceAll(String::toUpperCase);

// Constructor reference
Supplier<StringBuilder> builder = StringBuilder::new;
StringBuilder sb = builder.get();

In each example, the compiler infers the target functional interface from the context. The method referenced must match the interface’s abstract method signature by argument types and return type.

Built-in functional types

Java’s java.util.function package defines a comprehensive set of standard functional interfaces. These cover the most common patterns of input and output combinations, allowing you to express intent clearly without creating custom interfaces for every case. Each interface represents a single abstract method and is annotated with @FunctionalInterface.

The most frequently used functional types include:

• Predicate<T> — takes a value of type T and returns a boolean result
• Function<T,R> — takes a value of type T and returns a result of type R
• Consumer<T> — takes a value of type T and performs an action without returning a result
• Supplier<T> — provides (or "supplies") a value of type T without any input
• UnaryOperator<T> — a specialized Function<T,T> that returns the same type as it receives
• BinaryOperator<T> — a specialized BiFunction<T,T,T> combining two values of the same type
• BiFunction<T,U,R> — takes two inputs and returns a result
• BiConsumer<T,U> — takes two inputs and performs an action with no result

// Predicate example
Predicate<String> isEmpty = s -> s.isEmpty();
System.out.println(isEmpty.test(""));    // true

// Function example
Function<String, Integer> length = s -> s.length();
System.out.println(length.apply("Java")); // 4

// Consumer example
Consumer<String> printer = s -> System.out.println("Value: " + s);
printer.accept("Lambda");

// Supplier example
Supplier<Double> random = Math::random;
System.out.println(random.get());

// BinaryOperator example
BinaryOperator<Integer> sum = (a, b) -> a + b;
System.out.println(sum.apply(3, 4)); // 7

These interfaces are the foundation of many higher-level APIs, especially the Stream API, which uses them extensively to express filtering, mapping, reduction, and collection operations.

Stream API overview

The Stream API, introduced in Java 8, enables functional-style operations on collections and other data sources. A stream represents a sequence of elements that can be processed declaratively through a pipeline of transformations and actions. This approach promotes cleaner, more expressive code that focuses on what should happen, not how it should be implemented.

Stream pipelines consist of three main parts:

1. Source — where the data comes from, such as a collection, array, or generator
2. Intermediate operations — transformations that produce a new stream, such as filter(), map(), or sorted()
3. Terminal operation — an operation that produces a result or side effect, such as forEach(), collect(), or reduce()

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

names.stream()                      // Source
     .filter(n -> n.length() > 3)   // Intermediate operation
     .map(String::toUpperCase)      // Intermediate operation
     .sorted()                      // Intermediate operation
     .forEach(System.out::println); // Terminal operation

Streams can be sequential or parallel. Sequential streams process elements one after another, while parallel streams divide the workload across multiple threads, offering potential performance gains on large datasets.

// Parallel stream example
long count = names.parallelStream()
                  .filter(n -> n.startsWith("A"))
                  .count();
System.out.println("Names starting with A: " + count);

Intermediate operations are lazy, meaning they do not execute until a terminal operation is invoked. This allows the stream to optimize processing, such as combining operations or stopping early when possible.

Map-filter-reduce pipelines

One of the most powerful uses of the Stream API is composing map–filter–reduce pipelines. These combine three core functional concepts to transform, select, and aggregate data in a fluent, readable style. Each step plays a distinct role in processing elements through the stream.

• map() transforms each element using a provided function
• filter() retains only those elements that match a predicate
• reduce() combines all remaining elements into a single result

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

int sumOfSquares = numbers.stream()
  .filter(n -> n % 2 == 0)        // keep even numbers
  .map(n -> n * n)                // square each one
  .reduce(0, (a, b) -> a + b);    // sum them all

System.out.println(sumOfSquares); // 56

The reduce() operation accumulates results using an identity value (in this case 0) and a binary operator that combines elements step by step. For numeric data, this often replaces traditional loops for summing, multiplying, or aggregating values.

// Using method reference in reduce
int product = numbers.stream()
  .reduce(1, Math::multiplyExact);
System.out.println(product); // 720

Chaining map() and filter() operations allows you to express complex data transformations in a compact way, avoiding intermediate variables or mutable state. Because streams are lazy, elements are processed only as needed to produce the final result.

Chapter 14: Files and I/O

All programs eventually need to interact with the outside world. Whether reading configuration data, saving user information, processing text, or managing large data sets, Java provides powerful and flexible ways to perform input and output (I/O). From its earliest versions, the language has included a rich set of classes in the java.io package, which handle streams of data in both byte and character form. Later, the java.nio.file package was added, bringing modern, efficient, and more intuitive APIs for working with files and directories.

This chapter explores Java’s I/O capabilities in depth. You will learn how to use both the classic stream-based model and the newer NIO approach, how to read and write text and binary data, how to serialize objects, and how to manage character encodings and buffered input/output for improved performance.

Understanding Java’s I/O architecture is essential for writing efficient, reliable, and scalable applications. The API is deliberately layered, separating the source or destination of data (such as files or sockets) from the way data is read or written (such as streams, readers, and writers). This allows developers to combine components flexibly and to adapt to a wide variety of data sources without rewriting core logic.

By the end of this chapter, you will be able to confidently handle file and data operations, understand the differences between the old and new I/O systems, and write programs that manage files efficiently and safely.

Working with java.io streams

The java.io package forms the foundation of Java’s classic input and output system. It provides a wide range of stream classes that let you read and write data sequentially, one byte or character at a time. Streams are Java’s abstraction for data flow, allowing you to work with files, memory buffers, network connections, and other data sources in a consistent way.

At the core of this system are two major hierarchies: one for byte streams and another for character streams. Byte streams handle raw binary data, while character streams handle text data using Unicode encoding. Both hierarchies share a similar design, making it easy to switch between them depending on your needs.

Byte streams

Byte streams are based on the abstract classes InputStream and OutputStream. These classes provide methods for reading and writing bytes, and many concrete subclasses handle specific data sources such as files or network connections.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFile {
  public static void main(String[] args) {
    try (FileInputStream in = new FileInputStream("input.dat");
         FileOutputStream out = new FileOutputStream("output.dat")) {
      int b;
      while ((b = in.read()) != -1) {
        out.write(b);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This simple example copies one file to another by reading bytes from an InputStream and writing them to an OutputStream. The try-with-resources statement ensures both streams are automatically closed at the end of the operation.

Character streams

Character streams extend the idea of byte streams but work with Unicode characters instead of raw bytes. They are built on Reader and Writer classes and automatically handle character encoding and decoding.

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyText {
  public static void main(String[] args) {
    try (FileReader reader = new FileReader("input.txt");
         FileWriter writer = new FileWriter("output.txt")) {
      int c;
      while ((c = reader.read()) != -1) {
        writer.write(c);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This version reads and writes characters rather than bytes, making it ideal for plain-text files. Because Reader and Writer classes handle encoding automatically, the program can process text reliably across platforms.

Buffered streams

To improve performance, Java provides buffered stream wrappers that minimize the number of I/O operations by reading or writing chunks of data at once. For example, wrapping a FileReader in a BufferedReader allows efficient reading of entire lines of text.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadLines {
  public static void main(String[] args) {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Buffered streams can significantly speed up file access by reducing the number of system-level reads and writes. They are widely used for both binary and text I/O operations.

java.nio.file and modern I/O

The java.nio.file package, introduced in Java 7, provides a modern, flexible, and efficient way to handle files and directories. Known as the NIO.2 API (New Input/Output), it was designed to overcome many of the limitations of the older java.io classes, offering better scalability, richer metadata handling, and improved exception reporting. It also integrates cleanly with the rest of the Java platform and supports advanced features such as symbolic links, file attributes, and asynchronous I/O.

Central to this package is the Path interface, which represents a platform-independent file or directory path. It replaces the older File class as the preferred abstraction for file system locations, supporting powerful operations such as joining, normalizing, and resolving paths.

Using Path and Files

The Paths class provides factory methods for creating Path objects, while the Files utility class offers static methods to perform most file operations, including reading, writing, copying, moving, and deleting files.

import java.nio.file.*;

public class NIOExample {
  public static void main(String[] args) {
    Path path = Paths.get("example.txt");

    try {
      // Write text to a file
      Files.writeString(path, "Hello, NIO.2!");

      // Read text from a file
      String content = Files.readString(path);
      System.out.println(content);

      // Copy the file
      Files.copy(path, Paths.get("copy.txt"), StandardCopyOption.REPLACE_EXISTING);

      // Delete the file
      Files.deleteIfExists(path);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

This example demonstrates how concise and expressive the new API can be. The Files class eliminates much of the boilerplate code needed with traditional I/O, while still handling errors safely through exceptions.

Working with directories

The NIO API also provides powerful directory handling via methods such as Files.list(), Files.walk(), and Files.newDirectoryStream(). These allow you to iterate through files efficiently, even across large directory trees.

import java.nio.file.*;
import java.io.IOException;

public class ListFiles {
  public static void main(String[] args) {
    Path dir = Paths.get(".");

    try {
      Files.list(dir)
           .filter(Files::isRegularFile)
           .forEach(System.out::println);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This code lists all regular files in the current directory. For recursive traversal, Files.walk() can be used instead, returning a stream of paths for an entire directory tree.

Reading and writing with streams

The NIO API supports stream-based file I/O that integrates seamlessly with the java.util.stream library, making it easy to process files using functional constructs.

import java.nio.file.*;
import java.io.IOException;

public class ReadLinesNIO {
  public static void main(String[] args) {
    Path file = Paths.get("data.txt");

    try {
      Files.lines(file)
           .filter(line -> line.contains("Java"))
           .forEach(System.out::println);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Here, Files.lines() returns a lazily evaluated stream of strings, which can be filtered and processed using familiar functional operations. This allows concise, memory-efficient processing of large text files.

File attributes and metadata

Unlike the older I/O API, NIO.2 provides detailed access to file metadata, such as size, creation time, last modified time, and permissions. These can be read or modified using the Files.getAttribute() and Files.setAttribute() methods, or through attribute views such as BasicFileAttributes.

import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.IOException;

public class FileInfo {
  public static void main(String[] args) {
    Path file = Paths.get("data.txt");

    try {
      BasicFileAttributes attrs = Files.readAttributes(file, BasicFileAttributes.class);
      System.out.println("Size: " + attrs.size());
      System.out.println("Created: " + attrs.creationTime());
      System.out.println("Modified: " + attrs.lastModifiedTime());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This feature makes NIO.2 an ideal choice for systems programming, file synchronization, and applications that require detailed control over file metadata.

Overall, java.nio.file represents the modern standard for file handling in Java. It is both easier to use and more powerful than the legacy I/O model, while remaining fully interoperable with it.

Reading and writing text and binary files

Reading from and writing to files is one of the most common I/O tasks in any Java program. The Java platform offers several ways to do this, ranging from simple text-based operations to efficient handling of large binary files. Whether you use the traditional java.io streams or the newer java.nio.file utilities, the same basic principles apply: open a file, process its contents, and close it safely when finished.

Reading text files

Text files are typically read line by line or all at once into memory. The NIO.2 API simplifies this greatly using methods such as Files.readString() or Files.readAllLines(), which automatically handle character encoding and resource management.

import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class ReadTextFile {
  public static void main(String[] args) {
    Path file = Paths.get("example.txt");

    try {
      List<String> lines = Files.readAllLines(file);
      for (String line : lines) {
        System.out.println(line);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

For large files or streaming scenarios, use Files.lines() instead, which returns a Stream<String> that can be processed lazily without loading the entire file into memory.

Writing text files

Writing text to a file is just as simple. The Files.writeString() and Files.write() methods allow direct creation or replacement of files with string or byte content. For appending data, you can supply the StandardOpenOption.APPEND flag.

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class WriteTextFile {
  public static void main(String[] args) {
    Path file = Paths.get("output.txt");

    try {
      Files.writeString(file, "First line\n", StandardCharsets.UTF_8);
      Files.writeString(file, "Second line\n", StandardCharsets.UTF_8, 
        StandardOpenOption.APPEND);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This example writes text to a file in UTF-8 encoding, appending new content to the end. If the file does not exist, it will be created automatically.

Reading and writing binary files

Binary files contain raw data, such as images, audio, or serialized objects. These files are read and written using byte-oriented streams or NIO methods. The Files.readAllBytes() and Files.write() methods provide the simplest approach.

import java.nio.file.*;
import java.io.IOException;

public class CopyBinaryFile {
  public static void main(String[] args) {
    Path source = Paths.get("image.jpg");
    Path target = Paths.get("copy.jpg");

    try {
      byte[] data = Files.readAllBytes(source);
      Files.write(target, data);
      System.out.println("File copied successfully.");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This reads the entire binary file into a byte array and writes it to a new location. For larger files, however, streaming with buffered I/O is preferred to avoid excessive memory use.

Buffered I/O for efficiency

Using buffers can improve performance when dealing with large files by reducing the number of system calls. The BufferedInputStream and BufferedOutputStream classes wrap lower-level streams to provide this optimization.

import java.io.*;

public class BufferedCopy {
  public static void main(String[] args) {
    try (BufferedInputStream in = new BufferedInputStream(new FileInputStream("data.bin"));
         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("copy.bin"))) {
      byte[] buffer = new byte[4096];
      int bytesRead;
      while ((bytesRead = in.read(buffer)) != -1) {
        out.write(buffer, 0, bytesRead);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Buffered I/O is especially useful for large or frequently accessed files, as it minimizes disk access and speeds up data transfer.

By mastering these text and binary techniques, you can efficiently handle all types of file data in Java, combining ease of use with fine-grained control where necessary.

Serialization basics

Serialization is the process of converting an object into a stream of bytes so that it can be saved to a file, sent over a network, or stored for later use. Deserialization reverses this process, reconstructing the object from its byte representation. Java provides built-in support for object serialization through the java.io.Serializable interface and associated stream classes.

Serialization allows programs to persist complex data structures and restore them exactly as they were, including the values of fields and object references. However, not all objects can or should be serialized, especially those that represent transient or external resources such as open files or sockets.

Implementing Serializable

To make a class serializable, you simply declare that it implements the Serializable interface. This is a marker interface that has no methods, but signals to the JVM that instances of the class can be written to and read from an ObjectOutputStream or ObjectInputStream.

import java.io.*;

class Person implements Serializable {
  private String name;
  private int age;

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

  public String toString() {
    return name + " (" + age + ")";
  }
}

public class SerializeExample {
  public static void main(String[] args) {
    Person p = new Person("Alice", 30);

    try (ObjectOutputStream out =
           new ObjectOutputStream(new FileOutputStream("person.dat"))) {
      out.writeObject(p);
      System.out.println("Object serialized successfully.");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This example serializes a Person object to a binary file. The ObjectOutputStream automatically handles the conversion of fields and references into a byte sequence that can later be deserialized.

Deserializing objects

Deserialization reconstructs the object from its serialized form. It must be performed using the same class definition (including the same serial version identifier, if one is set).

import java.io.*;

public class DeserializeExample {
  public static void main(String[] args) {
    try (ObjectInputStream in =
           new ObjectInputStream(new FileInputStream("person.dat"))) {
      Person p = (Person) in.readObject();
      System.out.println("Read object: " + p);
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
}

The readObject() method returns a generic Object, which you must cast to the correct type. During deserialization, Java restores the original field values and object references, recreating the same logical structure that was saved.

Using serialVersionUID

Each serializable class has an associated identifier called serialVersionUID. This ID ensures that the serialized data is compatible with the class definition used to read it back. If you do not specify it explicitly, the JVM generates one automatically based on class details, which can lead to compatibility issues if the class is later modified.

private static final long serialVersionUID = 1L;

Including a constant serial version ID helps maintain forward and backward compatibility across versions of your code, especially when objects are stored or transmitted between different systems.

Transient and static fields

By default, all non-static fields of a serializable class are saved. If you want to exclude specific fields from serialization, mark them as transient. Static fields are also not serialized because they belong to the class, not the instance.

class User implements Serializable {
  private String username;
  private transient String password; // will not be serialized
}

Marking sensitive data as transient protects it from being written to disk or transmitted insecurely. Upon deserialization, transient fields are initialized with their default values.

Limitations and alternatives

While Java’s built-in serialization is convenient, it is not always ideal for long-term data storage or for communication between different programming environments. Serialized data is JVM-specific, may expose internal details, and is not human-readable. For interoperability, formats such as JSON, XML, or protocol buffers are often preferred.

Nevertheless, serialization remains an important feature within Java itself, used widely in frameworks such as RMI, HTTP session storage, and certain caching systems.

Character encodings and buffering

Text in Java is represented internally using Unicode, which can encode virtually every character from all writing systems. However, files and network streams store text as sequences of bytes, so encoding and decoding are required when converting between in-memory characters and external data sources. Understanding character encodings and how to manage them is essential for writing portable, reliable I/O code.

Character encodings

A character encoding defines how characters are mapped to bytes. Common encodings include UTF-8 (the default in modern Java versions), UTF-16, and ISO-8859-1. When reading or writing text, Java must know which encoding to use, or characters may become garbled.

The java.nio.charset package provides the Charset class for working with encodings, including standard constants defined in StandardCharsets. You can specify an encoding explicitly when using readers, writers, or NIO methods.

import java.nio.file.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class EncodingExample {
  public static void main(String[] args) {
    Path file = Paths.get("utf8.txt");

    try {
      Files.writeString(file, "Café", StandardCharsets.UTF_8);
      String text = Files.readString(file, StandardCharsets.UTF_8);
      System.out.println(text);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

This example ensures that both writing and reading use UTF-8, preserving accented and special characters correctly. If no encoding is specified, Java will use the platform default, which can vary by system and lead to inconsistent results.

Reader and Writer conversion

When working with byte streams, conversion to or from characters is handled using InputStreamReader and OutputStreamWriter. These bridge classes apply a specific encoding while translating between bytes and characters.

import java.io.*;
import java.nio.charset.StandardCharsets;

public class ReaderWriterExample {
  public static void main(String[] args) {
    try (OutputStreamWriter writer =
           new OutputStreamWriter(new FileOutputStream("text.txt"), StandardCharsets.UTF_8)) {
      writer.write("Hello, 世界");
    } catch (IOException e) {
      e.printStackTrace();
    }

    try (InputStreamReader reader =
           new InputStreamReader(new FileInputStream("text.txt"), StandardCharsets.UTF_8)) {
      int ch;
      while ((ch = reader.read()) != -1) {
        System.out.print((char) ch);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

These classes are particularly useful when dealing with mixed byte and character data, such as when reading text from a network socket or compressing encoded data streams.

Buffered reading and writing

Buffered I/O improves performance by reducing the number of physical read and write operations. Instead of reading or writing each character individually, buffered streams operate on blocks of data stored temporarily in memory.

import java.io.*;
import java.nio.charset.StandardCharsets;

public class BufferedTextIO {
  public static void main(String[] args) {
    try (BufferedWriter writer = new BufferedWriter(
           new OutputStreamWriter(new FileOutputStream("buffered.txt"), StandardCharsets.UTF_8))) {
      writer.write("Buffered output example");
    } catch (IOException e) {
      e.printStackTrace();
    }

    try (BufferedReader reader = new BufferedReader(
           new InputStreamReader(new FileInputStream("buffered.txt"), StandardCharsets.UTF_8))) {
      String line = reader.readLine();
      System.out.println(line);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Using buffers ensures smoother performance and helps reduce latency in high-volume I/O scenarios. Buffered streams are standard practice for almost all file-based operations in Java.

Choosing the right approach

The combination of correct encoding and buffering ensures both correctness and speed in text-based I/O. For most modern applications, UTF-8 encoding and buffered readers or writers provide the best balance between compatibility and performance. For binary data or large-scale operations, the java.nio.file API offers even greater efficiency through memory mapping and non-blocking channels, which are covered in later chapters.

With a clear understanding of character encoding and buffered I/O, you can reliably process text files across platforms and locales without corruption or performance issues.

Chapter 15: Date, Time, and Utilities

Programs often need to work with dates, times, mathematical calculations, and general-purpose utilities that make code simpler and more reliable. Java includes a comprehensive standard library to meet these needs, offering everything from powerful time management through the java.time API to mathematical and object utilities in java.util and related packages.

Before Java 8, working with dates and times involved the older Date and Calendar classes, which were cumbersome and prone to errors. The modern java.time API replaced these with a clean, immutable, and type-safe model based on the ISO-8601 standard, making it far easier to work with time zones, durations, and date arithmetic.

In addition to working with time, this chapter explores Java’s essential utility classes. These include Objects for safer null handling, Math for common mathematical functions, Random for generating pseudo-random values, and UUID for creating universally unique identifiers. You will also learn how to format and parse date and numeric data in a locale-aware way, and how to use Optional to write cleaner, null-safe code.

By the end of this chapter, you will be able to work confidently with date and time, perform complex calculations, generate secure random data, handle optional values safely, and make full use of Java’s versatile utility classes to streamline your programs.

The java.time API

The java.time package, introduced in Java 8, provides a modern and comprehensive framework for handling dates, times, and durations. It replaces the older Date and Calendar classes with a cleaner, more intuitive API that emphasizes immutability, thread safety, and clarity. All classes in this package are designed around the ISO-8601 standard, which is used internationally for date and time representation.

The core design divides temporal data into distinct types, such as date-only, time-only, date-time, and zoned date-time. This makes it easier to express exactly what kind of temporal information a variable holds, avoiding common mistakes with mixed or ambiguous date/time data.

Core date and time classes

The most commonly used classes in the java.time package include:

• LocalDate — represents a date without time or time zone (for example, 2025-10-27).
• LocalTime — represents a time without date or time zone (for example, 14:35:00).
• LocalDateTime — combines date and time, but still without a time zone.
• ZonedDateTime — represents a full date and time including a time zone and offset from UTC.
• Instant — represents a precise moment on the timeline in UTC, suitable for timestamps.

import java.time.*;

public class TimeExample {
  public static void main(String[] args) {
    LocalDate date = LocalDate.now();
    LocalTime time = LocalTime.now();
    LocalDateTime dateTime = LocalDateTime.now();
    ZonedDateTime zoned = ZonedDateTime.now();

    System.out.println("Date: " + date);
    System.out.println("Time: " + time);
    System.out.println("DateTime: " + dateTime);
    System.out.println("ZonedDateTime: " + zoned);
  }
}

Each of these classes provides a rich set of methods for retrieving and manipulating temporal data, such as adding or subtracting days, comparing times, or converting between formats.

Creating and manipulating dates

You can create date and time instances using static factory methods such as of() or by parsing strings. These immutable objects return new instances whenever modified, ensuring thread safety.

import java.time.*;

public class ManipulateDate {
  public static void main(String[] args) {
    LocalDate today = LocalDate.now();
    LocalDate birthday = LocalDate.of(1990, 5, 12);

    LocalDate nextWeek = today.plusWeeks(1);
    LocalDate nextMonth = today.plusMonths(1);

    System.out.println("Today: " + today);
    System.out.println("Next week: " + nextWeek);
    System.out.println("Next month: " + nextMonth);
    System.out.println("Birthday: " + birthday);
  }
}

Because LocalDate and related classes are immutable, methods like plusDays() or minusMonths() return new objects rather than modifying existing ones.

Periods and durations

The Period and Duration classes represent amounts of time, with Period measured in years, months, and days, and Duration measured in seconds and nanoseconds. These are useful for performing arithmetic between temporal objects.

import java.time.*;
import java.time.temporal.ChronoUnit;

public class PeriodDurationExample {
  public static void main(String[] args) {
    LocalDate start = LocalDate.of(2020, 1, 1);
    LocalDate end = LocalDate.of(2025, 10, 27);

    Period period = Period.between(start, end);
    long days = ChronoUnit.DAYS.between(start, end);

    System.out.println("Period: " + period);
    System.out.println("Total days: " + days);
  }
}

Periods and durations allow you to express time differences naturally and apply them directly to other temporal values using methods such as plus() and minus().

Time zones and offsets

Time zones are represented by the ZoneId class, which identifies regions such as "Europe/London" or "America/New_York". A ZonedDateTime combines a LocalDateTime with a zone to produce an exact instant on the global timeline.

import java.time.*;

public class ZoneExample {
  public static void main(String[] args) {
    ZoneId london = ZoneId.of("Europe/London");
    ZoneId tokyo = ZoneId.of("Asia/Tokyo");

    ZonedDateTime londonTime = ZonedDateTime.now(london);
    ZonedDateTime tokyoTime = ZonedDateTime.now(tokyo);

    System.out.println("London: " + londonTime);
    System.out.println("Tokyo: " + tokyoTime);
  }
}

Time zones are crucial when dealing with international applications or scheduling across regions. The ZoneOffset class represents fixed offsets from UTC, such as +02:00.

Instant and epoch time

The Instant class provides nanosecond precision for timestamps relative to the Unix epoch. You can use it to record exact event times or measure elapsed durations with high precision.

import java.time.*;

public class InstantExample {
  public static void main(String[] args) {
    Instant start = Instant.now();
    // Simulated operation
    for (int i = 0; i < 1000000; i++);
    Instant end = Instant.now();

    System.out.println("Elapsed: " +
      java.time.Duration.between(start, end).toNanos() + " ns");
  }
}

The Instant class is the foundation for high-precision timing and logging. It integrates well with Duration and can be converted easily to ZonedDateTime when required for display.

The java.time API provides a robust, immutable, and well-structured system for handling all aspects of date and time in modern Java applications. It is one of the most significant improvements to the standard library since the language’s early days, replacing error-prone legacy classes with a design that is both elegant and practical.

Formatting and parsing dates

Formatting and parsing are essential when converting between Java’s date and time objects and human-readable text. The java.time.format package provides flexible classes for these operations, allowing you to display dates in a chosen pattern or interpret user input into structured date and time values.

The central class for this purpose is DateTimeFormatter. It works with all major temporal types such as LocalDate, LocalTime, LocalDateTime, and ZonedDateTime, and it supports both predefined ISO formats and custom patterns.

Using predefined formatters

The DateTimeFormatter class provides several built-in constants for common date and time representations. These include ISO_LOCAL_DATE, ISO_LOCAL_DATE_TIME, and ISO_ZONED_DATE_TIME, among others.

import java.time.*;
import java.time.format.DateTimeFormatter;

public class PredefinedFormats {
  public static void main(String[] args) {
    LocalDateTime now = LocalDateTime.now();

    System.out.println("ISO local date: " +
      now.format(DateTimeFormatter.ISO_LOCAL_DATE));
    System.out.println("ISO date-time: " +
      now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    System.out.println("ISO zoned date-time: " +
      ZonedDateTime.now().format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
  }
}

These standard ISO formatters are especially useful when exchanging data between systems or APIs, since they are unambiguous and universally recognized.

Custom formatting patterns

For user interfaces or reports, you often need to display dates in a more readable or localized form. Custom patterns can be defined using pattern letters similar to those used in SimpleDateFormat, but with improved thread safety and clarity.

import java.time.*;
import java.time.format.DateTimeFormatter;

public class CustomFormat {
  public static void main(String[] args) {
    LocalDateTime now = LocalDateTime.now();
    DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd MMMM yyyy, HH:mm:ss");

    String formatted = now.format(fmt);
    System.out.println("Formatted: " + formatted);
  }
}

In this example, dd represents the day of the month, MMMM the full month name, yyyy the year, and HH:mm:ss the 24-hour time. The resulting string is locale-sensitive, displaying month names and other elements according to the default system locale unless specified otherwise.

Parsing text into dates

Parsing is the reverse of formatting: converting a string representation into a date or time object. The same DateTimeFormatter instance can be used for both operations, ensuring consistency between display and input.

import java.time.*;
import java.time.format.DateTimeFormatter;

public class ParseExample {
  public static void main(String[] args) {
    String input = "27 October 2025, 14:45:00";
    DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd MMMM yyyy, HH:mm:ss");

    LocalDateTime dateTime = LocalDateTime.parse(input, fmt);
    System.out.println("Parsed date-time: " + dateTime);
  }
}

If the text does not match the specified pattern, a DateTimeParseException will be thrown, so it is best to handle this gracefully when accepting user input.

Localized date and time formats

Java provides predefined localized formatters for displaying date and time values according to regional conventions. These can be obtained via the ofLocalizedDate(), ofLocalizedTime(), or ofLocalizedDateTime() methods.

import java.time.*;
import java.time.format.*;

public class LocalizedFormat {
  public static void main(String[] args) {
    LocalDate date = LocalDate.now();

    DateTimeFormatter shortFmt = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
    DateTimeFormatter longFmt = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG);

    System.out.println("Short: " + date.format(shortFmt));
    System.out.println("Long: " + date.format(longFmt));
  }
}

Localized formatters automatically adapt to the system locale or one you specify explicitly using withLocale(). This is especially useful in international applications.

Formatting and parsing with time zones

When working with time zone–aware types such as ZonedDateTime, you can include zone and offset information in your patterns using symbols like z for short names (e.g. GMT, PST) or Z for numeric offsets (e.g. +0100).

import java.time.*;
import java.time.format.*;

public class ZoneFormatting {
  public static void main(String[] args) {
    ZonedDateTime zoned = ZonedDateTime.now(ZoneId.of("Europe/London"));
    DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

    String formatted = zoned.format(fmt);
    System.out.println("Formatted with zone: " + formatted);

    ZonedDateTime parsed = ZonedDateTime.parse(formatted, fmt);
    System.out.println("Parsed back: " + parsed);
  }
}

This demonstrates that you can fully round-trip date-time strings containing time zone information, preserving the precise moment represented.

The java.time.format system provides a clear, thread-safe, and consistent way to format and parse date and time values, ensuring both readability for users and reliability for programs that depend on accurate temporal data.

Utility classes

Java provides a collection of utility classes that support everyday programming tasks. Among the most widely used are Objects, Math, and Random. These classes are part of java.util and java.lang and offer essential functionality for working safely with objects, performing mathematical operations, and generating random numbers.

The Objects class

The java.util.Objects class provides a set of static methods that simplify null handling, equality checks, and hash code generation. It helps prevent NullPointerException errors and reduces the amount of boilerplate code often required for defensive programming.

import java.util.Objects;

public class ObjectsExample {
  public static void main(String[] args) {
    String name = null;

    // Safe equality check
    System.out.println(Objects.equals(name, "Alice"));

    // Null-safe default value
    String result = Objects.requireNonNullElse(name, "Unknown");
    System.out.println("Name: " + result);

    // Manual null validation
    try {
      Objects.requireNonNull(name, "Name cannot be null");
    } catch (NullPointerException e) {
      System.out.println(e.getMessage());
    }
  }
}

The Objects class also provides hash() and toString() helpers that are especially useful when implementing equals() and hashCode() methods in your own classes.

The Math class

The java.lang.Math class offers a comprehensive set of static methods for mathematical calculations. It includes trigonometric, logarithmic, and exponential functions, rounding operations, and constants for PI and E.

public class MathExample {
  public static void main(String[] args) {
    double x = 7.5;

    System.out.println("Ceil: " + Math.ceil(x));
    System.out.println("Floor: " + Math.floor(x));
    System.out.println("Round: " + Math.round(x));
    System.out.println("Power: " + Math.pow(2, 8));
    System.out.println("Square root: " + Math.sqrt(81));
    System.out.println("Sin(PI/2): " + Math.sin(Math.PI / 2));
  }
}

The Math class uses double precision floating-point arithmetic for most operations, ensuring accuracy sufficient for most scientific and engineering tasks. For higher precision, the BigDecimal class (from java.math) can be used instead.

The Random class

The java.util.Random class provides methods for generating pseudo-random numbers. It can produce integers, floating-point values, booleans, and even random streams for functional-style processing. Each Random instance maintains its own internal seed, so repeated runs can produce different results unless the seed is fixed.

import java.util.Random;

public class RandomExample {
  public static void main(String[] args) {
    Random rand = new Random();

    System.out.println("Random int: " + rand.nextInt());
    System.out.println("Random int (0–9): " + rand.nextInt(10));
    System.out.println("Random double: " + rand.nextDouble());
    System.out.println("Random boolean: " + rand.nextBoolean());
  }
}

Using nextInt(bound) limits the output to a specific range (from 0 inclusive to the bound exclusive), which is useful for indexing or simple random selections.

Random streams and functional use

Since Java 8, Random also supports generating streams of random numbers that can be processed using the Stream API. This makes it easy to produce large sets of random values for analysis or simulation.

import java.util.Random;

public class RandomStreamExample {
  public static void main(String[] args) {
    Random rand = new Random();

    rand.ints(5, 1, 100) // generate 5 random ints from 1 to 99
        .forEach(System.out::println);
  }
}

This concise style is ideal for generating random data sets or testing algorithms. The ints(), doubles(), and longs() methods each produce specialized numeric streams.

Together, the Objects, Math, and Random classes form an essential part of Java’s core toolkit, offering reliability, safety, and versatility for a wide range of programming tasks.

UUIDs and basic data formatting

In many programs, you need to generate unique identifiers or format numbers and text for display. Java provides powerful utilities for both purposes: UUID for globally unique identifiers and the java.text package for flexible data formatting. Together, these make it easy to manage data safely and present it consistently across systems and locales.

Working with UUIDs

A UUID (Universally Unique Identifier) is a 128-bit value used to uniquely identify information across space and time, without needing a central authority. Java’s java.util.UUID class provides built-in methods to generate and parse these identifiers.

import java.util.UUID;

public class UUIDExample {
  public static void main(String[] args) {
    UUID id1 = UUID.randomUUID(); // random version 4 UUID
    UUID id2 = UUID.nameUUIDFromBytes("example".getBytes());

    System.out.println("Random UUID: " + id1);
    System.out.println("Name-based UUID: " + id2);
  }
}

A UUID is typically represented as a string of 32 hexadecimal digits separated by hyphens, such as 550e8400-e29b-41d4-a716-446655440000. The probability of collision is astronomically low, making UUIDs ideal for database keys, session identifiers, or distributed systems.

Basic number formatting

Numbers often need to be displayed in a readable, locale-specific format. The java.text.NumberFormat class handles this automatically, inserting grouping separators and adjusting decimal points according to regional conventions.

import java.text.NumberFormat;
import java.util.Locale;

public class NumberFormatting {
  public static void main(String[] args) {
    double value = 1234567.89;

    NumberFormat us = NumberFormat.getInstance(Locale.US);
    NumberFormat fr = NumberFormat.getInstance(Locale.FRANCE);

    System.out.println("US: " + us.format(value));
    System.out.println("France: " + fr.format(value));
  }
}

This produces:

US: 1,234,567.89
France: 1 234 567,89

The same number is rendered differently depending on the locale, ensuring that applications appear natural to users around the world.

Currency and percentage formatting

Specialized number formatters exist for currencies and percentages, automatically adding appropriate symbols and scaling values.

import java.text.NumberFormat;
import java.util.Locale;

public class CurrencyAndPercent {
  public static void main(String[] args) {
    double price = 49.99;
    double rate = 0.075;

    NumberFormat currency = NumberFormat.getCurrencyInstance(Locale.UK);
    NumberFormat percent = NumberFormat.getPercentInstance();

    System.out.println("Price: " + currency.format(price));
    System.out.println("Rate: " + percent.format(rate));
  }
}

This might display:

Price: £49.99
Rate: 7%

By selecting different locales, you can automatically adapt currency symbols and decimal rules to each region, avoiding manual string manipulation.

Decimal precision control

You can control the number of digits displayed before and after the decimal point using setMinimumFractionDigits() and setMaximumFractionDigits() methods. This is useful for aligning numeric data or producing clean reports.

import java.text.NumberFormat;

public class PrecisionExample {
  public static void main(String[] args) {
    double pi = Math.PI;

    NumberFormat fmt = NumberFormat.getNumberInstance();
    fmt.setMaximumFractionDigits(3);
    fmt.setMinimumFractionDigits(3);

    System.out.println("Pi (3 decimal places): " + fmt.format(pi));
  }
}

This ensures consistent rounding and alignment, regardless of the system locale or internal representation of the number.

Formatting with String.format()

Another approach to formatting numbers, strings, and other data is String.format(), which uses C-style format specifiers. This method is fast and concise for simple tasks.

public class StringFormatExample {
  public static void main(String[] args) {
    String name = "Alice";
    int age = 30;
    double balance = 1234.567;

    String result = String.format("Name: %s, Age: %d, Balance: %.2f", name, age, balance);
    System.out.println(result);
  }
}

This prints:

Name: Alice, Age: 30, Balance: 1234.57

The format specifiers work as follows: %s inserts a string, %d an integer, and %.2f a floating-point number with two decimal places. This method is locale-neutral by default but can accept a Locale as the first argument for internationalized formatting.

Together, UUID and Java’s data formatting classes provide a reliable foundation for identifying, presenting, and managing data clearly and consistently in applications of any scale.

Using Optional and null safety

Null references have long been a source of bugs and confusion in Java programs. Accidentally dereferencing a null value leads to a NullPointerException, one of the most common runtime errors in Java. To reduce this problem and encourage safer programming practices, Java 8 introduced the Optional class in java.util. It provides a container that may or may not hold a non-null value, explicitly expressing the possibility of absence.

Creating Optional values

An Optional<T> can be created in several ways: with a non-null value, as an empty instance, or conditionally using ofNullable(). This makes code safer and more readable by clearly showing when a value may be missing.

import java.util.Optional;

public class OptionalCreation {
  public static void main(String[] args) {
    Optional<String> name1 = Optional.of("Alice");       // value present
    Optional<String> name2 = Optional.empty();           // explicitly empty
    Optional<String> name3 = Optional.ofNullable(null);  // may be empty

    System.out.println(name1.isPresent()); // true
    System.out.println(name2.isEmpty());   // true
    System.out.println(name3.orElse("Unknown"));
  }
}

By using Optional, you make it explicit when a method might return no result. This eliminates the need for null checks scattered throughout your code.

Accessing and transforming values

The Optional class provides functional-style methods to access, transform, or supply default values without explicit null checks. This leads to cleaner, more declarative code.

import java.util.Optional;

public class OptionalTransform {
  public static void main(String[] args) {
    Optional<String> name = Optional.ofNullable("Bob");

    // Transform value if present
    String upper = name.map(String::toUpperCase).orElse("No name");
    System.out.println(upper);

    // Provide default if absent
    Optional<String> empty = Optional.empty();
    System.out.println(empty.orElse("Default value"));
  }
}

The map() and flatMap() methods allow you to apply functions directly to the contained value, if present. If not, the operations are simply skipped without throwing exceptions.

Conditional execution with ifPresent()

Instead of manually checking if a value is present, Optional provides ifPresent() and ifPresentOrElse() methods for conditional execution. These methods accept lambda expressions, keeping your logic concise and expressive.

import java.util.Optional;

public class IfPresentExample {
  public static void main(String[] args) {
    Optional<String> name = Optional.of("Carol");
    name.ifPresent(n -> System.out.println("Hello, " + n));

    Optional<String> missing = Optional.empty();
    missing.ifPresentOrElse(
      n -> System.out.println("Found: " + n),
      () -> System.out.println("Value not found")
    );
  }
}

These methods let you perform actions only when data exists, avoiding complex conditional blocks or null comparisons.

Optionals in method design

Returning Optional from methods is a good practice when a value may not exist. It encourages the caller to handle the absence explicitly rather than risking a null pointer.

import java.util.Optional;

public class UserLookup {
  public static Optional<String> findUserById(int id) {
    if (id == 1) return Optional.of("Alice");
    return Optional.empty();
  }

  public static void main(String[] args) {
    String user = findUserById(2).orElse("Guest");
    System.out.println("User: " + user);
  }
}

This approach communicates intent clearly and prevents accidental null misuse. Callers must decide what to do if no result is found, promoting safer API design.

Combining Optional with streams

Optional integrates smoothly with Java streams, allowing functional-style chaining and data transformation. You can convert between Optional and Stream when filtering or aggregating results.

import java.util.*;
import java.util.stream.*;

public class OptionalStream {
  public static void main(String[] args) {
    List<Optional<String>> list = List.of(
      Optional.of("Alpha"),
      Optional.empty(),
      Optional.of("Beta")
    );

    List<String> names = list.stream()
      .flatMap(Optional::stream)
      .collect(Collectors.toList());

    System.out.println(names);
  }
}

This example collects only present values, ignoring empty ones automatically. It shows how Optional and the Stream API work together for clean, expressive data processing.

By embracing Optional and careful null handling, you can eliminate many common runtime errors, making your Java programs safer, more predictable, and easier to maintain.

Chapter 16: Concurrency and Multithreading

Modern applications often need to perform many tasks at once, such as downloading data while updating a user interface, or processing multiple requests on a web server simultaneously. Concurrency and multithreading in Java provide the tools to manage such operations efficiently, allowing multiple parts of a program to run independently or in parallel.

Java has supported threads since its earliest versions, and its concurrency framework has grown into a sophisticated set of tools built around the java.util.concurrent package. From the low-level Thread class and Runnable interface to high-level abstractions like executors, thread pools, and asynchronous pipelines, Java offers fine control over performance, responsiveness, and scalability.

This chapter explores how to create and manage threads, synchronize shared data to prevent race conditions, and make use of the modern concurrency utilities. You will also learn how to coordinate tasks using CompletableFuture and apply asynchronous programming patterns that make code both efficient and easier to reason about.

Threads and the Runnable interface

At the heart of Java’s concurrency model lies the concept of a thread: a lightweight unit of execution that can run independently of other threads within the same program. Every Java application starts with at least one thread (the main thread) which executes the main() method. Additional threads can be created to perform tasks in parallel, improving responsiveness or throughput.

Java provides two primary ways to define a thread: by extending the Thread class, or by implementing the Runnable interface. The latter approach is preferred, as it separates the task being performed from the thread that runs it, making code more flexible and reusable.

Creating a thread with Runnable

The Runnable interface contains a single method, run(), which defines the code that will execute in the new thread. You then pass a Runnable instance to a Thread object and call start() to begin execution.

class MyTask implements Runnable {
  public void run() {
    System.out.println("Running in a separate thread");
  }
}

public class Example {
  public static void main(String[] args) {
    Thread t = new Thread(new MyTask());
    t.start();  // Starts the new thread
    System.out.println("Main thread continues...");
  }
}

When start() is called, Java’s runtime creates a new thread of execution that runs the run() method concurrently with the rest of the program.

Extending the Thread class

Although less flexible, another approach is to subclass Thread and override its run() method directly. This can be convenient for simple tasks, though it limits the ability to extend other classes.

class MyThread extends Thread {
  public void run() {
    System.out.println("Thread running: " + getName());
  }
}

public class Example2 {
  public static void main(String[] args) {
    MyThread t = new MyThread();
    t.start();
  }
}

Thread lifecycle

Once started, a thread moves through several states: new, runnable, running, waiting or sleeping, and finally terminated. These transitions depend on system scheduling and synchronization mechanisms, which determine when each thread gets CPU time.

Using lambda expressions with Runnable

Since Runnable is a functional interface, you can use a lambda expression instead of creating a class. This makes the code concise and readable:

public class Example3 {
  public static void main(String[] args) {
    Thread t = new Thread(() -> {
      System.out.println("Lambda thread running");
    });
    t.start();
  }
}

This syntax is ideal for short-lived or one-off tasks, and it integrates neatly with the functional features introduced in modern Java.

Synchronized blocks and locks

When multiple threads access shared data, there is a risk that they will interfere with each other. For example, if two threads update the same variable at the same time, the final result may be unpredictable. This type of problem is known as a race condition. Java provides synchronization mechanisms to ensure that only one thread can access a critical section of code at a time.

The synchronized keyword

The simplest way to prevent data corruption is to use the synchronized keyword. It can be applied to methods or blocks of code to enforce exclusive access by a single thread. When a thread enters a synchronized section, it obtains the lock (or monitor) associated with the specified object. Other threads attempting to enter the same section must wait until the lock is released.

class Counter {
  private int count = 0;

  public synchronized void increment() {
    count++;
  }

  public synchronized int getCount() {
    return count;
  }
}

public class Example {
  public static void main(String[] args) throws InterruptedException {
    Counter counter = new Counter();

    Thread t1 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) counter.increment();
    });

    Thread t2 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) counter.increment();
    });

    t1.start();
    t2.start();
    t1.join();
    t2.join();

    System.out.println("Final count: " + counter.getCount());
  }
}

Because the methods are synchronized, the counter’s value will always be correct, even though two threads are incrementing it concurrently.

Synchronized blocks

Instead of synchronizing an entire method, you can limit synchronization to a smaller block of code. This improves performance by reducing the amount of time a lock is held.

class PartialCounter {
  private int count = 0;
  private final Object lock = new Object();

  public void increment() {
    synchronized (lock) {
      count++;
    }
  }

  public int getCount() {
    synchronized (lock) {
      return count;
    }
  }
}

Here, synchronization is explicit and localized, which helps reduce contention between threads.

Reentrant locks

The java.util.concurrent.locks package introduces more flexible locking mechanisms, such as ReentrantLock. Unlike synchronized methods, these locks allow explicit control over when a lock is acquired and released, as well as features like timed and interruptible waits.

import java.util.concurrent.locks.ReentrantLock;

class SafeCounter {
  private int count = 0;
  private final ReentrantLock lock = new ReentrantLock();

  public void increment() {
    lock.lock();
    try {
      count++;
    } finally {
      lock.unlock();
    }
  }

  public int getCount() {
    lock.lock();
    try {
      return count;
    } finally {
      lock.unlock();
    }
  }
}

Reentrant and fairness properties

A ReentrantLock is reentrant, meaning a thread that already holds the lock can reacquire it without blocking itself. You can also construct a lock with a fairness policy, ensuring that threads acquire locks in the order they requested them, though this can reduce overall throughput.

ReentrantLock fairLock = new ReentrantLock(true);

While synchronized methods and blocks are simpler and sufficient for most use cases, explicit locks give greater flexibility and control in complex concurrency designs.

Executors and thread pools

Manually creating and managing threads works for simple programs, but it quickly becomes inefficient in larger systems. Constantly starting and stopping threads wastes resources, and it can be difficult to coordinate many concurrent tasks. To solve this, Java provides the Executor framework, which manages a pool of reusable threads that can execute tasks on demand.

The Executor interface

The Executor interface represents a simple abstraction for launching tasks. Instead of directly creating threads, you submit a Runnable (or Callable) to an executor that handles scheduling and execution.

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class Example {
  public static void main(String[] args) {
    Executor executor = Executors.newSingleThreadExecutor();
    executor.execute(() -> {
      System.out.println("Task running in executor thread");
    });
  }
}

This example uses a single-threaded executor that runs one task at a time. The execute() method accepts a Runnable and handles thread creation, execution, and cleanup automatically.

Thread pools with ExecutorService

The ExecutorService interface extends Executor with lifecycle management and task submission methods that can return results. You typically create one using a factory method in the Executors class.

import java.util.concurrent.*;

public class PoolExample {
  public static void main(String[] args) throws InterruptedException {
    ExecutorService pool = Executors.newFixedThreadPool(3);

    for (int i = 1; i <= 5; i++) {
      int taskId = i;
      pool.submit(() -> {
        System.out.println("Task " + taskId + " running on " +
          Thread.currentThread().getName());
      });
    }

    pool.shutdown();  // Prevent new tasks
    pool.awaitTermination(1, TimeUnit.MINUTES);
  }
}

Here, a pool of three threads executes five tasks. When one thread finishes, it becomes available for the next queued task. This approach maximizes CPU utilization while avoiding the overhead of creating new threads for each operation.

Callable and Future

The Callable interface is similar to Runnable but can return a result or throw an exception. When you submit a Callable to an executor, it returns a Future object that represents the pending result.

import java.util.concurrent.*;

public class CallableExample {
  public static void main(String[] args) throws Exception {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    Callable<Integer> task = () -> {
      Thread.sleep(1000);
      return 42;
    };

    Future<Integer> future = executor.submit(task);
    System.out.println("Result: " + future.get());
    executor.shutdown();
  }
}

The Future allows you to check whether a task is complete, cancel it if necessary, or retrieve its result using get().

Common executor types

The Executors utility class provides several predefined factory methods:

• newSingleThreadExecutor() — One reusable thread.
• newFixedThreadPool(int n) — A pool with a fixed number of threads.
• newCachedThreadPool() — A flexible pool that creates threads as needed.
• newScheduledThreadPool(int n) — Executes tasks after a delay or periodically.

Using these built-in executors makes it easy to tune concurrency behavior for different workloads without manually managing thread creation or cleanup.

Shutting down executors

Executors do not stop automatically when your main thread ends. Always shut them down cleanly to free system resources:

executor.shutdown();     // Graceful stop
// or
executor.shutdownNow();  // Forceful stop

shutdown() lets tasks finish gracefully, while shutdownNow() attempts to interrupt running tasks immediately.

Concurrent collections

In multithreaded applications, sharing data structures between threads can easily lead to race conditions and data corruption if access is not properly synchronized. To make this easier, Java provides a set of thread-safe collection classes in the java.util.concurrent package. These concurrent collections are designed for high performance and safe access without the need for explicit synchronization by the programmer.

Limitations of synchronized collections

Before the java.util.concurrent package was introduced, developers often used synchronized wrappers like Collections.synchronizedList() or Collections.synchronizedMap() to make standard collections thread-safe. While this works, the entire collection is locked for every operation, creating a performance bottleneck when many threads compete for access.

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

These wrappers ensure correctness, but they serialize access to the entire collection, reducing concurrency. Modern concurrent collections overcome this limitation through fine-grained locking or lock-free algorithms.

ConcurrentHashMap

ConcurrentHashMap is a highly efficient, thread-safe alternative to HashMap. It uses segmented locking to allow multiple threads to read and update the map simultaneously, provided they operate on different parts of the map. This makes it ideal for caches, registries, and other shared data structures.

import java.util.concurrent.ConcurrentHashMap;

public class Example {
  public static void main(String[] args) {
    ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    map.put("A", 1);
    map.put("B", 2);

    map.computeIfAbsent("C", k -> 3);
    map.forEach((k, v) -> System.out.println(k + ": " + v));
  }
}

Most operations on a ConcurrentHashMap are atomic, meaning you can safely modify it from multiple threads without additional synchronization.

Concurrent queues and deques

Concurrent queue implementations allow safe insertion and retrieval from multiple threads. Common examples include ConcurrentLinkedQueue, which uses a lock-free algorithm for high throughput, and LinkedBlockingQueue, which supports capacity limits and blocking operations.

import java.util.concurrent.*;

public class QueueExample {
  public static void main(String[] args) throws InterruptedException {
    BlockingQueue<String> queue = new LinkedBlockingQueue<>(3);

    new Thread(() -> {
      try {
        queue.put("Message 1");
        queue.put("Message 2");
        queue.put("Message 3");
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
      }
    }).start();

    Thread.sleep(500);
    while (!queue.isEmpty()) {
      System.out.println(queue.take());
    }
  }
}

BlockingQueue is especially useful in producer-consumer designs, where one thread produces items and another consumes them. The queue automatically coordinates access between threads.

CopyOnWrite collections

The CopyOnWriteArrayList and CopyOnWriteArraySet classes provide thread safety by creating a new internal copy of the data each time it is modified. This makes them ideal for collections that are read frequently and modified rarely, such as lists of event listeners or configuration settings.

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyExample {
  public static void main(String[] args) {
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
    list.add("One");
    list.add("Two");

    for (String s : list) {
      System.out.println(s);
      list.add("Three");  // Safe during iteration
    }
  }
}

Because iteration is performed on a stable snapshot of the collection, you can safely modify it during iteration without triggering ConcurrentModificationException.

Other concurrent utilities

The java.util.concurrent package also includes supporting classes like DelayQueue, PriorityBlockingQueue, and ConcurrentSkipListMap for specialized scenarios such as delayed execution, priority ordering, or sorted concurrent access.

These collections combine the safety of synchronization with the performance of fine-grained locking and non-blocking algorithms, making them essential tools for modern concurrent programming in Java.

CompletableFuture and async patterns

The CompletableFuture class provides a modern approach to asynchronous programming in Java. It builds upon the traditional Future interface but adds powerful methods for composing, chaining, and combining asynchronous tasks without blocking threads. With CompletableFuture, you can write clean, non-blocking code that efficiently utilizes system resources.

Basic usage

A CompletableFuture represents a computation that may complete at some point in the future, either successfully with a result or exceptionally with an error. You can create one manually or start an asynchronous task using factory methods like supplyAsync() or runAsync().

import java.util.concurrent.*;

public class BasicExample {
  public static void main(String[] args) {
    CompletableFuture<String> future =
      CompletableFuture.supplyAsync(() -> "Hello, world!");

    System.out.println(future.join());  // Waits and retrieves the result
  }
}

The join() method blocks until the result is available, but in real applications, you can chain further computations instead of waiting synchronously.

Chaining asynchronous tasks

CompletableFuture supports fluent chaining of dependent actions through methods such as thenApply(), thenAccept(), and thenRun(). These methods execute automatically when the preceding stage completes.

CompletableFuture.supplyAsync(() -> "Java")
  .thenApply(s -> s + " Concurrency")
  .thenApply(String::toUpperCase)
  .thenAccept(System.out::println);

This sequence runs each stage asynchronously without blocking, resulting in output like JAVA CONCURRENCY.

Combining multiple futures

You can coordinate several asynchronous computations using methods such as thenCombine() or allOf(). This allows tasks to run in parallel and merge their results when all are complete.

CompletableFuture<String> f1 =
  CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> f2 =
  CompletableFuture.supplyAsync(() -> "World");

CompletableFuture<String> combined =
  f1.thenCombine(f2, (a, b) -> a + " " + b);

System.out.println(combined.join());

Here, both futures run concurrently. When both complete, the results are combined into a single string.

Error handling

Asynchronous tasks may fail or throw exceptions. CompletableFuture provides methods such as exceptionally() and handle() to recover or handle errors gracefully.

CompletableFuture<Integer> result =
  CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("Oops!");
    return 10;
  })
  .exceptionally(ex -> {
    System.out.println("Error: " + ex.getMessage());
    return 0;
  });

System.out.println("Result: " + result.join());

Running multiple tasks in parallel

With allOf() and anyOf(), you can coordinate many concurrent tasks efficiently. allOf() waits for all to finish, while anyOf() completes as soon as one finishes.

CompletableFuture<String> a =
  CompletableFuture.supplyAsync(() -> "A done");
CompletableFuture<String> b =
  CompletableFuture.supplyAsync(() -> "B done");
CompletableFuture<String> c =
  CompletableFuture.supplyAsync(() -> "C done");

CompletableFuture.allOf(a, b, c)
  .thenRun(() -> System.out.println("All tasks finished"));

This model is ideal for tasks such as web requests, computations, or file operations that can be processed concurrently.

Custom executors

By default, CompletableFuture uses the common ForkJoinPool, but you can provide your own executor to control concurrency level and thread management.

ExecutorService pool = Executors.newFixedThreadPool(4);

CompletableFuture<String> task =
  CompletableFuture.supplyAsync(() -> "Task completed", pool);

System.out.println(task.join());
pool.shutdown();

Using a custom executor gives you predictable performance and better control over system resources in large applications.

Chapter 17: Input, Output, and Networking

Modern software often relies on data exchange between files, devices, and remote systems. Java provides a comprehensive set of APIs for handling input and output (I/O) operations, along with powerful networking capabilities for building connected applications. From reading files and streams to communicating over sockets or HTTP, Java’s I/O and networking frameworks make it possible to create efficient and secure data-driven systems.

The core I/O libraries are built around the concept of streams; sequences of data that can be read from or written to various sources, such as files, network connections, or memory buffers. The java.io and java.nio packages provide both traditional and non-blocking approaches for working with data streams and channels, while higher-level classes simplify tasks like object serialization or file manipulation.

Networking support is equally robust. The java.net package enables communication over TCP and UDP sockets, while the modern HttpClient API provides an easy way to perform HTTP requests asynchronously. Together, these allow you to build everything from low-level network tools to full-featured web clients and distributed systems.

This chapter explores the key techniques for managing I/O and network communication in Java. You will learn how to open and use sockets, send and receive data streams, make web requests, serialize objects for transmission, and apply safe practices for handling resources and exceptions in networked environments.

Working with sockets

Sockets provide the foundation for network communication in Java. A socket represents one endpoint of a two-way communication link between two programs running on a network. Java’s java.net package offers both high-level and low-level APIs for creating client and server sockets, allowing applications to exchange data over TCP or UDP connections.

TCP sockets

TCP (Transmission Control Protocol) provides reliable, ordered communication between applications. In Java, TCP communication is handled using the Socket and ServerSocket classes. A server listens for incoming connections on a specific port, while a client connects to that port on the server’s address.

import java.io.*;
import java.net.*;

// Simple server example
public class SimpleServer {
  public static void main(String[] args) throws IOException {
    ServerSocket server = new ServerSocket(5000);
    System.out.println("Server waiting for connection...");

    Socket client = server.accept();
    PrintWriter out = new PrintWriter(client.getOutputStream(), true);
    out.println("Hello from the server!");

    client.close();
    server.close();
  }
}

import java.io.*;
import java.net.*;

// Simple client example
public class SimpleClient {
  public static void main(String[] args) throws IOException {
    Socket socket = new Socket("localhost", 5000);
    BufferedReader in = new BufferedReader(
      new InputStreamReader(socket.getInputStream())
    );

    System.out.println("Message: " + in.readLine());
    socket.close();
  }
}

In this example, the server accepts a connection from the client, sends a text message, and then closes the socket. TCP ensures that the message arrives reliably and in the correct order.

Using try-with-resources for sockets

Since Java 7, you can simplify socket handling using the try-with-resources construct, which automatically closes connections even if an exception occurs.

try (ServerSocket server = new ServerSocket(6000);
     Socket client = server.accept();
     PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {
  out.println("Connected safely!");
}

This pattern helps ensure clean termination of network resources, reducing the risk of hanging connections or resource exhaustion.

UDP sockets

UDP (User Datagram Protocol) is a connectionless, lightweight protocol that sends data packets without guaranteeing delivery or order. It is often used in applications like games, streaming, or sensor data where speed is more important than reliability. Java supports UDP with DatagramSocket and DatagramPacket.

import java.net.*;

// UDP sender
public class UDPSender {
  public static void main(String[] args) throws IOException {
    DatagramSocket socket = new DatagramSocket();
    byte[] data = "Hello UDP".getBytes();
    InetAddress address = InetAddress.getByName("localhost");

    DatagramPacket packet = new DatagramPacket(data, data.length, address, 7000);
    socket.send(packet);
    socket.close();
  }
}

import java.net.*;

// UDP receiver
public class UDPReceiver {
  public static void main(String[] args) throws IOException {
    DatagramSocket socket = new DatagramSocket(7000);
    byte[] buffer = new byte[256];

    DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
    socket.receive(packet);

    String message = new String(packet.getData(), 0, packet.getLength());
    System.out.println("Received: " + message);
    socket.close();
  }
}

Unlike TCP, UDP does not establish a connection. Each packet (datagram) is sent independently, making it faster but less reliable.

Ports and addressing

Every socket communicates through a specific IP address and port number. Common ports include 80 for HTTP and 443 for HTTPS, but user applications typically use higher-numbered ports (above 1024). Java’s InetAddress class provides methods to resolve hostnames and retrieve local network information.

InetAddress local = InetAddress.getLocalHost();
System.out.println("Local host: " + local.getHostName());
System.out.println("IP address: " + local.getHostAddress());

Understanding addressing and port management is essential for ensuring that your application connects correctly and avoids conflicts with other services.

HTTP clients

While sockets provide low-level network access, most modern applications communicate using higher-level protocols such as HTTP. Java’s HttpClient API, introduced in Java 11, offers a powerful and convenient way to send HTTP requests and process responses using a fluent, asynchronous design. It replaces older classes like HttpURLConnection with a cleaner, more flexible interface.

Creating a basic HTTP client

The HttpClient class represents a reusable, thread-safe client that can send requests and handle responses. You can create one using its builder pattern:

import java.net.http.*;
import java.net.URI;

public class SimpleRequest {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();

    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://example.com"))
      .build();

    HttpResponse<String> response =
      client.send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println("Status: " + response.statusCode());
    System.out.println("Body:\n" + response.body());
  }
}

This example performs a simple GET request and prints the HTTP status code and response body. The BodyHandlers utility provides predefined ways to process the response, such as reading it as text or writing it to a file.

Sending asynchronous requests

To keep programs responsive, you can perform HTTP requests asynchronously using the sendAsync() method. This returns a CompletableFuture that completes when the response arrives.

import java.net.http.*;
import java.net.URI;
import java.util.concurrent.*;

public class AsyncExample {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();

    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://example.com/data"))
      .build();

    CompletableFuture<HttpResponse<String>> future =
      client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

    future.thenAccept(response -> {
      System.out.println("Status: " + response.statusCode());
      System.out.println("Response: " + response.body());
    });

    future.join();
  }
}

Because sendAsync() integrates with CompletableFuture, you can chain multiple asynchronous operations, such as transforming or saving the response once it arrives.

Custom headers and POST requests

HTTP requests often need additional headers or body data, especially when working with APIs. You can add these easily using the HttpRequest builder.

import java.net.http.*;
import java.net.URI;

public class PostExample {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();

    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://httpbin.org/post"))
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"Robin\"}"))
      .build();

    HttpResponse<String> response =
      client.send(request, HttpResponse.BodyHandlers.ofString());

    System.out.println("Response: " + response.body());
  }
}

The BodyPublishers class provides several methods for sending content, including ofString(), ofFile(), and ofInputStream().

Handling timeouts and redirects

You can customize client behavior using HttpClient.Builder to set timeouts, redirect policies, and proxy configurations.

HttpClient client = HttpClient.newBuilder()
  .connectTimeout(java.time.Duration.ofSeconds(5))
  .followRedirects(HttpClient.Redirect.NORMAL)
  .build();

Redirect policies can be set to NEVER, NORMAL, or ALWAYS, depending on how you want the client to handle redirection responses (such as HTTP 301 or 302).

Downloading files

To download large files efficiently, you can use a file-based body handler that streams data directly to disk instead of keeping it in memory.

import java.nio.file.*;
import java.net.http.*;
import java.net.URI;

public class DownloadExample {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://example.com/file.zip"))
      .build();

    HttpResponse<Path> response = client.send(
      request,
      HttpResponse.BodyHandlers.ofFile(Paths.get("file.zip"))
    );

    System.out.println("Downloaded to: " + response.body());
  }
}

The BodyHandlers.ofFile() method allows efficient file downloads without consuming excessive memory, which is especially useful for large content transfers.

Reading URLs and streams

Before the modern HttpClient API, the java.net package provided the URL and URLConnection classes for working with online resources. These remain useful for simple tasks such as reading a text file or JSON feed from a web address. They operate using familiar stream-based I/O, allowing data to be processed line by line or byte by byte.

Reading text from a URL

The URL class represents an address to a resource, and its openStream() method provides an InputStream for reading data directly. This makes it easy to access text-based content like web pages or configuration files.

import java.net.*;
import java.io.*;

public class URLReader {
  public static void main(String[] args) {
    try {
      URL url = new URL("https://example.com");
      try (BufferedReader in = new BufferedReader(
             new InputStreamReader(url.openStream()))) {

        String line;
        while ((line = in.readLine()) != null) {
          System.out.println(line);
        }
      }
    } catch (IOException e) {
      System.err.println("Error: " + e.getMessage());
    }
  }
}

This example reads a web page line by line and prints it to the console. The try-with-resources block ensures that the stream is closed automatically when finished.

Working with URLConnection

For more control, such as setting headers or handling metadata, you can use URLConnection. This class lets you configure connection parameters before opening the input or output streams.

import java.net.*;
import java.io.*;

public class ConnectionExample {
  public static void main(String[] args) throws IOException {
    URL url = new URL("https://example.com/data.json");
    URLConnection conn = url.openConnection();

    conn.setRequestProperty("User-Agent", "JavaClient/1.0");
    try (BufferedReader reader = new BufferedReader(
           new InputStreamReader(conn.getInputStream()))) {

      String line;
      while ((line = reader.readLine()) != null) {
        System.out.println(line);
      }
    }
  }
}

The URLConnection class works with both HTTP and file URLs, allowing code reuse across different data sources with minimal changes.

Reading binary data

When working with images, PDFs, or other binary content, use byte streams instead of character streams. The InputStream interface provides methods for reading raw byte data efficiently.

import java.net.*;
import java.io.*;
import java.nio.file.*;

public class BinaryDownload {
  public static void main(String[] args) throws IOException {
    URL url = new URL("https://example.com/image.jpg");
    try (InputStream in = url.openStream()) {
      Files.copy(in, Paths.get("image.jpg"), StandardCopyOption.REPLACE_EXISTING);
    }
    System.out.println("Download complete.");
  }
}

This approach copies the content of the URL directly to a file using the Files.copy() method, ideal for handling binary data without manually managing buffers.

Reading from local and classpath resources

The same stream-based approach applies to local files or classpath resources. The FileInputStream class reads from disk, while ClassLoader.getResourceAsStream() reads from packaged files inside JARs.

// Reading a file from disk
try (InputStream in = new FileInputStream("config.txt")) {
  in.transferTo(System.out);
}

// Reading a resource from classpath
try (InputStream in = MyClass.class.getResourceAsStream("/data/config.txt")) {
  if (in != null) in.transferTo(System.out);
}

Using consistent stream handling across URLs, files, and embedded resources helps maintain a unified data-access strategy throughout your application.

Serialization over networks

Serialization is the process of converting an object’s state into a format that can be stored or transmitted, then reconstructed later. In Java, serialization is most commonly achieved using the Serializable interface, which marks a class as capable of being converted into a byte stream. This mechanism can be used to send complex data structures over a network or save them to a file.

The Serializable interface

Any class that implements java.io.Serializable can be serialized automatically by Java’s I/O system. No methods need to be defined; just the marker interface itself is enough. However, all fields within the object must also be serializable, or they must be marked transient to be skipped during the process.

import java.io.*;

class Message implements Serializable {
  private String text;
  private int id;

  public Message(String text, int id) {
    this.text = text;
    this.id = id;
  }

  public String toString() {
    return "Message[" + id + "]: " + text;
  }
}

This class can now be serialized and transmitted over a network stream or saved to disk using ObjectOutputStream and ObjectInputStream.

Sending objects across sockets

Java’s object streams make it simple to send and receive serialized objects over TCP connections. On the server side, you write an object to an ObjectOutputStream; on the client side, you read it back with an ObjectInputStream.

import java.io.*;
import java.net.*;

// Server sending a serialized object
public class ObjectServer {
  public static void main(String[] args) throws IOException {
    try (ServerSocket server = new ServerSocket(8000);
         Socket client = server.accept();
         ObjectOutputStream out =
           new ObjectOutputStream(client.getOutputStream())) {

      Message msg = new Message("Hello client", 1);
      out.writeObject(msg);
      out.flush();
    }
  }
}

import java.io.*;
import java.net.*;

// Client receiving a serialized object
public class ObjectClient {
  public static void main(String[] args) throws Exception {
    try (Socket socket = new Socket("localhost", 8000);
         ObjectInputStream in =
           new ObjectInputStream(socket.getInputStream())) {

      Message msg = (Message) in.readObject();
      System.out.println("Received: " + msg);
    }
  }
}

This pattern allows entire object hierarchies to be sent between programs with minimal code. The only requirement is that the classes involved implement Serializable.

private static final long serialVersionUID = 1L;

Transient fields

Some data should not be serialized; for example, sensitive information or temporary resources like open file handles or network connections. You can exclude these fields by marking them transient.

class UserSession implements Serializable {
  private String username;
  private transient String password;
}

When deserialized, transient fields are set to their default values (such as null or 0), since they are not written to the stream.

Customizing serialization

You can control how objects are serialized by defining private methods writeObject() and readObject() within your class. These are called automatically during serialization and deserialization, allowing you to encrypt data, validate integrity, or modify the format.

private void writeObject(ObjectOutputStream out) throws IOException {
  out.defaultWriteObject();
  out.writeLong(System.currentTimeMillis());  // Add timestamp
}

private void readObject(ObjectInputStream in)
    throws IOException, ClassNotFoundException {
  in.defaultReadObject();
  long timestamp = in.readLong();
  System.out.println("Deserialized at: " + timestamp);
}

Alternative serialization formats

Although Java’s built-in serialization is convenient, it is primarily suited for trusted systems where both sender and receiver use the same class definitions. For cross-platform communication or public APIs, it is better to use standardized formats such as JSON, XML, or binary protocols like Protocol Buffers.

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonExample {
  public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    Message msg = new Message("JSON hello", 2);

    String json = mapper.writeValueAsString(msg);
    System.out.println(json);
  }
}

Using formats like JSON ensures interoperability between different programming languages and platforms, making them ideal for distributed systems and RESTful services.

Security and exception hygiene

When working with I/O and networking in Java, maintaining security and robust error handling is essential. Networked applications operate in unpredictable environments. Connections can fail, input can be malformed, and malicious data can exploit poorly secured systems. Good exception hygiene and defensive programming practices are key to building reliable and secure communication systems.

Validating input and avoiding injection

Always validate and sanitize incoming data, whether it comes from user input, a network stream, or a file. Never assume that external data is well-formed or trustworthy. For example, when parsing URLs or parameters, verify expected formats and ranges before use.

import java.net.*;

public class SafeURL {
  public static void main(String[] args) {
    try {
      String input = "https://example.com";
      URI uri = new URI(input);

      if (!"https".equalsIgnoreCase(uri.getScheme())) {
        throw new IllegalArgumentException("Only HTTPS is allowed");
      }

      System.out.println("Validated: " + uri);
    } catch (Exception e) {
      System.err.println("Invalid input: " + e.getMessage());
    }
  }
}

Failing to check input can lead to command injection, directory traversal, or denial-of-service attacks. Restrict access to trusted protocols and sanitize strings used in file paths or system commands.

Using encryption and secure protocols

When transmitting sensitive information, always use secure connections such as HTTPS or SSL/TLS. Java’s SSLSocket and HttpsURLConnection classes support encrypted communication channels that protect data in transit from interception or tampering.

import javax.net.ssl.HttpsURLConnection;
import java.net.*;
import java.io.*;

public class SecureConnection {
  public static void main(String[] args) throws Exception {
    URL url = new URL("https://example.com/secure");
    HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

    try (BufferedReader in = new BufferedReader(
           new InputStreamReader(conn.getInputStream()))) {
      System.out.println("Response code: " + conn.getResponseCode());
      in.lines().forEach(System.out::println);
    }
  }
}

Modern Java versions verify SSL certificates automatically. However, avoid disabling verification (for example, with custom trust managers) unless absolutely necessary for controlled testing environments.

Exception hygiene

Most I/O and networking operations can throw checked exceptions such as IOException, SocketTimeoutException, or UnknownHostException. Always handle these appropriately to ensure that failures do not leave resources open or applications in an unstable state.

try (Socket socket = new Socket("example.com", 80);
     PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
  out.println("GET / HTTP/1.1");
} catch (IOException e) {
  System.err.println("Connection failed: " + e.getMessage());
}

The try-with-resources statement ensures that sockets and streams are closed automatically, even if exceptions occur. Always log errors meaningfully but avoid exposing sensitive internal details in messages sent to users or clients.

Timeouts and resource limits

Set timeouts for network operations to prevent hanging connections and resource exhaustion. Most network classes in Java provide timeout settings through constructors or configuration methods.

Socket socket = new Socket();
socket.connect(new InetSocketAddress("example.com", 80), 3000);  // 3-second timeout
socket.setSoTimeout(5000);  // 5-second read timeout

Time limits ensure that threads are not blocked indefinitely due to network latency or unreachable hosts. Similarly, use thread pools, bounded queues, and memory limits to control system load under heavy traffic.

Secure serialization and deserialization

Deserializing untrusted data is one of the most common security vulnerabilities in networked applications. Java’s native serialization mechanism can instantiate arbitrary classes, leading to potential remote code execution if input is malicious. To mitigate this, never deserialize objects from unknown sources, or restrict allowed classes with an ObjectInputFilter.

import java.io.*;

public class SafeDeserialization {
  public static void main(String[] args) throws Exception {
    ObjectInputFilter filter = ObjectInputFilter.Config.createFilter("com.example.*;!*");
    try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.ser"))) {
      in.setObjectInputFilter(filter);
      Object obj = in.readObject();
      System.out.println("Read: " + obj);
    }
  }
}

This approach ensures that only classes from trusted packages are allowed during deserialization, greatly reducing attack surface.

Chapter 18: Working with Data and JSON

Modern applications rely heavily on structured data, whether it comes from configuration files, APIs, databases, or web services. In Java, working with data formats such as JSON and XML is a fundamental skill, as these formats are widely used to exchange and store information across systems and platforms. Java provides both built-in and third-party libraries that make parsing, generating, validating, and transforming data straightforward and efficient.

JSON (JavaScript Object Notation) has become the de facto standard for lightweight data exchange due to its readability and ease of use. Java includes multiple APIs and libraries for processing JSON, such as the built-in java.json package, and popular third-party libraries like Gson and Jackson. XML, though older, remains prevalent in enterprise systems, configuration files, and standards such as SOAP and SVG. Java’s DOM and SAX parsers offer reliable ways to read and manipulate XML data structures.

This chapter explores how to parse and produce JSON and XML, how to use high-level data-binding libraries to convert between Java objects and text formats, and how to validate and transform data for integration between systems. Practical examples will demonstrate reading from APIs, creating structured data output, and mapping Java objects to portable representations that work seamlessly across platforms.

Parsing and generating JSON

JSON (JavaScript Object Notation) is a lightweight text format used to represent structured data. It is language-independent, simple to read, and easy to generate, making it the preferred choice for modern APIs and configuration files. In Java, you can work with JSON using either the built-in java.json package (part of Jakarta EE and available in several standard distributions) or third-party libraries like Gson and Jackson.

Understanding JSON structure

JSON represents data as key–value pairs inside objects and arrays. A typical JSON object might look like this:

{
  "name": "Robin",
  "age": 42,
  "languages": ["Java", "Python", "C"],
  "active": true
}

This example defines an object with string, numeric, array, and boolean values. In Java, such data can be represented using maps, lists, and primitive types.

Parsing JSON with javax.json

The javax.json API (also available as jakarta.json in newer versions) provides classes such as JsonReader, JsonObject, and JsonArray for reading and writing JSON in a streaming or object-based manner.

import javax.json.*;
import java.io.*;

public class JsonParsing {
  public static void main(String[] args) throws Exception {
    String json = "{ \"name\": \"Robin\", \"age\": 42 }";
    try (JsonReader reader = Json.createReader(new StringReader(json))) {
      JsonObject obj = reader.readObject();
      System.out.println("Name: " + obj.getString("name"));
      System.out.println("Age: " + obj.getInt("age"));
    }
  }
}

The JsonReader reads data into a structured JsonObject, allowing you to access fields using type-safe getter methods.

Creating JSON objects

You can construct JSON programmatically using JsonObjectBuilder and JsonArrayBuilder, then serialize it to text.

import javax.json.*;
import java.io.StringWriter;

public class JsonBuilding {
  public static void main(String[] args) {
    JsonObject person = Json.createObjectBuilder()
      .add("name", "Robin")
      .add("age", 42)
      .add("languages", Json.createArrayBuilder()
        .add("Java")
        .add("Python")
        .add("C"))
      .build();

    StringWriter writer = new StringWriter();
    Json.createWriter(writer).write(person);
    System.out.println(writer.toString());
  }
}

This produces a properly formatted JSON string that can be saved or transmitted. The builder pattern provides a clear, readable way to construct complex JSON structures.

Streaming JSON parsing

For very large JSON documents, the streaming API reads data incrementally, avoiding the need to load entire structures into memory. It operates similarly to an XML SAX parser, generating events for each key or value encountered.

import javax.json.stream.*;
import java.io.*;

public class JsonStreamExample {
  public static void main(String[] args) throws Exception {
    String json = "{\"x\":10, \"y\":20}";
    try (JsonParser parser = Json.createParser(new StringReader(json))) {
      while (parser.hasNext()) {
        JsonParser.Event event = parser.next();
        System.out.println(event);
      }
    }
  }
}

This approach is useful for parsing large data feeds or log streams efficiently without building the full JSON object tree.

Generating JSON manually

You can also generate JSON strings manually using Java’s standard types or libraries like Gson and Jackson. For simple cases, concatenating strings may suffice, but structured builders or mappers are safer and more maintainable.

String json = String.format(
  "{ \"name\": \"%s\", \"age\": %d }", "Robin", 42
);
System.out.println(json);

This manual method works for small tasks, but for larger or dynamic data structures, prefer dedicated JSON APIs that ensure correct formatting and escaping.

XML basics with DOM and SAX

XML (Extensible Markup Language) is a structured format for representing hierarchical data. It is widely used in enterprise systems, configuration files, and standards-based data exchange. Unlike JSON, XML includes metadata in the form of tags and attributes, making it suitable for schemas, validation, and complex document structures.

Java provides robust XML handling through its standard libraries in javax.xml (or jakarta.xml in newer platforms). The two main processing models are DOM (Document Object Model) and SAX (Simple API for XML). DOM loads an entire XML document into memory as a tree structure, while SAX processes the document sequentially using events. Each approach is suited to different needs.

Parsing XML with DOM

The DOM API represents an XML document as a tree of nodes that can be traversed and manipulated. It is easy to use for smaller documents where random access to elements is needed.

import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;

public class DOMExample {
  public static void main(String[] args) throws Exception {
    File file = new File("example.xml");
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document doc = builder.parse(file);

    Element root = doc.getDocumentElement();
    System.out.println("Root element: " + root.getTagName());

    NodeList items = doc.getElementsByTagName("item");
    for (int i = 0; i < items.getLength(); i++) {
      Element item = (Element) items.item(i);
      System.out.println("Item: " + item.getTextContent());
    }
  }
}

DOM is intuitive and supports full modification of the XML structure, including adding, removing, or updating elements and attributes.

Generating XML with DOM

DOM can also be used to create XML documents from scratch. You can build elements programmatically and write them to a file or stream.

import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;

public class DOMWrite {
  public static void main(String[] args) throws Exception {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document doc = builder.newDocument();

    Element root = doc.createElement("books");
    doc.appendChild(root);

    Element book = doc.createElement("book");
    book.setAttribute("id", "1");
    book.setTextContent("Learning Java");
    root.appendChild(book);

    Transformer transformer = TransformerFactory.newInstance().newTransformer();
    transformer.setOutputProperty(OutputKeys.INDENT, "yes");
    transformer.transform(new DOMSource(doc), new StreamResult(System.out));
  }
}

This example builds a simple XML tree and prints it to standard output with indentation for readability.

Parsing XML with SAX

SAX provides an event-driven approach, where the parser triggers callbacks as it reads through the document. This method is far more memory-efficient than DOM, making it suitable for large XML files or continuous data streams.

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class SAXExample extends DefaultHandler {
  public void startElement(String uri, String localName,
                           String qName, Attributes attributes) {
    System.out.println("Start element: " + qName);
  }

  public void characters(char[] ch, int start, int length) {
    System.out.println("Text: " + new String(ch, start, length).trim());
  }

  public void endElement(String uri, String localName, String qName) {
    System.out.println("End element: " + qName);
  }

  public static void main(String[] args) throws Exception {
    SAXParserFactory factory = SAXParserFactory.newInstance();
    SAXParser parser = factory.newSAXParser();
    parser.parse("example.xml", new SAXExample());
  }
}

With SAX, you define handlers for events such as element starts, text content, and element ends. Because the parser does not build a full in-memory representation, it can process extremely large files efficiently.

Choosing between DOM and SAX

The choice between DOM and SAX depends on your needs:

• DOM: Best for small to medium documents where you need full control and manipulation of the XML tree.
• SAX: Best for large or streamed XML data where efficiency and low memory usage are priorities.

In modern Java applications, these core parsers remain the foundation for more advanced XML frameworks such as JAXB and StAX, which combine convenience with performance.

Using Gson and Jackson

While Java’s built-in JSON libraries are capable and standards-compliant, most modern developers prefer higher-level libraries such as Gson and Jackson. These libraries make it easy to convert between Java objects and JSON (a process known as data binding), offering concise syntax, strong typing, and advanced features such as custom serialization, field filtering, and streaming.

Working with Gson

Gson is a popular JSON library from Google that provides simple APIs for parsing and generating JSON. It automatically converts Java objects to JSON and back again, using reflection to map field names and types.

import com.google.gson.Gson;

class Person {
  String name;
  int age;
  boolean active;

  Person(String name, int age, boolean active) {
    this.name = name;
    this.age = age;
    this.active = active;
  }
}

public class GsonExample {
  public static void main(String[] args) {
    Gson gson = new Gson();

    // Serialize Java object to JSON
    Person person = new Person("Robin", 42, true);
    String json = gson.toJson(person);
    System.out.println("JSON: " + json);

    // Deserialize JSON back to object
    Person copy = gson.fromJson(json, Person.class);
    System.out.println("Name: " + copy.name + ", Age: " + copy.age);
  }
}

Gson supports nested objects, lists, and maps automatically. It also provides options for pretty-printing, excluding fields, and handling nulls or special data types.

Customizing serialization in Gson

You can customize how Gson serializes and deserializes objects by using annotations or adapters. For example, to change field names in JSON, use @SerializedName.

import com.google.gson.annotations.SerializedName;

class User {
  @SerializedName("full_name")
  String name;

  @SerializedName("user_age")
  int age;
}

Custom type adapters allow precise control over conversion logic, such as formatting dates or transforming special types.

Working with Jackson

Jackson is another widely used library that provides similar functionality but with a richer feature set and higher performance. It uses annotations, data binding, and a flexible streaming API for fine-grained control.

import com.fasterxml.jackson.databind.ObjectMapper;

class Product {
  public String name;
  public double price;
}

public class JacksonExample {
  public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();

    // Serialize object to JSON
    Product p = new Product();
    p.name = "Laptop";
    p.price = 899.99;
    String json = mapper.writeValueAsString(p);
    System.out.println("JSON: " + json);

    // Deserialize JSON to object
    Product result = mapper.readValue(json, Product.class);
    System.out.println("Product: " + result.name + " ($" + result.price + ")");
  }
}

Jackson automatically handles most Java types, including nested objects, collections, and generic containers. Its ObjectMapper can read and write to files, URLs, streams, or strings with equal ease.

Jackson annotations and configuration

Jackson supports annotations for customizing JSON mapping. For example, you can rename fields, ignore specific properties, or mark fields as required.

import com.fasterxml.jackson.annotation.*;

class Account {
  @JsonProperty("user_name")
  public String username;

  @JsonIgnore
  public String password;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  public String email;
}

These annotations give precise control over serialization behavior without requiring manual converters or adapters.

Streaming and large data handling

Jackson provides a powerful streaming API for reading and writing large JSON documents efficiently. It processes data incrementally, similar to SAX for XML, making it suitable for high-performance applications.

import com.fasterxml.jackson.core.*;

public class StreamExample {
  public static void main(String[] args) throws Exception {
    JsonFactory factory = new JsonFactory();

    // Writing JSON
    try (JsonGenerator gen = factory.createGenerator(System.out)) {
      gen.writeStartObject();
      gen.writeStringField("name", "Streamed JSON");
      gen.writeNumberField("version", 1);
      gen.writeEndObject();
    }
  }
}

Streaming avoids the need to build large object trees in memory, which is ideal for big data pipelines or log processing.

Data validation and transformation

Once data is loaded into your Java application (whether from JSON, XML, or another source) it is important to validate and transform it before use. Validation ensures that the data meets expected formats, ranges, and constraints, while transformation adapts it into the structures your program needs. Proper handling of these steps helps prevent bugs, runtime errors, and security vulnerabilities caused by malformed or unexpected input.

Validating data structures

Validation can be performed manually or through libraries such as Jakarta Bean Validation (formerly Java EE Bean Validation) that use annotations to enforce constraints on object fields.

import jakarta.validation.constraints.*;

public class User {
  @NotNull
  private String name;

  @Min(0)
  @Max(120)
  private int age;

  @Email
  private String email;
}

These annotations describe the allowed values for each field. A validator framework (for example, Hibernate Validator) can check objects automatically and report violations.

import jakarta.validation.*;
import java.util.Set;

public class ValidateExample {
  public static void main(String[] args) {
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();

    User user = new User();
    user.setName(null);
    user.setAge(200);
    user.setEmail("invalid");

    Set<ConstraintViolation<User>> violations = validator.validate(user);
    for (ConstraintViolation<User> v : violations) {
      System.out.println(v.getPropertyPath() + ": " + v.getMessage());
    }
  }
}

This approach centralizes validation rules within the data model itself, making it easier to maintain and reuse across projects.

Manual validation

For simple cases or when libraries are unavailable, manual checks are sufficient. These can include range checks, regular expressions, or logical constraints applied to incoming values.

public static boolean isValidAge(int age) {
  return age >= 0 && age <= 120;
}

public static boolean isValidEmail(String email) {
  return email != null && email.matches("^[\\w.%+-]+@[\\w.-]+\\.[A-Za-z]{2,6}$");
}

Manual validation is especially useful for lightweight programs or environments where dependency-free solutions are preferred.

Transforming JSON to Java objects

Once validated, data often needs to be transformed into domain-specific structures. Gson and Jackson both provide mechanisms to map raw JSON data into typed Java objects, handling nested structures automatically.

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.*;

class Post {
  public String title;
  public String author;
  public List<String> tags;
}

public class TransformExample {
  public static void main(String[] args) throws Exception {
    String json = "{ \"title\": \"Learning Java\", \"author\": \"Robin\", " +
                  "\"tags\": [\"Java\", \"Programming\"] }";

    ObjectMapper mapper = new ObjectMapper();
    Post post = mapper.readValue(json, Post.class);

    System.out.println("Title: " + post.title);
    System.out.println("Tags: " + post.tags);
  }
}

This data-binding approach automatically converts compatible types and builds lists, maps, and nested objects as needed.

Transforming between formats

Applications frequently need to convert between data formats such as JSON and XML. Jackson supports multiple data formats through modules like jackson-dataformat-xml, allowing seamless transformation between them.

import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.databind.ObjectMapper;

public class FormatConversion {
  public static void main(String[] args) throws Exception {
    ObjectMapper jsonMapper = new ObjectMapper();
    XmlMapper xmlMapper = new XmlMapper();

    String json = "{ \"name\": \"Robin\", \"age\": 42 }";

    // Convert JSON to XML
    Object obj = jsonMapper.readValue(json, Object.class);
    String xml = xmlMapper.writeValueAsString(obj);

    System.out.println(xml);
  }
}

Transforming data in this way allows a single data model to serve multiple endpoints or APIs without redundant logic.

Filtering and restructuring data

Transformation often involves reshaping or filtering large datasets before use or export. Libraries like Jackson’s JsonNode API provide a flexible tree model for traversing and modifying JSON dynamically.

import com.fasterxml.jackson.databind.*;

public class FilterExample {
  public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    String json = "{ \"name\":\"Robin\", \"role\":\"Author\", \"salary\":5000 }";

    JsonNode node = mapper.readTree(json);
    ((ObjectNode) node).remove("salary");

    System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(node));
  }
}

Filtering lets you control what information is passed along, helping to reduce data size and protect sensitive content when sharing results across systems or users.

Practical examples

To consolidate what you have learned about working with data in Java, this section demonstrates practical examples that combine parsing, validation, and transformation. These examples show how to load, process, and output JSON and XML data safely and efficiently in real-world scenarios.

Example 1: Reading and processing JSON API data

This example fetches JSON data from a web API using the HttpClient class, parses it with Jackson, and filters selected fields for display. It demonstrates asynchronous I/O combined with structured data handling.

import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.*;

public class ApiExample {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
      .build();

    HttpResponse<String> response =
      client.send(request, HttpResponse.BodyHandlers.ofString());

    ObjectMapper mapper = new ObjectMapper();
    JsonNode node = mapper.readTree(response.body());

    System.out.println("Title: " + node.get("title").asText());
    System.out.println("Body: " + node.get("body").asText());
  }
}

This program retrieves a JSON object, parses it into a JsonNode tree, and extracts specific properties without needing to define a dedicated Java class. This approach is ideal for exploratory or lightweight data integration tasks.

Example 2: Validating and transforming input data

The following example validates a JSON payload, converts it into a Java object, and writes the result to an XML file. It demonstrates data pipeline stages—input validation, transformation, and output formatting.

import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

class User {
  public String name;
  public String email;
  public int age;
}

public class DataPipeline {
  public static void main(String[] args) throws Exception {
    String json = "{ \"name\":\"Robin\", \"email\":\"robin@example.com\", \"age\":42 }";

    ObjectMapper jsonMapper = new ObjectMapper();
    XmlMapper xmlMapper = new XmlMapper();

    // Validate input fields
    JsonNode node = jsonMapper.readTree(json);
    if (!node.hasNonNull("name") || !node.hasNonNull("email")) {
      throw new IllegalArgumentException("Missing required fields");
    }

    // Transform to Java object and then to XML
    User user = jsonMapper.treeToValue(node, User.class);
    String xml = xmlMapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);

    System.out.println(xml);
  }
}

Here, JSON is validated for key fields before conversion, ensuring that only well-formed and complete data is transformed into XML. This pattern is especially useful in ETL (Extract, Transform, Load) systems and API gateways.

Example 3: Converting XML to JSON

Sometimes data originates in XML but needs to be served as JSON for modern web APIs. This example uses Jackson’s XML and JSON mappers to convert formats seamlessly.

import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.databind.ObjectMapper;

public class XmlToJson {
  public static void main(String[] args) throws Exception {
    String xml = "<user><name>Robin</name><age>42</age></user>";

    XmlMapper xmlMapper = new XmlMapper();
    ObjectMapper jsonMapper = new ObjectMapper();

    Object obj = xmlMapper.readValue(xml, Object.class);
    String json = jsonMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);

    System.out.println(json);
  }
}

This technique is valuable in legacy system integrations, where older XML-based services must interface with newer REST or JavaScript clients.

Example 4: Filtering and exporting selected fields

In data analytics and reporting, you often need to export only specific fields from a larger dataset. This example uses Jackson’s tree model to remove unwanted values before writing output.

import com.fasterxml.jackson.databind.*;
import java.io.File;

public class ExportExample {
  public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    JsonNode root = mapper.readTree(new File("data.json"));

    for (JsonNode node : root) {
      ((ObjectNode) node).remove("internalId");
      ((ObjectNode) node).remove("password");
    }

    mapper.writerWithDefaultPrettyPrinter().writeValue(
      new File("filtered.json"), root
    );

    System.out.println("Filtered data written to filtered.json");
  }
}

This ensures that sensitive or unnecessary data is excluded before export. The same technique can be used to anonymize or aggregate information for compliance and privacy reasons.

Example 5: Combining JSON and database data

JSON data is often combined with database content for reporting or integration. In this example, JSON records are read from a file and merged with database metadata before generating a combined output.

import com.fasterxml.jackson.databind.*;
import java.sql.*;
import java.util.*;

public class MergeExample {
  public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    List<Map<String, Object>> data =
      mapper.readValue(new java.io.File("records.json"),
        new com.fasterxml.jackson.core.type.TypeReference<>() {});

    try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:test")) {
      Statement stmt = conn.createStatement();
      stmt.execute("CREATE TABLE info (id INT, category VARCHAR)");
      stmt.execute("INSERT INTO info VALUES (1, 'A'), (2, 'B')");

      ResultSet rs = stmt.executeQuery("SELECT * FROM info");
      Map<Integer, String> categories = new HashMap<>();
      while (rs.next()) categories.put(rs.getInt("id"), rs.getString("category"));

      for (Map<String, Object> record : data) {
        Integer id = (Integer) record.get("id");
        record.put("category", categories.getOrDefault(id, "Unknown"));
      }

      mapper.writerWithDefaultPrettyPrinter().writeValue(
        new java.io.File("merged.json"), data
      );
      System.out.println("Merged output written to merged.json");
    }
  }
}

This workflow shows how JSON and relational data can coexist cleanly within Java applications, enabling unified reporting, synchronization, and data exchange between heterogeneous systems.

Chapter 19: Next Steps and Resources

By now you have seen how Java brings together clarity, structure, and power to build reliable applications across platforms. You have explored the syntax and semantics of the language, worked with classes, data, and exceptions, and developed an understanding of how Java programs are organized, compiled, and executed. This chapter offers guidance on where to go next in your Java journey, focusing on tools, practices, and resources that will help you advance your skills and create production-quality software.

We begin by introducing the fundamentals of testing with JUnit, which is an essential part of modern software development. From there, we look at how build tools such as Maven and Gradle can automate compiling, testing, and packaging your code. You will also learn about distributing Java applications, including creating JAR files and understanding deployment basics.

Finally, we outline a roadmap to advanced Java topics. These include deeper aspects of the Java Virtual Machine (JVM), reflection and dynamic features, and popular frameworks used in enterprise and web development. Together these elements form the bridge between core Java knowledge and professional-level development.

Testing and JUnit introduction

Testing is a vital part of the software development process. It ensures that your code behaves as expected, reduces the chance of regressions, and increases confidence when making changes. In Java, the most widely used testing framework is JUnit, which provides a structured and repeatable way to write and run automated tests.

JUnit supports unit testing, where individual methods or classes are verified in isolation. This helps detect issues early in the development cycle and promotes cleaner, more maintainable code. JUnit integrates easily with IDEs such as IntelliJ IDEA, Eclipse, and VS Code, as well as build tools like Maven and Gradle.

// Example JUnit 5 test
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {

  @Test
  void testAddition() {
    int result = 2 + 3;
    assertEquals(5, result, "Addition should work correctly");
  }
}

Each test method is annotated with @Test, and assertions such as assertEquals() verify that actual results match expectations. When a test fails, JUnit reports the discrepancy, allowing developers to identify and correct problems quickly.

Build tools (Maven and Gradle)

As Java projects grow, manual compilation and dependency management quickly become impractical. Build automation tools such as Maven and Gradle streamline these tasks, managing everything from compiling and testing to packaging and deployment.

Maven uses an XML configuration file called pom.xml (Project Object Model) to describe project dependencies, plugins, and build steps. It follows a convention-over-configuration approach, meaning most projects share a common structure and predictable build lifecycle.

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>myapp</artifactId>
  <version>1.0.0</version>

  <dependencies>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.10.0</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Gradle offers a more flexible approach using a domain-specific language (DSL) based on Groovy or Kotlin. It provides the same core features as Maven but with more control over custom tasks and build logic.

// Example Gradle build script (build.gradle)
plugins {
  id 'java'
}

repositories {
  mavenCentral()
}

dependencies {
  testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
}

test {
  useJUnitPlatform()
}

Both tools can automatically download dependencies from repositories such as Maven Central, generate JAR or WAR files, and integrate seamlessly with IDEs and CI/CD pipelines. Choosing between Maven and Gradle often comes down to personal preference or project requirements.

Packaging and deployment

Once a Java application has been developed and tested, it must be packaged for distribution. Packaging combines compiled classes, resources, and metadata into a single archive that can be executed or included as a dependency in other projects. The most common package format is the JAR (Java ARchive) file, which is essentially a ZIP archive containing compiled bytecode and a manifest file.

A simple JAR can be created using the Java command-line tools:

javac Main.java
jar cfe MyApp.jar Main Main.class

Here, cfe specifies that a new archive should be created (c), that the first class is the entry point (e), and that the output file should be named MyApp.jar. Once packaged, the program can be run on any compatible Java installation:

java -jar MyApp.jar

Build tools such as Maven and Gradle can automate this process and also generate more complex distributions, including dependency management and metadata. For example, Maven can produce executable JARs, while Gradle can create shaded or fat JARs that include all required libraries.

Beyond JARs, Java applications may be packaged in other formats such as WAR files for web deployment or modular JMOD files introduced in Java 9. For desktop or standalone programs, the jpackage tool can produce platform-specific installers.

jpackage --name MyApp --input out --main-jar MyApp.jar --type exe

Deployment methods vary depending on the target environment. Applications may be distributed directly, deployed to web servers, published to repositories, or integrated into containerized systems using Docker and Kubernetes.

Roadmap to advanced topics

Having completed the core areas of the Java language, you are now well prepared to explore the deeper aspects of the platform and its ecosystem. Beyond writing syntax-correct and functional programs, mastering Java involves understanding how the Java Virtual Machine (JVM) operates, how dynamic features such as reflection work, and how major frameworks and tools build upon these foundations.

JVM internals are central to understanding how Java executes code. Topics such as the class loading mechanism, the bytecode instruction set, the Just-In-Time (JIT) compiler, and garbage collection strategies reveal how performance and portability are achieved. A grasp of these concepts helps developers write more efficient and optimized code, particularly for high-performance systems.

Reflection and introspection allow programs to examine and modify their own structure at runtime. Using classes from java.lang.reflect, you can discover class members, invoke methods dynamically, and even create instances on the fly. Reflection underpins many powerful tools in the Java ecosystem, including dependency injection frameworks, testing libraries, and serialization systems.

// Simple example using reflection
Class<?> cls = Class.forName("java.util.ArrayList");
System.out.println("Class name: " + cls.getName());

Frameworks and libraries form the backbone of modern Java development. Frameworks such as Spring, Jakarta EE, Hibernate, and Micronaut extend Java with features for dependency management, web applications, persistence, and cloud-native design. Each framework builds on the principles you have already learned: encapsulation, modularity, and reusable components.

Other advanced areas to explore include concurrency and parallelism (via the java.util.concurrent package), reactive programming, performance tuning, memory profiling, and even bytecode manipulation. As you grow more comfortable with the language and platform, these topics will help you become not just a Java programmer but a Java expert.

This marks the completion of your journey through This is Java. By combining the principles, syntax, and practices introduced throughout this book, you now have the foundation to build robust, efficient, and modern Java applications. Continue exploring, experimenting, and learning. The Java ecosystem is vast and ever-evolving.