Java and Programming Foundations

Introduction

Java is a general-purpose, class-based, object-oriented programming language designed to support portability, reliability, security, and maintainability. Since its introduction in the 1990s, Java has been used for enterprise systems, Android applications, web services, scientific software, financial platforms, embedded systems, and large-scale data processing.

Learning Java requires more than memorizing keywords. A programmer must understand how problems are represented as algorithms, how source code is translated and executed, how data is stored and manipulated, and how errors are detected and corrected. This chapter establishes those foundations. It introduces programming paradigms, Java syntax, data types, variables, operators, control flow, methods, arrays, the Java Virtual Machine (JVM), bytecode, garbage collection, and the Java Development Kit (JDK).

Java is especially suitable for foundational study because it combines a relatively consistent syntax with a strongly defined execution model. A Java program is compiled into bytecode, which is executed by a JVM. This separation between source code and the underlying operating system is central to Java's portability.

Learning Objectives

By the end of this chapter, you should be able to:

• distinguish major programming paradigms and explain Java's dominant paradigm;
• describe the structure and lexical rules of a Java program;
• declare and use primitive types, reference types, constants, and variables;
• apply arithmetic, relational, logical, assignment, and conditional operators;
• implement selection, iteration, and branching using control-flow statements;
• define and invoke methods, including methods with parameters and return values;
• create, traverse, and reason about one-dimensional and multidimensional arrays;
• explain the relationship among source code, bytecode, the JDK, the JVM, and the JRE runtime environment;
• describe garbage collection and its practical implications; and
• compile, execute, test, and debug basic Java programs.

1. Programming as Problem Solving

A program is a precisely defined set of instructions that transforms input into output. Programming begins with problem analysis rather than typing code. A sound development process commonly includes:

1. Understanding the problem: identify inputs, required outputs, constraints, and exceptional cases.
2. Designing an algorithm: express the solution as ordered, finite, unambiguous steps.
3. Representing the design: use pseudocode, diagrams, or structured descriptions.
4. Implementing the solution: translate the design into Java.
5. Testing and debugging: compare actual behavior with expected behavior and correct defects.
6. Maintaining the program: improve, adapt, document, and secure the software over time.

An algorithm is not necessarily a Java program. An algorithm is language-independent; a program is an implementation in a particular programming language.

Programming Paradigms

A programming paradigm is a style or model for expressing computation.

• Imperative programming describes computation as commands that change program state. Variables are assigned new values, and statements execute in sequence.
• Procedural programming organizes imperative instructions into procedures or functions. It emphasizes decomposition into reusable operations.
• Object-oriented programming (OOP) organizes software around objects that combine state and behavior. Classes define the structure and operations of objects. Encapsulation, abstraction, inheritance, and polymorphism are central concepts.
• Functional programming treats computation primarily as the evaluation of functions and emphasizes immutability, expression-oriented design, and the avoidance of unintended side effects.
• Declarative programming specifies what result is required rather than describing every operational step. SQL is a familiar example.

Java is primarily object-oriented, but it also supports imperative, procedural, generic, concurrent, and functional features. For example, Java permits statements that change variables, methods organized around classes, lambda expressions, and stream operations. A paradigm is therefore a way of thinking about program structure, not merely a list of language features.

2. The Structure and Syntax of Java Programs

Java source files normally use the .java extension. The compiler translates source code into a .class file containing bytecode. A minimal program is:

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

The public class Greeting declaration defines a class named Greeting. When a public class is declared, the source-file name must normally be Greeting.java. The main method is the conventional entry point for a standalone Java application:

• public makes the method accessible to the JVM launcher;
• static allows invocation without first creating a Greeting object;
• void means that the method returns no value;
• main is the method name recognized by the launcher; and
• String[] args is an array of command-line arguments.

System.out.println sends text followed by a line terminator to standard output. A semicolon terminates most Java statements. Braces delimit blocks, and parentheses group expressions or contain method parameters.

Lexical Elements

Java is case-sensitive: total, Total, and TOTAL are different identifiers. Comments are ignored by the compiler but are essential for communicating intent:

// A single-line comment
/* A comment that may span several lines */
/** Documentation comment used by the Javadoc tool */

Identifiers name classes, methods, variables, and other program elements. They may contain letters, digits, underscores, and currency characters, but cannot begin with a digit and cannot be reserved words. By convention, class names use UpperCamelCase, methods and variables use lowerCamelCase, and constants use UPPER_SNAKE_CASE.

Java keywords include class, public, private, static, if, else, for, while, return, new, and int. They have predefined meanings and cannot be used as ordinary identifiers.

Whitespace generally separates tokens and improves readability. Java has no significant indentation, although consistent indentation is a professional necessity.

3. Types, Variables, and Values

A type determines the kind of value an expression can represent, the operations permitted on it, and the memory and execution rules associated with it. Java is statically typed: the compiler checks most type relationships before execution.

Primitive Types

Java has eight primitive types.

The integer types represent whole numbers. The int type is the usual default for integer literals. A long literal commonly requires the suffix L; a float literal requires F because decimal literals default to double.

Floating-point values are approximations for many decimal quantities. Consequently, direct equality comparisons can be unsafe in numerical code. For example, repeated operations involving 0.1 may produce a value very close to, but not exactly, the mathematically expected result. Applications requiring exact decimal arithmetic, such as currency calculations, should consider BigDecimal with an appropriate rounding policy.

A char represents a UTF-16 code unit, not necessarily a complete human-perceived character. Some Unicode characters require a pair of code units. For general text processing, String and Unicode-aware APIs are preferable.

Reference Types

Classes, interfaces, arrays, enumerations, and records are reference types. A variable of reference type holds a reference to an object rather than the object’s complete value directly. The special value null means that a reference does not currently refer to an object.

String name = "Amina";
int[] scores = {82, 91, 76};

Primitive variables contain primitive values. Reference variables may refer to objects, and several variables may refer to the same object. This distinction is important when modifying mutable objects.

Declaration, Initialization, and Assignment

A declaration introduces a variable and its type. Initialization gives it its first value. Assignment replaces its current value.

int attempts;        // declaration
attempts = 1;        // assignment
int limit = 3;       // declaration and initialization
final double TAX = 0.15; // named constant

Local variables must be definitely assigned before use. Instance fields and class fields receive default values, but relying on defaults can obscure intent. The final modifier prevents reassignment after initialization; for a reference, it prevents changing the reference, not necessarily changing the referenced object.

Java performs some implicit widening conversions, such as converting an int to a long. Narrowing conversions require an explicit cast and may lose information:

int whole = 7;
double precise = whole;       // widening conversion
int truncated = (int) 4.9;    // result is 4

A cast does not round 4.9; it discards the fractional part. Numeric overflow is also possible for fixed-width integer types. Programs that process values near type limits must choose types and validation rules deliberately.

4. Operators and Expressions

An expression produces a value. Operators combine or transform values.

Arithmetic Operators

+, -, *, /, and % represent addition, subtraction, multiplication, division, and remainder. If both operands of / are integers, integer division is performed:

int quotient = 7 / 2;   // 3
int remainder = 7 % 2;  // 1
double result = 7 / 2.0; // 3.5

Division by zero is an error for integer arithmetic and produces special IEEE floating-point results in some floating-point cases. Programs should not assume that floating-point behavior matches integer behavior.

The increment and decrement operators, ++ and --, change a numeric variable by one. Their prefix and postfix forms differ in the value of the expression:

int x = 3;
int a = x++; // a is 3, x becomes 4
int b = ++x; // x becomes 5, b is 5

Relational and Logical Operators

Relational operators include ==, !=, <, >, <=, and >=. They produce Boolean values. For primitive values, == compares values. For references, == tests whether two references identify the same object; it does not generally compare object content. Use an appropriate method such as String.equals for content comparison:

String first = new String("Java");
String second = new String("Java");
boolean sameObject = first == second;       // usually false
boolean sameText = first.equals(second);    // true

The logical operators are && (AND), || (OR), and ! (NOT). The && and || operators short-circuit: the right operand is evaluated only when necessary. This permits safe guarded expressions such as:

if (value != null && value.length() > 0) {
    System.out.println(value);
}

Assignment and Conditional Operators

Assignment operators include =, +=, -=, *=, and /=. The conditional operator has the form condition ? expression1 : expression2 and selects one of two expressions:

String result = score >= 50 ? "Pass" : "Fail";

Parentheses should be used when they improve clarity. Although Java has defined operator precedence, relying on a complicated precedence chain makes code harder to review and maintain.

5. Control Flow

Control flow determines the order in which statements execute.

Selection

An if statement chooses between alternatives:

if (temperature > 30) {
    System.out.println("Hot");
} else if (temperature >= 20) {
    System.out.println("Moderate");
} else {
    System.out.println("Cool");
}

A switch is useful when one expression is compared with several discrete alternatives:

switch (day) {
    case 1:
        name = "Monday";
        break;
    case 2:
        name = "Tuesday";
        break;
    default:
        name = "Unknown";
}

Without an appropriate break, traditional switch cases may fall through. Modern Java also supports switch expressions, which can return a value and use arrow labels. The chosen form should be compatible with the project’s Java version and coding standards.

Iteration

A while loop is appropriate when repetition continues while a condition remains true:

int n = 1;
while (n <= 5) {
    System.out.println(n);
    n++;
}

A do-while loop executes its body at least once. A for loop groups initialization, continuation testing, and update in one header:

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

The enhanced for loop traverses arrays and other iterable structures:

int total = 0;
for (int score : scores) {
    total += score;
}

break exits a loop or switch, while continue skips to the next iteration. Excessive use of both can obscure logic. A loop should have a clearly understood initialization, termination condition, and progress step. Failure to make progress can cause an infinite loop.

6. Methods and Decomposition

A method is a named, reusable unit of behavior. Methods reduce duplication, isolate responsibilities, and make programs easier to test.

public static double average(int[] values) {
    if (values == null || values.length == 0) {
        throw new IllegalArgumentException("At least one value is required");
    }

    int total = 0;
    for (int value : values) {
        total += value;
    }
    return (double) total / values.length;
}

The method signature includes its name, parameter types, and other declaration information. The return type is double in this example. return supplies the result and ends method execution. A void method returns no value.

Java uses pass-by-value. For a primitive argument, the method receives a copy of the primitive value. For a reference argument, the method receives a copy of the reference; it can use that copied reference to modify the referenced mutable object, but assigning a new object to the parameter does not change the caller’s variable.

static void change(int number) {
    number = 99;
}

static void modify(int[] data) {
    data[0] = 99;
}

Calling change(x) does not change x, while calling modify(values) can change the first array element. This behavior is frequently misunderstood and should be documented when it matters.

Java supports method overloading: multiple methods may share a name if their parameter lists differ. A method should have a clear responsibility, meaningful names, controlled visibility, and documented assumptions. Validation at method boundaries prevents invalid data from spreading through a system.

7. Arrays

An array is a fixed-length, indexed collection whose elements have one declared type. Indexing begins at zero. The last valid index is length - 1.

int[] marks = new int[3];
marks[0] = 70;
marks[1] = 85;
marks[2] = 91;

The expression marks.length gives the number of elements. Accessing an invalid index causes ArrayIndexOutOfBoundsException.

Arrays can be initialized directly:

int[] values = {4, 8, 15, 16, 23, 42};

A two-dimensional array is technically an array of arrays:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

Rows can have different lengths, so Java arrays are not required to be rectangular. Code should not assume equal row lengths unless that is an explicit invariant.

Arrays are appropriate when length is fixed and indexed access is useful. When a collection must grow or shrink, classes such as ArrayList are generally more suitable. Arrays store values of a common declared type, although an array of references may contain objects belonging to subclasses of that type.

8. JVM, Bytecode, and the JDK Toolchain

Java’s execution model separates compilation from machine execution. The principal components are:

• JDK (Java Development Kit): tools and libraries used to develop Java software. It includes the compiler, launcher, documentation tools, debugger, packaging utilities, and a runtime implementation.
• JVM (Java Virtual Machine): an abstract machine that loads, verifies, and executes Java bytecode. Different operating systems have different JVM implementations.
• Runtime class libraries: standard APIs such as java.lang, java.util, and java.io.
• Bytecode: platform-independent instructions stored in class files.

The traditional term JRE refers to the runtime components needed to run Java programs. Modern JDK distributions provide the runtime, and separate JRE downloads are no longer the main distribution model. The practical distinction remains useful: development requires a JDK, whereas execution requires a compatible runtime.

A typical command-line workflow is:

javac Greeting.java
java Greeting

javac compiles source code into bytecode. java starts the JVM, loads the requested class, invokes its main method, and supplies command-line arguments. The compiler reports syntax and many type errors before execution.

At a high level, the JVM performs the following steps:

1. The class loader locates and loads class definitions.
2. The bytecode verifier checks structural and safety properties.
3. The runtime links classes, resolving symbolic references as required.
4. The execution engine interprets bytecode and may use just-in-time (JIT) compilation to translate frequently executed code into native machine instructions.
5. Runtime services manage threads, exceptions, memory, and interaction with the operating system.

The JVM specification defines behavior, while a particular JVM implementation determines many performance details. Therefore, programmers should rely on language and API specifications rather than undocumented implementation assumptions.

Memory and Garbage Collection

A JVM manages memory for objects and other runtime structures. Objects created with new become eligible for garbage collection when they are no longer reachable through active references. Garbage collection automatically reclaims storage; it does not guarantee immediate reclamation, and programmers should not use it as a substitute for closing files, sockets, database connections, or other external resources.

The try-with-resources statement is the appropriate mechanism for many closeable resources:

try (java.io.BufferedReader reader =
         new java.io.BufferedReader(new java.io.FileReader("data.txt"))) {
    System.out.println(reader.readLine());
}

The resource is closed automatically when the block ends, including when an exception occurs. Memory leaks can still occur in a garbage-collected language when a program unintentionally retains references, for example by placing obsolete objects in a long-lived collection.

Garbage collection involves trade-offs. Collection work consumes processing time and may affect pauses or throughput. Application developers should write code with clear object lifetimes, avoid unnecessary retention, and measure performance rather than assuming that manual memory management would automatically be better.

9. Testing and Debugging Basic Programs

A defect is a flaw in a program. Common categories include:

• Syntax or compilation errors: violations detected by the compiler, such as a missing semicolon or incompatible type.
• Runtime errors: failures during execution, such as division by zero, invalid indexing, or a missing file.
• Logic errors: the program runs but produces an incorrect result.

Consider:

public class AverageDemo {
    public static void main(String[] args) {
        int[] scores = {60, 70, 80};
        int total = 0;

        for (int score : scores) {
            total += score;
        }

        double average = (double) total / scores.length;
        System.out.println(average);
    }
}

The total is 210 and the array length is 3, so the average is 70.0. The cast to double makes the intended division explicit. Without a floating-point operand, integer division could discard a fractional part.

Effective debugging is systematic:

1. reproduce the defect with a small, reliable input;
2. state the expected and actual results;
3. identify the smallest location where they diverge;
4. inspect variables and control flow using print statements or a debugger;
5. form one hypothesis at a time;
6. change the code minimally and retest; and
7. add a regression test so the defect does not return.

An IDE debugger can set breakpoints, execute one statement at a time, inspect the call stack, and examine variable values. A debugger is not a replacement for understanding the algorithm; it is an instrument for testing hypotheses about execution.

10. Applied Case: A Small Student Assessment Program

Background

A university department needs a command-line program that receives assessment marks, calculates an average, and reports whether a student passes. This is an illustrative case, not a production assessment system.

Problem Analysis

The program must accept a fixed set of marks, calculate their arithmetic mean, and apply a passing rule. Assume marks are integers from 0 through 100, at least one mark is required, and a mean of 50 or more indicates a pass. These assumptions must be validated rather than silently presumed.

Approach and Solution

public class Assessment {
    public static double average(int[] marks) {
        if (marks == null || marks.length == 0) {
            throw new IllegalArgumentException("Marks are required");
        }

        int total = 0;
        for (int mark : marks) {
            if (mark < 0 || mark > 100) {
                throw new IllegalArgumentException("Mark outside 0..100");
            }
            total += mark;
        }
        return (double) total / marks.length;
    }

    public static boolean passed(double average) {
        return average >= 50.0;
    }

    public static void main(String[] args) {
        int[] marks = {48, 57, 66};
        double result = average(marks);
        System.out.println("Average: " + result);
        System.out.println("Passed: " + passed(result));
    }
}

The total is 171 and the number of marks is 3, giving an average of 57.0. The student therefore passes under the stated rule. The program demonstrates arrays, enhanced for loops, validation, methods, return values, Boolean expressions, and explicit numeric conversion.

Outcome and Learning Points

Separating average from passed gives each method a focused responsibility. Validation makes assumptions visible and prevents invalid marks from contaminating the result. A professional version would obtain input through a well-defined interface, use tests for boundary values such as 49.999 and 50, handle input errors, protect student data, and obtain grading rules from authorized policy rather than hard-coding them.

Professional, Ethical, and Contemporary Considerations

Basic programming decisions can have significant consequences. Assessment software, financial systems, health applications, and employment platforms may affect people’s opportunities. Developers should validate requirements, protect personal data, avoid exposing sensitive information in logs, and test boundary and exceptional cases.

Java remains relevant because its ecosystem supports long-lived enterprise applications, cloud services, secure APIs, concurrent systems, and large development teams. Modern Java includes features such as records, enhanced switch expressions, pattern matching developments, modules, and improved garbage collectors. These features do not remove the need for fundamental knowledge. Readable design, testing, dependency management, secure configuration, version control, and observability remain essential.

AI-assisted programming tools can generate code, explain errors, and suggest tests, but generated code must be reviewed. It may contain security vulnerabilities, licensing concerns, incorrect assumptions, or subtle logic errors. Professional responsibility remains with the developer and organization that deploys the software.

Chapter Summary

Java programming begins with problem analysis, algorithm design, implementation, testing, and maintenance. Programming paradigms provide different ways to organize computation; Java is primarily object-oriented while also supporting imperative, generic, concurrent, and functional styles.

Java source code is organized into classes, methods, statements, expressions, and blocks. The language is case-sensitive and statically typed. Primitive types store values directly, while reference variables refer to objects. Operators perform arithmetic, comparisons, logical operations, assignments, and conditional selection. Control-flow statements implement decisions and repetition.

Methods support decomposition and reuse. Java passes arguments by value, including copies of object references. Arrays provide fixed-length, indexed storage, and their indexes begin at zero. The JDK supplies development tools such as javac and java; the compiler produces bytecode, and a JVM loads, verifies, interprets, or JIT-compiles that bytecode. Garbage collection manages unreachable object memory, but external resources require explicit or structured closing.

Finally, effective programmers distinguish compilation, runtime, and logic errors; use systematic debugging; validate assumptions; and consider security, privacy, maintainability, and social consequences in software design.

Key Terms

Algorithm: A finite, precise sequence of steps for solving a problem.

Array: A fixed-length, indexed collection of elements of one declared type.

Bytecode: Platform-independent instructions stored in Java class files.

Class: A declaration that defines the structure and behavior of objects.

Compiler: A program that translates source code into another representation, such as bytecode.

Control flow: The order in which program statements execute.

Garbage collection: Automatic reclamation of memory occupied by unreachable objects.

Identifier: A programmer-defined name for a program element.

JDK: Java Development Kit; tools, libraries, and runtime components for Java development.

JIT compilation: Runtime translation of frequently executed bytecode into native machine instructions.

JVM: Java Virtual Machine; the runtime system that executes Java bytecode.

Method: A named, reusable unit of behavior defined within a class.

Object: A runtime entity containing state and behavior as defined by a class.

Operator: A symbol or construct that performs an operation on one or more operands.

Paradigm: A general model or style of programming.

Primitive type: One of Java’s built-in value types, such as int or boolean.

Reference type: A type whose variables refer to objects, arrays, or other reference values.

Scope: The region of source code in which a declared name can be accessed.

Static typing: A type system in which many type relationships are checked before execution.

Variable: A named storage location associated with a type and value.

Review Questions

Short Answer Questions

1. What is the difference between an algorithm and a Java program?
2. Why does Java compile source code into bytecode?
3. Distinguish a primitive variable from a reference variable.
4. What is the difference between == and .equals() when comparing objects?
5. Why is a cast to double sometimes required when calculating an average?

Long Answer Questions

1. Explain the major programming paradigms and evaluate Java’s relationship to them.
2. Describe the roles of the JDK, compiler, bytecode, JVM, class loader, and JIT compiler.
3. Explain Java’s control-flow statements and give appropriate use cases for selection and iteration.
4. Discuss Java’s pass-by-value rule, including the behavior of primitive and reference arguments.
5. Explain garbage collection, object reachability, resource management, and possible causes of memory retention.

Analytical / Application Questions

1. Design an algorithm and Java method that receives an integer array and returns the largest value. Specify how the method should behave for a null or empty array.
2. A program calculates 5 / 2 and displays 2. Explain why this occurs and propose two correct ways to obtain a result of 2.5.
3. A student assessment program sometimes reports incorrect averages and occasionally crashes on invalid input. Identify likely compilation, runtime, and logic defects, and propose a testing and debugging strategy.

Multiple Choice Questions with Answers

Question 1

Which component compiles Java source code into bytecode?

A. The JVM

B. The javac compiler

C. The garbage collector

D. The class loader

Correct Answer: B. The javac compiler

Question 2

What is the result of the expression 7 / 2 when both operands are of type int?

A. 2

B. 2.5

C. 3

D. A compilation error

Correct Answer: A. 2

Question 3

Which statement correctly compares the textual contents of two String objects?

A. first == second

B. first.equals(second)

C. first != second

D. first.compareReference(second)

Correct Answer: B. first.equals(second)

Question 4

What is the first valid index of a Java array?

A. -1

B. 0

C. 1

D. The array length

Correct Answer: B. 0

Question 5

Which loop is guaranteed to execute its body at least once?

A. for

B. while

C. do-while

D. Enhanced for

Correct Answer: C. do-while

Question 6

What does the final modifier generally prevent for a variable?

A. Reading the variable

B. Using the variable in a method

C. Reassigning the variable after initialization

D. Assigning the variable a value initially

Correct Answer: C. Reassigning the variable after initialization

Question 7

What does garbage collection reclaim?

A. All files opened by a program

B. Unreachable objects’ memory

C. Every local variable immediately after use

D. Source-code comments

Correct Answer: B. Unreachable objects’ memory

Question 8

What does Java pass to a method when an object reference is used as an argument?

A. The object is always copied completely

B. A copy of the reference

C. A reference that cannot modify the object

D. The object’s class definition only

Correct Answer: B. A copy of the reference

Question 9

Which error occurs when a program runs but produces an incorrect result?

A. A syntax error

B. A logic error

C. A linker keyword error

D. A naming convention error

Correct Answer: B. A logic error

Question 10

If int[] values = {4, 8, 15};, what is the value of values.length?

A. 2

B. 3

C. 4

D. 15

Correct Answer: B. 3