## Learn Java with a Strong Engineering Foundation

Learning Java is not just about memorizing syntax or getting code to run.

Strong software engineers know how to break problems into smaller parts, model responsibilities clearly, reason about trade-offs, and write code that remains understandable and maintainable as a system grows.

**Java & Object-Oriented Programming Foundation** is designed to build that foundation.

You will start with Java from the beginning and progressively learn how to use object-oriented programming to model and solve real software problems.

The goal is not simply to teach you **what code to write**, but to help you understand **why the code should be designed that way**.

## Who Is This Course For?

This course is suitable for:

* Beginners starting their programming journey
* Developers moving to Java from another programming language
* Learners who want to strengthen their Java and OOP fundamentals
* Anyone planning to move into Java backend development and Spring Boot

No previous experience with Java or object-oriented programming is required.

The course starts from the fundamentals and builds progressively toward stronger software design concepts.

## More Than Java Syntax

Many programming courses focus heavily on syntax.

This course goes further.

Alongside Java fundamentals, you will learn how to **reason about software**.

You will explore questions such as:

* How should a larger problem be broken into smaller responsibilities?
* Which object should own a particular piece of state or behavior?
* When does an abstraction improve a design?
* When is a simpler solution better?
* How can code remain readable as the application grows?
* How do you recognize unnecessary complexity?

These questions are introduced gradually as your programming knowledge develops.

Object-oriented programming is also taught beyond definitions.

You will not simply memorize concepts such as `encapsulation`, `inheritance`, `polymorphism`, and `abstraction`.

You will learn **why they exist, what problems they solve, where they are useful, and when they should not be used**.

## Practical and Progressive Learning

The course is structured so that each topic naturally builds on what you learned before.

You will begin with small programming problems and gradually progress toward applications involving multiple classes, objects, relationships, abstractions, and collaborating components.

Throughout the course, you will work with:

* Practical coding exercises
* Predict-the-result challenges
* Knowledge checks
* Design questions
* Refactoring exercises
* Hands-on projects

You will learn to evaluate more than whether your code works.

You will also learn to ask:

> Is this code clear?

> Are responsibilities in the right place?

> Is the design easy to change?

> Am I introducing complexity that I do not actually need?

This is where programming begins to develop into software engineering.

## Learn in English — Translate with AI When You Need It

The course is written in **English**, using the same terminology you will encounter in professional Java documentation, technical articles, APIs, codebases, and engineering teams.

Java keywords, APIs, class names, method names, and technical terminology remain consistent with industry usage.

If English is not your preferred learning language, Tarkev's **AI translation** option allows you to translate lesson content into a supported language while you learn.

This gives you the flexibility to understand difficult concepts in a language that is more comfortable for you without maintaining a separate version of the course or losing connection with the original technical terminology.

You can learn from the same course while using AI-assisted translation whenever it helps your understanding.

## Build the Foundation for Java Backend Development

The course is intentionally focused on fundamentals.

Before working with frameworks such as Spring Boot, it is important to understand the Java and software-design concepts those frameworks build upon.

You will develop a foundation in areas such as:

* Programming logic
* Variables, types, expressions, and control flow
* Methods and program structure
* Arrays and data processing
* Classes and objects
* Constructors and object state
* Encapsulation and invariants
* Object relationships and composition
* Immutability
* Packages and project organization
* Inheritance
* Method overriding
* Runtime polymorphism
* Abstract classes
* Interfaces
* Dependency design
* Constructor injection
* Composition and delegation

The emphasis throughout is on understanding the concepts rather than simply copying patterns.

## By the End of the Course

After completing the course, you should have a strong foundation in Java programming and object-oriented design.

You will be able to:

* Build Java programs independently
* Read and understand existing Java code
* Break larger problems into smaller responsibilities
* Model problems using classes and objects
* Use encapsulation, inheritance, interfaces, and composition intentionally
* Reason about code quality and maintainability
* Recognize unnecessarily complicated designs
* Make better software-design decisions as your applications grow

Most importantly, you will be ready to move forward into **Java backend development and Spring Boot** with a much stronger understanding of the language and the engineering principles underneath the framework.

**Learn Java. Understand programming. Start building software like an engineer.**

# Lesson Overview

Programming is the process of giving a computer clear and specific instructions to perform a task or solve a problem.

A computer can process data very quickly, but the programmer must define what it should do. Those instructions are written using a programming language.

In this lesson, we will learn:

* What programming and source code are
* How a programming language expresses instructions
* How programs solve problems
* Algorithms and the Input–Processing–Output model
* The difference between a program and an application
* A common programming workflow
* Syntax, runtime, and logical errors

## Learning Objectives

After completing this lesson, you will be able to:

* Explain programming and source code
* Understand what an algorithm is
* Think about a problem in terms of Input, Processing, and Output
* Understand the difference between a program and an application
* Explain a common programming workflow
* Distinguish between syntax, runtime, and logical errors

## What Is Programming?

Programming is the process of designing and writing instructions for a computer.

Programming can be used to make a computer perform many different types of tasks, such as:

* Performing calculations
* Saving or searching data
* Processing user input
* Processing payments
* Sending emails or notifications
* Communicating with other systems

The human-readable instructions written by a programmer using a programming language are called **source code**.

Example:

```java
System.out.println("Welcome to Java");
```

Output:

```text
Welcome to Java
```

This is Java source code.

A developer can read this code, but the processor does not directly execute Java source code. We will discuss how Java source code is transformed into executable instructions in the next lesson.

## What Is a Programming Language?

A programming language is a structured language used to write instructions for a computer.

Some well-known programming languages include:

* Java
* Python
* JavaScript
* Go
* C
* C++
* C#
* Rust
* Kotlin

Each language has its own syntax, keywords, data types, and code structure.

Java:

```java
System.out.println("Hello");
```

Python:

```python
print("Hello")
```

Both instructions perform a similar task, but their syntax is different.

## Programming and Problem Solving

Programming is not just about writing syntax. First, you need to understand the problem. Then, you need to break it into smaller steps that a computer can follow.

Suppose we need to calculate a student's average mark.

One possible solution is:

1. Receive the student's marks
2. Add the marks together
3. Determine the number of subjects
4. Divide the total by the number of subjects
5. Display the average

This ordered sequence of steps is called an **algorithm**.

## What Is an Algorithm?

An algorithm is a clear, specific, and correctly ordered sequence of steps used to solve a problem or complete a task.

An algorithm does not depend on a programming language. The same algorithm can be implemented in Java, Python, or another language.

The steps of a good algorithm should be:

* Clear
* Complete
* Arranged in the correct order
* Possible to perform in practice

## Input, Processing, and Output

Many programming problems can be thought of in three parts:

1. **Input**
2. **Processing**
3. **Output**

### Input

Information received by a program.

Examples:

* Student marks
* Product price
* User email
* Account balance
* Data received from another system

### Processing

Operations that a program performs on the input.

Examples:

* Adding two values
* Calculating an average
* Comparing a password
* Searching for a product
* Checking a condition

### Output

The result produced by a program after processing.

Examples:

* Calculated total
* Search result
* Error message
* Confirmation
* Generated report

## Example: Area of a Rectangle

Suppose we need to calculate the area of a rectangle.

Formula:

```text
area = length × width
```

### Input

* `length`
* `width`

### Processing

Multiply `length` and `width`.

### Output

The calculated `area`.

Algorithm:

1. Receive the length
2. Receive the width
3. Multiply the length and width
4. Display the result

Java implementation:

```java
int length = 10;
int width = 5;

int area = length * width;

System.out.println(area);
```

Output:

```text
50
```

At this point, understanding the problem's input, calculation, and expected output clearly is more important than understanding the Java syntax.

## Program and Application

**Program** and **application** are related concepts, but they are not exactly the same.

### Program

A program is a collection of instructions that performs a specific task.

For example:

* Grade calculator
* Temperature converter
* File rename tool

A program can be very small.

### Application

An application is usually larger software in which multiple features and components work together.

For example:

* Banking application
* Web browser
* Learning platform
* Food delivery application
* E-commerce application

An application may contain:

* User interface
* Backend service
* Database
* Authentication
* External integration
* Payment or notification system

A small program may perform one specific task. An application generally solves multiple related tasks together.

## Source Code

Source code is human-readable instructions written using a programming language.

Java source code is generally stored in files with the `.java` extension.

Examples:

```text
Main.java
GradeCalculator.java
BankAccount.java
Student.java
```

A Java source file may contain classes, methods, variables, conditions, loops, and object-related code.

Example:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("My first Java program");
    }
}
```

You do not need to understand every part of this code yet. We will learn these concepts step by step in the following lessons.

## A Common Programming Workflow

Programming is an iterative process in practice. However, as a beginner, it can be understood as a series of steps.

### 1. Understand the Problem

Before writing code, you need to clarify:

* What should the program do?
* What input is required?
* What output is expected?
* What rules must be followed?
* Which situations may be invalid?

If you misunderstand the problem, technically correct code can still produce the wrong solution.

### 2. Determine the Input, Output, and Rules

You need to determine what data the program will receive and what result it should produce.

For example, the input for a grade calculator could be:

* Mathematics mark
* English mark
* Science mark

The output could be:

* Total
* Average
* Grade

### 3. Create an Algorithm

Determine the steps required to produce the expected output from the input.

For example:

1. Receive the marks
2. Validate the marks
3. Calculate the total
4. Calculate the average
5. Display the result

### 4. Write the Code

The algorithm is implemented using a programming language.

Example:

```java
int mathematics = 80;
int english = 90;
int science = 85;

int total = mathematics + english + science;

System.out.println(total);
```

### 5. Run, Test, and Debug

After writing the code, execute the program and check:

* Whether the code compiles
* Whether the program behaves as expected
* Whether the correct result is produced
* Whether unexpected input can be handled

When testing a grade calculator, you may consider not only ordinary values but also boundary and invalid values:

* `0`
* Maximum allowed mark
* Negative mark
* A mark greater than the maximum

A program working for one input does not mean that it is correct in every situation.

### 6. Improve the Solution

After the program works, the code can be improved further.

For example:

* Use better variable names
* Reduce duplicate code
* Improve validation
* Make the code more readable
* Break large logic into smaller parts

## Debugging

The process of finding an error in a program, understanding its cause, and fixing it is called **debugging**.

During debugging, a developer generally:

1. Observes the error or unexpected behavior
2. Identifies the relevant code
3. Finds possible causes
4. Tests a hypothesis
5. Applies a fix
6. Runs and tests the program again

Errors are a normal part of programming. An important skill is being able to systematically identify the cause of an error.

## Common Types of Programming Errors

Three important categories are:

1. Syntax error
2. Runtime error
3. Logical error

## Syntax Error

A syntax error occurs when code does not follow the rules of the programming language.

Example:

```java
System.out.println("Hello")
```

The semicolon at the end of the statement is missing.

Correct:

```java
System.out.println("Hello");
```

Another example:

```java
int age = ;
```

There is no valid value here.

Syntax errors can generally be detected by the compiler before the program runs.

## Runtime Error

A runtime error occurs while a program is executing.

Example:

```java
int result = 10 / 0;
```

Dividing an integer value by zero will cause the program to fail at runtime.

Runtime failures may also occur because of:

* Missing file
* Invalid input
* Missing data
* Network failure
* Unexpected system state

We will learn about Java exceptions and error handling in detail in a later lesson.

## Logical Error

With a logical error, the program runs, but the result is incorrect.

Example:

```java
int mathematics = 80;
int english = 90;

int total = mathematics + english;
int average = total / 3;

System.out.println(average);
```

There are two subjects, but the total is divided by `3`.

Correct calculation:

```java
int average = total / 2;
```

Logical errors can be comparatively difficult to identify because:

* The program may not crash
* There may be no error message
* The result may appear reasonable

This is why testing is important.

## Programming Means Precise Problem Solving

A programming language is a tool.

Good programming requires:

* Understanding the problem clearly
* Breaking the problem into smaller parts
* Determining the input and expected output
* Creating a logical solution
* Implementing the solution in code
* Testing the result
* Fixing errors

Memorizing syntax may allow you to write familiar examples. But to solve new problems, you need to understand the underlying logic.

## Important Terms

### Programming

The process of designing and writing instructions for a computer.

### Programming Language

A structured language used to write instructions for a computer.

### Source Code

Human-readable code written by a programmer using a programming language.

### Program

A collection of instructions used to perform a specific task.

### Application

Software made up of multiple related features and components.

### Algorithm

An ordered sequence of steps used to solve a problem.

### Input

Information received by a program.

### Processing

Operations performed by a program on input.

### Output

The result produced by a program.

### Debugging

The process of finding the cause of an error in a program and fixing it.

### Syntax Error

An error caused by breaking the syntax rules of a programming language.

### Runtime Error

An error that occurs while a program is executing.

### Logical Error

An error in which the program runs but produces an incorrect result.

## Practice Exercise 1: Algorithm and Input–Processing–Output

Write a solution for calculating the area of a rectangle.

Formula:

```text
area = length × width
```

Write the following separately:

* Input
* Processing
* Output
* Algorithm

You do not need to write Java code.

## Practice Exercise 2: Identify the Error Type

Determine whether each example contains a **syntax error**, **runtime error**, or **logical error**.

### Example 1

```java
System.out.println("Java")
```

### Example 2

```java
int result = 100 / 0;
```

### Example 3

```java
int price = 500;
int quantity = 2;

int total = price + quantity;
```

### Example 4

```java
int age = ;
```

## Practice Exercise 3: Break Down a Problem

Choose any one of the following systems:

* Library management system
* Food delivery application
* Student management system
* Online shopping application
* Learning platform

Write:

1. What problem the system solves
2. Three possible inputs
3. Three processing operations
4. Three possible outputs

You do not need to write Java code.

## Knowledge Check

### Question 1

What is programming?

### Question 2

What is source code?

### Question 3

What is an algorithm?

### Question 4

What do Input, Processing, and Output mean?

### Question 5

What is the difference between a program and an application?

### Question 6

What is the difference between a syntax error, runtime error, and logical error?

### Question 7

What is debugging?

## Knowledge Check Answers

### Answer 1

Programming is the process of designing and writing instructions for a computer.

### Answer 2

Source code is human-readable code written by a programmer using a programming language.

### Answer 3

An algorithm is an ordered sequence of steps used to solve a problem or complete a task.

### Answer 4

Input is the information received by a program, Processing is the operation performed on that information, and Output is the result produced by the program.

### Answer 5

A program generally performs a specific task. An application is generally larger software made up of multiple related features and components.

### Answer 6

A syntax error breaks the syntax rules of the language. A runtime error occurs while the program is executing. With a logical error, the program runs but produces an incorrect result.

### Answer 7

Debugging is the process of finding the cause of an error in a program and fixing it.

## Lesson Summary

In this lesson, we learned:

* Programming is the process of designing and writing instructions for a computer
* Source code is written using a programming language
* Programming is primarily a problem-solving process
* An algorithm describes the steps used to solve a problem
* Many problems can be thought of in terms of Input, Processing, and Output
* Programs and applications can have different scopes
* Programming involves problem analysis, implementation, testing, and improvement
* Debugging is the process of finding and fixing errors
* Syntax, runtime, and logical errors are different from one another

Introduction to Programming

## Lesson Overview

The source code we write in Java cannot be executed directly by the computer's processor.

Java source code is first compiled into **bytecode**. Then the **Java Virtual Machine (JVM)** executes that bytecode and works with the underlying operating system and hardware.

In this lesson, we will learn:

* The basic roles of CPU, memory, and storage
* Machine language and high-level programming languages
* Compiler and runtime execution
* How Java source code is executed
* The roles of bytecode, JVM, and JIT
* How Java can run on different platforms

## Learning Objectives

After completing this lesson, you will be able to:

* Explain the roles of CPU, memory, and storage
* Understand the difference between machine language and high-level languages
* Explain what a compiler does
* Explain the flow from Java source code to a running program
* Understand the difference between `.java` and `.class` files
* Explain why bytecode and the JVM are needed

## What Happens in a Computer When a Program Runs?

When a program runs, several parts of hardware and software work together.

The most important ones for us are:

* **CPU**
* **Memory**
* **Storage**
* **Operating System**

A simplified view of program execution:

```text
Program is stored in storage
        ↓
Program is loaded into memory
        ↓
CPU executes instructions
        ↓
Program produces a result
```

## CPU

The **CPU — Central Processing Unit** executes computer instructions.

A CPU can perform different types of operations:

* Calculations
* Comparisons
* Data movement
* Reading data from memory
* Writing data to memory
* Selecting instructions based on conditions

Suppose we have:

```java
int firstNumber = 10;
int secondNumber = 20;
int total = firstNumber + secondNumber;
```

The programmer only wrote:

```java
firstNumber + secondNumber
```

But at a lower level, the computer may need to perform multiple operations such as loading values, adding them, and storing the result.

One major advantage of using a high-level programming language is that the programmer does not need to write these low-level instructions directly.

## Memory and Storage

While a program is running, **RAM** is generally used to store temporary data.

Example:

```java
int age = 30;
String name = "Sakib";
```

While the program is running, the data required for these values is stored in memory.

RAM is **volatile**. Its data does not remain when the computer is powered off.

In contrast, **storage** keeps long-term data.

Examples:

* SSD
* HDD
* External drive

Storage may contain:

* Operating system
* Application
* Java source file
* Compiled file
* Database
* Image
* Document

### Difference Between Memory and Storage

| Topic             | Memory                              | Storage              |
| ----------------- | ----------------------------------- | -------------------- |
| Common example    | RAM                                 | SSD / HDD            |
| Purpose           | Temporary data for running programs | Long-term data       |
| Speed             | Generally faster                    | Comparatively slower |
| When power is off | Data is lost                        | Data remains         |
| Example           | Variable, object                    | File, application    |

Simply put:

> Programs are stored in storage and run in memory.

## Operating System

The operating system manages the computer's hardware resources and running programs.

Examples:

* Windows
* macOS
* Linux

Responsibilities of an operating system include:

* Managing CPU usage
* Allocating memory
* Managing the file system
* Managing running processes
* Managing network and device resources

When a Java application runs, the operating system runs a Java process and provides it with the CPU and memory resources it needs.

## What Kind of Instructions Does a Computer Understand?

At the lowest level, information in a computer is represented in binary form.

The binary system uses:

```text
0
1
```

Low-level instructions that a processor can execute directly are called **machine instructions** or **machine language**.

Machine instructions can depend on the processor architecture.

Examples:

* x86-64
* ARM

Writing large programs directly in machine language is extremely difficult for humans.

This is why we use high-level programming languages.

## High-Level Programming Language

Java is a high-level programming language.

Example:

```java
int total = firstPrice + secondPrice;
```

By reading this code, we can easily understand that two prices are being added and the result is stored in `total`.

High-level languages provide:

* Readable code
* Easier maintenance
* Faster development
* Reusable abstractions
* Separation from low-level hardware details

Java, Python, Go, and JavaScript are examples of high-level programming languages.

## The CPU Does Not Directly Execute Source Code

Java source code is human-readable.

Example:

```java
int total = 10 + 20;
```

But the CPU does not directly understand Java syntax.

Java source code must be translated into an intermediate format that the Java runtime can execute.

The first step in this process is **compilation**.

## Compiler

A compiler is a program that analyzes source code and translates it into another format.

The Java compiler can detect different kinds of problems while checking source code.

Example:

```java
int age = "twenty";
```

Here, a text value is being assigned to an `int` variable.

The Java compiler will not allow this code to compile.

The compiler can detect many syntax and type-related errors before the program runs.

## Compilation

The process of converting source code into a translated format using a compiler is called **compilation**.

General concept:

```text
Source Code
    ↓
Compiler
    ↓
Translated Code
```

In Java:

```text
Java Source Code
        ↓
Java Compiler
        ↓
Java Bytecode
```

## Compiled and Interpreted Execution

Classifying programming languages only as **compiled** or **interpreted** is not always completely accurate.

In simplified terms:

### Compilation

Source code is translated into another format before the program executes.

### Interpretation

Instructions are read and executed at runtime.

Modern runtimes may use compilation, interpretation, and runtime optimization together.

Java also uses such a hybrid execution model.

# How Does a Java Program Execute?

A simplified Java program execution flow:

```text
Java Source Code (.java)
        ↓
Java Compiler (javac)
        ↓
Java Bytecode (.class)
        ↓
JVM
        ↓
Operating System / CPU
        ↓
Program Output
```

## Step 1: Java Source Code

Java source code is generally written in a `.java` file.

Example:

```text
Main.java
```

File:

```java
public class Main {

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

This is human-readable source code written by the developer.

## Step 2: Compile the Source Code

The Java compiler command is:

```bash
javac Main.java
```

If compilation is successful, it creates:

```text
Main.class
```

The `Main.class` file contains Java **bytecode**.

## Step 3: Bytecode

Bytecode is an intermediate instruction format created by the Java compiler.

It is:

* Not Java source code
* Not direct CPU machine code
* An instruction format created for the JVM

Flow:

```text
Main.java
    ↓
javac
    ↓
Main.class
```

## Step 4: JVM Runs the Program

The **JVM — Java Virtual Machine** is the runtime environment that executes Java bytecode.

To run the program:

```bash
java Main
```

The JVM loads the `Main` class, and execution of a standalone Java application begins from the `main` method.

Output:

```text
Hello Java
```

Notice:

```bash
java Main
```

The `.class` extension is not included in the command.

## Role of the JVM

The main responsibility of the JVM is to execute bytecode.

In addition, the JVM provides various runtime services, such as:

* Class loading
* Bytecode execution
* Memory management
* Garbage collection
* Thread management
* Runtime optimization

You do not need to understand the JVM's internal architecture in detail yet. We will discuss the necessary parts later as we continue learning Java.

## JIT Compiler

Modern JVMs can use a **JIT — Just-In-Time Compiler** to improve runtime performance.

In simplified form:

```text
Bytecode
    ↓
JVM execution
    ↓
Frequently executed code
    ↓
JIT compilation
    ↓
Native machine code
```

The JVM can use runtime information to optimize frequently executed code.

This is why Java execution is not only traditional interpretation; compilation and runtime optimization can work together.

## Java Platform Independence

The Java compiler generally produces bytecode instead of a platform-specific machine executable.

The same bytecode can run on different platforms when a compatible JVM is available.

```text
                Windows JVM
              ↗
Java Bytecode → Linux JVM
              ↘
                macOS JVM
```

The important points are:

* **Bytecode can be portable**
* **The JVM is platform-specific**

A JVM for Windows works with Windows, while a JVM for Linux works with Linux.

This model forms the basis of Java's portability.

This idea in Java is often expressed as:

> Write once, run anywhere.

However, if an application uses operating-system-specific paths, native libraries, or platform-specific dependencies, additional compatibility considerations may be required.

## `.java` and `.class`

When learning Java, it is important to clearly remember these two file types.

### `.java`

Source code written by the developer.

```text
Main.java
```

### `.class`

Bytecode generated by the Java compiler.

```text
Main.class
```

Flow:

```text
Main.java
    ↓
javac
    ↓
Main.class
```

## Compilation and Execution

These are two separate stages.

### Compilation

```text
Main.java → Main.class
```

The source code is checked and bytecode is generated.

Command:

```bash
javac Main.java
```

### Execution

```text
Main.class → JVM → Running Program
```

Command:

```bash
java Main
```

Simply put:

> Compilation prepares the code, while execution runs the code.

## Compilation Error vs. Runtime Error

Understanding this difference is important.

### Compilation Error

The following code will not compile:

```java
System.out.println("Hello")
```

The semicolon is missing.

Correct:

```java
System.out.println("Hello");
```

The compiler detects the problem before the program runs.

### Runtime Error

The following code can compile:

```java
int result = 10 / 0;
```

But it will fail during execution.

That means:

> Successful compilation does not mean that a program will be error-free at runtime.

## What Happens When You Press Run in an IDE?

An IDE such as IntelliJ IDEA performs many tasks automatically.

In simplified form:

```text
Source Code
    ↓
Compile
    ↓
Bytecode
    ↓
JVM Start
    ↓
Program Execute
    ↓
Console Output
```

An IDE makes development easier, but the Java compiler compiles Java code and the JVM executes the bytecode.

## Relationship Between Hardware, OS, and JVM

A Java application can be thought of in layers:

```text
Java Application
        ↓
JVM
        ↓
Operating System
        ↓
Hardware
```

### Java Application

The developer's program logic.

### JVM

Executes Java bytecode and provides runtime services.

### Operating System

Manages processes, memory, files, and hardware resources.

### Hardware

CPU, RAM, storage, and physical devices.

Because of this abstraction, a Java developer generally does not need to work with processor-specific instructions when writing normal application code.

## Why Do We Need to Know These Concepts?

This foundation will help you understand:

* Why the CPU does not directly execute Java code
* Why `.java` and `.class` files are different
* Where compilation errors occur
* Where runtime errors occur
* Why the JVM is needed
* How Java can run on different operating systems
* What happens behind an IDE's Run button

## Important Terms

### CPU

The processing unit that executes computer instructions.

### Memory

The place where temporary data for running programs is stored.

### Storage

The place where long-term files and data are stored.

### Operating System

System software that manages computer resources and running programs.

### Machine Language

Low-level instructions that a processor can execute directly.

### High-Level Language

A programming language that is comparatively readable for humans.

### Compiler

A program that analyzes source code and translates it into another format.

### Compilation

The process of translating source code.

### Bytecode

An intermediate instruction format produced by the Java compiler that is compatible with the JVM.

### JVM

The Java Virtual Machine, which executes Java bytecode and provides runtime services.

### JIT Compiler

A compiler that can compile selected bytecode into native machine code at runtime for optimization.

### Source File

A `.java` file written by the developer.

### Class File

A compiled `.class` file containing Java bytecode.

## Practice Exercise 1: Execution Order

Arrange the following steps in the correct order:

* JVM executes the bytecode
* Java source code is written
* The program produces output
* Java compiler generates bytecode

## Practice Exercise 2: Compilation or Runtime?

Determine whether each situation is a problem during the compilation stage or runtime stage.

### Situation 1

A semicolon is missing at the end of a statement.

### Situation 2

The program divides an integer value by zero.

### Situation 3

A text value is assigned to an `int` variable.

### Situation 4

The file that the program is trying to open cannot be found.

## Practice Exercise 3: Java Execution Flow

Write the Java execution flow using the following terms:

* Source code
* Java compiler
* Bytecode
* JVM
* CPU
* Output

## Knowledge Check

### Question 1

What is the main difference between memory and storage?

### Question 2

Why do we use high-level programming languages?

### Question 3

What does a compiler do?

### Question 4

What are the extensions of a Java source file and a compiled file?

### Question 5

What is bytecode?

### Question 6

What is the role of the JVM?

### Question 7

What is the difference between compilation and execution?

### Question 8

How does Java's platform independence work?

## Knowledge Check Answers

### Answer 1

Memory stores temporary data for running programs. Storage preserves long-term files and data.

### Answer 2

A high-level language makes code readable and maintainable for humans and removes the need for programmers to write low-level processor instructions directly.

### Answer 3

A compiler analyzes source code and translates it into another format. The Java compiler produces bytecode from Java source code.

### Answer 4

Java source file:

```text
.java
```

Compiled bytecode file:

```text
.class
```

### Answer 5

Bytecode is an intermediate instruction format produced by the Java compiler that the JVM can execute.

### Answer 6

The JVM executes Java bytecode and provides services such as memory management, class loading, and runtime optimization.

### Answer 7

Compilation creates bytecode from source code. During execution, the JVM runs that bytecode.

### Answer 8

The Java compiler produces bytecode instead of a platform-specific executable. When a compatible platform-specific JVM is available, the same bytecode can run on different operating systems.

## Lesson Summary

In this lesson, we learned:

* The CPU executes computer instructions
* Memory stores temporary data for running programs
* Storage keeps long-term data
* The operating system manages hardware resources and processes
* The CPU does not directly execute Java source code
* Java is a high-level programming language
* The Java compiler produces `.class` bytecode from `.java` source code
* The JVM executes bytecode
* JIT can optimize selected code at runtime
* Compilation and execution are separate stages
* Java bytecode can run on different platforms when a compatible JVM is available

How a Computer Executes a Program

## Lesson Overview

Java is a high-level, general-purpose, statically typed, and class-based programming language with strong support for object-oriented programming.

Java is used to build everything from small command-line programs to backend services, banking platforms, e-commerce applications, and large distributed systems.

In this lesson, we will learn:

* What Java is
* A brief history of Java
* Important characteristics of Java
* What the Java ecosystem is
* Where Java is used
* Why Java is popular for backend development
* Some benefits and challenges of learning Java

## Learning Objectives

After completing this lesson, you will be able to:

* Explain what type of programming language Java is
* Identify important characteristics of Java
* Understand where Java is used
* Explain the relationship between the Java language, JDK, and JVM at a basic level
* Understand the importance of Java in backend development
* Describe some benefits and trade-offs of learning Java

## What Is Java?

Java is a:

* High-level language
* General-purpose language
* Statically typed language
* Class-based language

Java provides strong support for object-oriented programming.

A simple Java program:

```java
public class Main {

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

Output:

```text
Hello Java
```

You do not need to understand every part of this code yet. In the following lessons, we will learn Java syntax, methods, classes, and objects step by step.

## General-Purpose Language

A general-purpose language is not designed for only one specific type of task.

Java can be used to build:

* Command-line applications
* Backend services
* REST APIs
* Web applications
* Financial systems
* E-commerce platforms
* Data processing applications
* Distributed systems

This means Java is not a language limited to one specific domain.

## Statically Typed Language

Java is a statically typed language.

This means the types of variables and expressions are checked at compile time.

```java
int age = 25;
String name = "Sakib";
```

Here, `age` is an integer and `name` is a `String`.

The following code is not valid:

```java
int age = "twenty-five";
```

The compiler can detect that a text value is being assigned to an `int` variable.

Static typing allows many types of errors to be detected before the program runs. It can also make refactoring and maintenance easier in large codebases.

## Class-Based and Object-Oriented Programming

A large part of Java code is structured using classes.

Example:

```java
public class Student {

    String name;
    int age;
}
```

Here, `Student` is a class that represents the structure of student-related data.

Using Java, we can model different concepts in software, such as:

* Student
* Course
* Product
* Order
* BankAccount
* Payment

In later modules, we will learn step by step, starting with classes and objects, and then covering:

* Encapsulation
* Composition
* Inheritance
* Abstraction
* Interface
* Polymorphism

The goal of this course is not only to learn Java syntax, but also to learn how to design maintainable object-oriented software using Java.

## A Brief History of Java

Java development began in the early 1990s at Sun Microsystems through James Gosling and his team.

The language was originally called:

```text
Oak
```

It was later renamed Java and was publicly released in 1995.

Some of the important goals behind Java included:

* Building portable software
* Running code on different platforms
* Providing a managed runtime environment
* Reducing some of the low-level complexity of C and C++

Over time, Java became widely used in enterprise and server-side software development.

## Java Language, JDK, and JVM

When understanding the Java ecosystem, it is useful to distinguish between three terms:

### Java Language

The syntax and programming rules developers use to write source code.

### JDK

**JDK — Java Development Kit** is the toolset needed to develop Java applications.

It includes the compiler and other development-related tools.

### JVM

**JVM — Java Virtual Machine** executes compiled Java bytecode.

In the previous lesson, we saw the Java execution flow:

```text
Java Source Code
        ↓
Compiler
        ↓
Bytecode
        ↓
JVM
        ↓
Running Program
```

This architecture is the foundation of Java application's portability and managed runtime model.

## OpenJDK

**OpenJDK** is the open-source implementation of the Java platform.

Different vendors in the Java ecosystem may provide JDK distributions based on OpenJDK.

As a beginner, vendor differences are not important yet.

The main point is:

> A compatible JDK is required to develop and run Java applications.

# Important Characteristics of Java

Several characteristics of Java have made it suitable for production software development.

## Readable and Explicit

Java syntax is relatively explicit.

```java
int price = 500;
int quantity = 2;
int total = price * quantity;
```

By reading the code, it is easy to understand the variable types and the calculation.

This explicitness can be useful in large teams and large codebases.

The trade-off is that Java can be more verbose than some other languages.

## Platform Portability

The Java compiler generates bytecode, and a compatible JVM can execute that bytecode.

Because of this model, the same compiled Java application may be able to run on different operating systems.

However, if an application uses native libraries or operating-system-specific dependencies, portability may be limited.

## Strong Type System

Java's type system helps detect many invalid operations at compile time.

Example:

```java
int quantity = 10;
String productName = "Keyboard";
boolean available = true;
```

Type information:

* Helps developers understand code
* Improves IDE support
* Makes refactoring safer
* Makes method contracts clearer
* Helps maintain large codebases

## Automatic Memory Management

The JVM manages memory for Java applications.

Developers generally do not need to manually allocate and free memory.

The JVM uses **Garbage Collection** to reclaim memory from unused objects.

This reduces the complexity of low-level memory management.

However, automatic memory management does not mean that developers never need to think about memory. In production applications, allocation, object lifetime, and memory usage can still be important.

## Standard Library

Java provides a rich standard library.

Built-in APIs are available for common functionality such as:

* String processing
* Collections
* File handling
* Date and time
* Networking
* Concurrency
* Input/output
* Security

Example:

```java
String name = "Java";

System.out.println(name.length());
```

Output:

```text
4
```

Here, `String` and `length()` are part of Java's standard library.

## Mature Ecosystem

A large production ecosystem has developed around Java over many years.

Popular technologies include:

* Spring Boot
* Hibernate
* Maven
* Gradle
* JUnit
* Mockito
* Jackson
* Kafka client

These technologies make tasks such as application development, persistence, testing, build automation, and integration easier.

This is why it is important to understand core Java well before learning frameworks.

## Concurrency Support

Java provides built-in language and library support for concurrent programming.

Backend applications may need to handle many requests or background tasks at the same time.

Concurrency is an advanced topic, so you do not need to understand its implementation at this stage. However, it is an important concept in production Java development.

# Where Is Java Used?

Java is used in many types of software systems.

## Backend and API Development

Java is widely used for building server-side applications.

A backend application typically:

* Receives HTTP requests
* Executes business logic
* Works with databases
* Handles authentication and authorization
* Communicates with other services
* Produces API responses

Spring Boot is a widely used framework for Java backend development.

## Enterprise and Financial Systems

Java has been used in enterprise software for many years.

Examples include:

* Banking
* Payment processing
* Insurance
* Telecom
* E-commerce
* Healthcare
* Large internal business systems

These types of applications often need to be maintained for a long time, where reliability, tooling, and backward compatibility are important.

## Distributed Systems

Java can be used to build services that work together over a network.

Examples:

* Microservices
* Message consumers
* Background workers
* Event-driven services
* Data processing services

The Java ecosystem integrates well with technologies such as Kafka, gRPC, Spring, and various networking libraries.

## Android and Desktop Applications

Java was an important language for Android development for many years. Although Kotlin is now prominent, Java is still relevant in the existing Android ecosystem.

Java can also be used to build desktop applications using Swing or JavaFX.

However, the main focus of this course is the foundation of backend engineering.

# Why Is Java Popular for Backend Development?

Java has remained popular in backend development for many years for several practical reasons.

## Mature Ecosystem

The Java ecosystem is built on decades of production experience.

Developers have access to:

* Mature frameworks
* Established libraries
* Strong tooling
* A large community
* Extensive production knowledge

## Strong Framework Support

Frameworks such as Spring Boot make it easier to build production backend applications using Java.

They can be used for:

* REST APIs
* Database integration
* Validation
* Authentication
* Messaging
* Configuration
* Monitoring

However, understanding framework abstractions requires a strong core Java foundation.

## Performance

Modern JVMs can provide strong runtime performance for long-running server applications.

However, application performance does not depend only on the programming language.

Performance is also affected by:

* Algorithms
* Data structures
* Database queries
* Network latency
* Memory allocation
* Concurrency design
* Application architecture

## Maintainability

Java's static typing and explicit structure help maintain large codebases.

Example:

```java
public int calculateTotal(int price, int quantity) {
    return price * quantity;
}
```

From the method signature alone, we can understand that:

* Two `int` inputs are required
* An `int` result is returned

This kind of clear contract is valuable in large teams.

## Tooling

The Java ecosystem has strong IDE support.

In particular, IDEs such as IntelliJ IDEA help with:

* Code completion
* Compile-time error detection
* Refactoring
* Debugging
* Test execution
* Dependency navigation

In large application development, tooling plays an important role in developer productivity and code safety.

# Benefits of Learning Java

Learning Java builds a foundation not only in one language, but also in several transferable software engineering concepts.

Examples include:

* Types
* Variables
* Control flow
* Methods
* Classes and objects
* Interfaces
* Error handling
* Collections
* Generics
* Concurrency

This knowledge is also useful when learning other programming languages and backend technologies later.

Java is also a practical foundation for production backend engineering.

# Challenges of Learning Java

Java can be beginner-friendly, but it also has some challenges.

## Syntax Can Be Relatively Verbose

Even simple tasks can sometimes require more syntax than in other languages.

Java:

```java
System.out.println("Hello");
```

Python:

```python
print("Hello")
```

Although Java's explicitness can increase verbosity in some cases, it can also help keep structure clear in large codebases.

## Many New Terms Appear at the Beginning

A first Java program:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Hello");
    }
}
```

A beginner sees many unfamiliar terms at once.

Examples:

* `public`
* `class`
* `static`
* `void`
* `String`

You do not need to memorize these immediately. The course will introduce them step by step in the correct sequence.

## A Strong Foundation Is Needed Before Frameworks

If you start directly with Spring Boot without understanding Java syntax and OOP, the code may work, but it can be difficult to understand the underlying behavior.

In particular, concepts such as:

* Object creation
* Interface
* Exception
* Generics
* Dependency
* Method invocation

are important for understanding framework abstractions.

This is why we will first build a strong Java and OOP foundation.

## Java and JavaScript Are Not the Same

Despite the similarity in their names, Java and JavaScript are two different programming languages.

Java is generally more associated with the JVM ecosystem and backend or enterprise development.

JavaScript is the primary language for browser-based frontend development and is also used for backend development through Node.js.

Their runtimes, type systems, ecosystems, and execution models are different.

## Important Terms

### Java

A high-level, general-purpose, statically typed, and class-based programming language.

### General-Purpose Language

A programming language that can be used for different types of problems and applications.

### Statically Typed

A language in which type information is checked at compile time.

### Class-Based

A programming model in which classes are important building blocks of program structure.

### Object-Oriented Programming

An approach to modeling and designing software through objects and their responsibilities.

### JDK

A collection of the compiler and other development tools used to develop Java applications.

### JVM

The runtime environment that executes Java bytecode.

### OpenJDK

The open-source implementation of the Java platform.

### Standard Library

Reusable built-in classes and APIs provided with Java.

### Ecosystem

The frameworks, libraries, tools, and community surrounding a language.

## Practice Exercise 1: Identify Java Characteristics

Write which Java characteristic is most closely related to each description below.

1. Variable types are checked at compile time.
2. The JVM can reclaim memory from unused objects.
3. Software can be modeled using classes and objects.
4. Built-in APIs are available for common tasks.
5. Compiled Java code can run on different platforms using compatible JVMs.

Possible answers:

* Static typing
* Automatic memory management
* Object-oriented programming
* Standard library
* Platform portability

## Practice Exercise 2: Where Can Java Be Used?

For any three of the following systems, briefly describe what kind of backend responsibilities Java could handle:

* Banking system
* Learning platform
* E-commerce application
* Food delivery application
* Payment service

## Practice Exercise 3: Observe the Code

Look at the following code:

```java
public class Product {

    String name;
    int price;
}
```

Answer:

1. What is the name of the class?
2. How many fields are there?
3. What are the names of the fields?
4. Which field stores text?
5. Which field stores an integer?

## Knowledge Check

### Question 1

What type of programming language is Java?

### Question 2

What does statically typed language mean?

### Question 3

What does it mean that Java is class-based?

### Question 4

What are the roles of the JDK and JVM?

### Question 5

What are three reasons Java is popular for backend development?

### Question 6

What does automatic memory management mean?

### Question 7

Are Java and JavaScript the same language?

## Knowledge Check Answers

### Answer 1

Java is a high-level, general-purpose, statically typed, and class-based programming language with strong support for object-oriented programming.

### Answer 2

In a statically typed language, the types of variables and expressions are checked at compile time.

### Answer 3

Classes are important building blocks for structuring Java applications. Classes can be used to organize data and behavior.

### Answer 4

The JDK provides the tools needed to develop Java applications. The JVM executes compiled Java bytecode.

### Answer 5

Java's mature ecosystem, static type system, strong framework support, runtime performance, and tooling are important reasons for its popularity in backend development.

### Answer 6

Automatic memory management means that the JVM can reclaim memory from unused objects, so developers generally do not need to manually free memory.

### Answer 7

No. Java and JavaScript are two different programming languages.

## Lesson Summary

In this lesson, we learned:

* Java is a high-level, general-purpose, and statically typed language
* Java is class-based and provides strong support for object-oriented programming
* Java was created at Sun Microsystems and was originally known as `Oak`
* The JDK provides development tools, while the JVM executes Java bytecode
* Java provides automatic memory management and a rich standard library
* Java has a mature ecosystem of frameworks, libraries, and tools
* Java is widely used in backend, enterprise, financial, and distributed systems
* Static typing, maintainability, tooling, and ecosystem make Java suitable for backend development
* It is important to build a strong core Java and OOP foundation before learning frameworks
* Java and JavaScript are two different programming languages

Introduction to Java

## Lesson Overview

At the beginning of Java development, you will repeatedly encounter three terms:

* **JDK**
* **JRE**
* **JVM**

Because these names are similar, they can easily be confusing. However, each has a different responsibility.

In this lesson, we will clearly understand:

* What JDK is
* What JRE is
* What JVM is
* What the `javac` and `java` commands do
* The difference between compile time and runtime
* How the components work together from Java source code to a running program

## Learning Objectives

After completing this lesson, you will be able to:

* Distinguish the responsibilities of JDK, JRE, and JVM
* Understand what the `javac` and `java` commands do
* Identify `.java` and `.class` files
* Explain the difference between compile time and runtime
* Understand the basic relationship between the Java development environment and runtime environment

# JDK, JRE, and JVM

In the previous lesson, we saw the simplified execution flow of a Java program:

```text id="8wjv32"
Java Source Code (.java)
        ↓
Java Compiler
        ↓
Java Bytecode (.class)
        ↓
JVM
        ↓
Running Program
```

Now let's look at the components in this flow more clearly.

## What Is JDK?

**JDK — Java Development Kit** is a collection of tools required to develop Java applications.

As a developer, you will generally install a JDK to compile and run Java code.

The JDK includes:

* Java compiler
* Java launcher
* Runtime components
* Standard Java APIs
* Development utilities

Simply put:

> JDK is the Java developer's toolkit.

## `javac`

`javac` is the Java compiler command.

Suppose your source file is:

```text id="sdjzsw"
Main.java
```

To compile it:

```bash id="0dwe1e"
javac Main.java
```

If compilation is successful, the following file is created:

```text id="k3jywk"
Main.class
```

That means:

```text id="66t8au"
Main.java
    ↓
javac
    ↓
Main.class
```

The `Main.class` file contains Java bytecode.

## `java`

The `java` command starts a compiled Java application.

```bash id="lsrz3s"
java Main
```

Although the `Main.class` file exists, you do not include `.class` in the command.

Incorrect:

```bash id="f1lot9"
java Main.class
```

Correct:

```bash id="xrfpao"
java Main
```

The `java` launcher starts the required runtime and executes the `Main` class through the JVM.

# What Is JVM?

**JVM — Java Virtual Machine** is the runtime engine that executes Java bytecode.

The JVM does not directly execute `.java` source code.

Its input is compiled bytecode:

```text id="sp3uxu"
.class
```

In simplified terms, the JVM is responsible for:

* Loading required classes
* Executing bytecode
* Managing runtime memory
* Providing an execution environment for Java applications

We will explore JVM class loading, garbage collection, JIT compilation, and memory internals in later lessons when needed.

## Why Is the JVM Important?

Instead of producing a platform-specific executable, the Java compiler produces JVM-compatible bytecode.

The same bytecode can run on different platforms when a compatible JVM is available.

```text id="5dy30n"
                Windows JVM
              ↗
Main.class ─── Linux JVM
              ↘
                macOS JVM
```

Bytecode can be portable, but the JVM implementation differs for each operating system.

# What Is JRE?

**JRE — Java Runtime Environment** refers to the runtime environment required to run Java applications.

Conceptually, it includes:

* JVM
* Java runtime libraries
* Required runtime components

Simply put:

> The purpose of the JRE is to run Java applications.

Traditionally, the distinction was:

```text id="ke5cgi"
JDK → Develop + Compile + Run
JRE → Run
JVM → Execute Bytecode
```

In the modern Java ecosystem, standalone JRE installations are not as central as they once were. Developers generally install a full JDK, which includes the runtime components required to run applications.

As a beginner, the most important distinction is:

| Component | Main Responsibility                         |
| --------- | ------------------------------------------- |
| JDK       | Develop and compile Java applications       |
| JRE       | The concept of the Java runtime environment |
| JVM       | Execute Java bytecode                       |

# How Do JDK, JRE, and JVM Work Together?

For a Java program:

```text id="tyax6p"
Developer
    ↓
Main.java
    ↓
JDK's javac compiler
    ↓
Main.class
    ↓
Java runtime
    ↓
JVM
    ↓
Program Execution
```

From a developer's perspective, the common workflow is:

1. Install a JDK
2. Write Java source code
3. Compile the code using `javac`
4. Generate `.class` bytecode
5. Start the application using the `java` command
6. JVM executes the bytecode

# Source File and Class File

There are two file types in Java development that should be clear from the beginning.

## `.java`

Source code written by the developer.

```text id="id4ol5"
Main.java
```

Example:

```java id="ppti6t"
public class Main {

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

## `.class`

Bytecode generated by the Java compiler.

```text id="di5nav"
Main.class
```

Relationship:

```text id="d6nkaw"
Main.java
    ↓
javac
    ↓
Main.class
```

# Complete Compile and Run Example

Suppose we have:

```java id="45m9j1"
public class Main {

    public static void main(String[] args) {
        System.out.println("Learning Java");
    }
}
```

The file is saved as:

```text id="f9djxz"
Main.java
```

Compile:

```bash id="u275s6"
javac Main.java
```

Generated file:

```text id="7gz8d9"
Main.class
```

Run:

```bash id="ub906p"
java Main
```

Output:

```text id="44m2eo"
Learning Java
```

This single example shows the entire basic workflow:

```text id="z1lglq"
Source Code
    ↓
Compile
    ↓
Bytecode
    ↓
Run
    ↓
Output
```

# Compile Time and Runtime

In Java development, **compile time** and **runtime** are two separate stages.

## Compile Time

Compile time is the stage when source code is being compiled.

At this stage, the compiler analyzes the source code.

Example:

```java id="7iutf9"
int age = "twenty";
```

Here, a `String` value is being assigned to an `int` variable.

The compiler will not accept this code.

Examples of compile-time problems include:

* Invalid syntax
* Incompatible type
* Unknown variable
* Invalid method usage

## Runtime

Runtime is the stage when the program is executing.

Example:

```java id="pq48fo"
int result = 10 / 0;
```

The code can compile, but it will fail during execution because of integer division by zero.

That means:

> Successful compilation does not guarantee that a program will successfully run at runtime.

## Compile Time vs. Runtime

| Topic           | Compile Time                 | Runtime                      |
| --------------- | ---------------------------- | ---------------------------- |
| When            | While code is being compiled | While the program is running |
| Main component  | Compiler                     | JVM                          |
| Input           | Source code                  | Compiled bytecode            |
| Example command | `javac Main.java`            | `java Main`                  |
| Common problem  | Syntax/type error            | Runtime exception            |

# Development Environment and Runtime Environment

A developer's computer generally contains:

* Source code
* JDK
* IDE
* Build tools
* Tests

In this environment, code is written, compiled, and tested.

In a production environment, the application's source code is not necessarily required. The application can run as long as the compiled application and the required Java runtime are available.

This distinction will become important later when we learn about backend deployment.

# Why Is JDK Needed Even If You Have an IDE?

An IDE such as IntelliJ IDEA does not compile or execute the Java language by itself.

An IDE makes the development workflow easier by helping with:

* Writing code
* Highlighting errors
* Invoking the compiler
* Running applications
* Debugging
* Running tests

However, the underlying Java compiler and runtime come from the JDK.

That is why a JDK must be configured alongside the IDE when setting up a Java development environment.

# Common Misconceptions

### JVM Compiles Source Code

No.

The `javac` compiler compiles source code.

The JVM executes compiled bytecode.

### JDK and JVM Are the Same Thing

No.

JDK is the development toolkit.

JVM is the runtime engine that executes Java bytecode.

### Bytecode Is Machine Code

No.

Bytecode is an intermediate instruction format for the JVM.

### Successful Compilation Means the Program Is Correct

No.

A program may fail at runtime or may run successfully but still produce an incorrect result because of a logical error.

### You Do Not Need JDK If You Have an IDE

No.

An IDE depends on a configured JDK to use the Java compiler and runtime.

# Important Terms

### JDK

Java Development Kit. A collection of tools and runtime components used to develop and compile Java applications.

### JRE

Java Runtime Environment. The concept of the runtime environment used to run Java applications.

### JVM

Java Virtual Machine. The runtime engine that executes Java bytecode.

### `javac`

The command used to compile Java source code.

### `java`

The command used to start a compiled Java application.

### Source Code

The `.java` code written by the developer.

### Bytecode

A JVM-compatible intermediate instruction format produced by the Java compiler.

### Compile Time

The stage when source code is compiled.

### Runtime

The stage when the compiled program is executed.

### Class File

A `.class` file containing Java bytecode.

# Practice Exercise 1: Identify the Component

Match the following tasks with the most appropriate component:

* JDK
* JVM
* Java compiler

1. Compile Java source code
2. Provide Java development tools
3. Execute bytecode
4. Provide the `javac` command

# Practice Exercise 2: Compile Time or Runtime?

Write which stage each problem occurs in.

### Problem 1

```java id="8pxfjw"
int age = "twenty";
```

### Problem 2

```java id="ftjl9m"
int result = 10 / 0;
```

### Problem 3

An undeclared variable is used.

### Problem 4

At runtime, the program tries to open a file that does not exist.

# Practice Exercise 3: Write the Commands

Suppose you have:

```text id="c0fboq"
Calculator.java
```

It contains:

```java id="qmkxse"
public class Calculator {
}
```

Write:

1. The compile command
2. The name of the generated file
3. The run command

# Knowledge Check

### Question 1

What is the main purpose of the JDK?

### Question 2

What does the JVM execute?

### Question 3

What is the difference between the `javac` and `java` commands?

### Question 4

What is the difference between `.java` and `.class` files?

### Question 5

What is the difference between compile time and runtime?

### Question 6

What does JRE conceptually mean?

### Question 7

Why is a JDK still needed when using an IDE?

# Knowledge Check Answers

### Answer 1

The JDK provides the tools and runtime components required to develop, compile, and run Java applications.

### Answer 2

The JVM executes compiled Java bytecode.

### Answer 3

`javac` compiles Java source code. `java` starts a compiled Java application.

### Answer 4

A `.java` file contains source code written by the developer. A `.class` file contains Java bytecode produced by the compiler.

### Answer 5

At compile time, the compiler analyzes and translates the source code. At runtime, the compiled program is executed through the JVM.

### Answer 6

JRE refers to the environment containing the JVM, runtime libraries, and supporting components required to run Java applications.

### Answer 7

An IDE manages the development workflow, but it uses the compiler and runtime from a configured JDK to compile and execute Java code.

# Lesson Summary

In this lesson, we learned:

* JDK is the Java development toolkit
* JRE represents the Java runtime environment
* JVM executes Java bytecode
* `javac` compiles `.java` source code
* The compiler generates `.class` bytecode
* The `java` command starts a compiled application
* Compile time and runtime are separate stages
* Successful compilation does not guarantee runtime success
* An IDE makes Java development easier but still depends on the underlying JDK

JDK, JRE, JVM, and Bytecode

## Lesson Overview

To write, compile, and run Java code, you need a working development environment on your computer.

In this course, we will use:

* **Azul Zulu JDK 21**
* **IntelliJ IDEA**

In this lesson, you will install Azul Zulu JDK 21, verify the installation, and configure IntelliJ IDEA to use Java 21.

We will cover:

* Installing Azul Zulu JDK 21
* Verifying the `java` and `javac` commands
* Understanding `PATH` and `JAVA_HOME`
* Installing IntelliJ IDEA
* Configuring a JDK in IntelliJ IDEA
* Running a Java program from the terminal and IDE
* Troubleshooting common setup problems

## Learning Objectives

After completing this lesson, you will be able to:

* Install Azul Zulu JDK 21
* Verify a Java installation from the terminal
* Understand the roles of `PATH` and `JAVA_HOME`
* Configure Java 21 in IntelliJ IDEA
* Compile and run a Java program from the terminal
* Run a Java program from IntelliJ IDEA
* Identify common setup problems

# What Do You Need?

To start Java development, you need two main tools:

1. **Azul Zulu JDK 21**
2. **IntelliJ IDEA**

Conceptually, the setup looks like this:

```text
Computer
├── Azul Zulu JDK 21
│   ├── Java Compiler
│   ├── Java Runtime
│   └── Development Tools
│
└── IntelliJ IDEA
    ├── Code Editor
    ├── Project Management
    ├── Run / Debug Support
    └── Test Support
```

We will use Java 21 for the code and exercises in this course.

# Installing Azul Zulu JDK 21

When downloading the JDK, make sure you select:

* Distribution: **Azul Zulu**
* Java version: **21**
* Package: **JDK**
* Correct operating system
* Correct CPU architecture

## CPU Architecture

When downloading a JDK, you will commonly see architectures such as:

* `x64`
* `ARM64` / `AArch64`

In general:

* Intel or AMD 64-bit processor → `x64`
* Apple Silicon Mac → `ARM64`

On macOS or Linux, you can check your architecture using:

```bash
uname -m
```

The output may be:

```text
x86_64
```

or:

```text
arm64
```

or:

```text
aarch64
```

Download the Azul Zulu JDK 21 package that matches your machine's architecture.

# Installing Azul Zulu JDK 21 on Windows

From Azul's official download source, select:

* Java version: `21`
* Package: `JDK`
* Operating system: Windows
* Architecture: `x64` or `ARM64`

Download the installer and complete the installation.

If the installer provides an option to add Java to `PATH`, you can leave that option enabled.

After installation, open a new PowerShell or Windows Terminal window.

Run:

```bash
java -version
```

Then:

```bash
javac -version
```

Both commands should show Java version `21`.

# Installing Azul Zulu JDK 21 on macOS

First, check your architecture:

```bash
uname -m
```

On an Apple Silicon Mac, the output will usually be:

```text
arm64
```

On an Intel Mac, it will usually be:

```text
x86_64
```

Then, when downloading Azul Zulu, select:

* Java version: `21`
* Package: `JDK`
* Operating system: macOS
* The correct architecture for your processor

After installation, you can view installed JDKs using:

```bash
/usr/libexec/java_home -V
```

Then verify the installation:

```bash
java -version
```

```bash
javac -version
```

# Installing Azul Zulu JDK 21 on Linux

When selecting the Linux package for Azul Zulu JDK 21, make sure you choose:

* Java version: `21`
* Package: `JDK`
* Operating system: Linux
* Correct CPU architecture

The package format and installation method may differ depending on your Linux distribution.

After installation, verify it with:

```bash
java -version
```

```bash
javac -version
```

Both commands should report Java 21.

# Verify the Installation

After installing the JDK, first run:

```bash
java -version
```

Then:

```bash
javac -version
```

The `java` command shows whether the Java runtime is available.

The `javac` command shows whether the Java compiler is available.

The major version of both should be:

```text
21
```

Conceptually, your setup should look like:

```text
java  → Java 21
javac → Java 21
```

If the two commands show different Java versions, you may have multiple JDKs installed or your environment configuration may not be correct.

# What Is `PATH`?

`PATH` is an environment variable.

When you type:

```bash
java
```

in the terminal, the operating system needs to know where the `java` executable is located.

JDK executable files are usually located inside the `bin` directory:

```text
Zulu JDK 21
└── bin
    ├── java
    ├── javac
    └── ...
```

If the JDK is installed but you still see:

```text
java: command not found
```

or on Windows:

```text
'java' is not recognized
```

you should check whether your `PATH` configuration is correct.

# What Is `JAVA_HOME`?

`JAVA_HOME` is an environment variable that usually points to the JDK installation directory.

Conceptually:

```text
JAVA_HOME=/path/to/zulu-jdk-21
```

`JAVA_HOME` should point to the root directory of the JDK, not its `bin` directory.

That means:

```text
JAVA_HOME
└── bin
    ├── java
    └── javac
```

Maven, Gradle, and other development tools may use `JAVA_HOME` to locate the JDK.

## Checking `JAVA_HOME`

Windows PowerShell:

```powershell
echo $env:JAVA_HOME
```

Windows Command Prompt:

```cmd
echo %JAVA_HOME%
```

macOS or Linux:

```bash
echo $JAVA_HOME
```

If `JAVA_HOME` is configured, make sure it points to the Azul Zulu JDK 21 installation.

# Which Java Executable Is Being Used?

If multiple Java installations exist on your computer, you can check which executable the terminal is using.

Windows:

```powershell
where.exe java
where.exe javac
```

macOS or Linux:

```bash
which java
which javac
```

Then verify again:

```bash
java -version
javac -version
```

For this course, we need Java 21.

# Test a Java Program from the Terminal

Before configuring IntelliJ IDEA, let's compile and run a small Java program from the terminal.

Create a file named `Main.java`:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Java setup is working");
    }
}
```

Compile it:

```bash
javac Main.java
```

If compilation succeeds, the following file will be created in the same directory:

```text
Main.class
```

Now run it:

```bash
java Main
```

Output:

```text
Java setup is working
```

If you see this output, both your Java compiler and runtime are working.

# What Is an IDE?

**IDE — Integrated Development Environment** is an application that provides several software development tools in one place.

An IDE commonly provides:

* Code editor
* Project explorer
* Code completion
* Error highlighting
* Run and debug support
* Refactoring
* Test runner
* Terminal
* Version control integration

In this course, we will use **IntelliJ IDEA**.

# Installing IntelliJ IDEA

Download and install IntelliJ IDEA for your operating system and CPU architecture.

For learning core Java and OOP, the free edition is sufficient.

After installation is complete, start IntelliJ IDEA.

# Configure Azul Zulu JDK 21 in IntelliJ IDEA

IntelliJ IDEA needs to know which JDK it should use to compile and run your project.

When creating a new Java project, select:

```text
Azul Zulu 21
```

as the JDK.

Conceptually:

```text
New Project
→ Java
→ JDK
→ Azul Zulu 21
```

IntelliJ IDEA may detect the installed JDK automatically.

If it does not, select:

```text
Add JDK
```

and point IntelliJ IDEA to the Azul Zulu JDK 21 installation directory.

# What Is Project SDK?

**Project SDK** is the JDK that IntelliJ IDEA uses to compile and run a specific project.

For projects in this course, use:

```text
Project SDK: Azul Zulu 21
```

If there is an option to select the Java language level, keep it compatible with Java 21 as well.

# Test the Setup from IntelliJ IDEA

Create a Java project and select Azul Zulu 21 as the JDK.

Create a `Main` class:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("IntelliJ IDEA is ready");
    }
}
```

Run the program.

Output:

```text
IntelliJ IDEA is ready
```

If you see this output:

* The JDK is configured
* The project is compiling
* The Java program is running

Your development environment is ready.

# Why Did We Test Both the Terminal and IDE?

Running a program from the terminal confirms that the operating system-level Java setup is working.

Running a program from IntelliJ IDEA confirms that the IDE is using the correct Project SDK.

If both tests are successful, your environment is ready for the upcoming coding lessons.

# Common Setup Problems

## `java` Command Is Not Found

If you see:

```text
java: command not found
```

or:

```text
'java' is not recognized
```

check whether:

* Azul Zulu JDK 21 is installed
* The JDK is available in `PATH`
* You opened a new terminal after installation

Then run again:

```bash
java -version
```

## `java` Works, but `javac` Does Not

Run:

```bash
java -version
javac -version
```

This may happen if:

* A full JDK is not installed
* `PATH` points to another Java installation

Make sure **Azul Zulu JDK 21** is installed.

## Wrong Java Version

If you see:

```text
java 17
javac 21
```

or another version is being used instead of Java 21, check the executable locations.

Windows:

```powershell
where.exe java
where.exe javac
```

macOS / Linux:

```bash
which java
which javac
```

Then check:

* `PATH`
* `JAVA_HOME`
* IntelliJ IDEA Project SDK

Use Java 21 in all relevant places.

## IntelliJ IDEA Does Not Detect the JDK

First, verify from the terminal:

```bash
java -version
javac -version
```

If both commands work correctly, select:

```text
Add JDK
```

in IntelliJ IDEA and manually choose the Azul Zulu JDK 21 installation directory.

## `Project SDK is not defined`

A JDK has not been selected for the project.

From the project settings, select:

```text
Azul Zulu 21
```

## IntelliJ IDEA Uses Another Java Version

Even if Java 21 is available in the terminal, IntelliJ IDEA may use a different JDK.

Check the Project SDK:

```text
Project SDK: Azul Zulu 21
```

## Wrong CPU Architecture

If the installer or JVM does not start, check whether the downloaded JDK matches your CPU architecture.

Common mapping:

```text
Intel / AMD 64-bit → x64
Apple Silicon      → ARM64
```

# Development Environment Checklist

Before moving to the next lesson, make sure:

* [ ] Azul Zulu JDK 21 is installed
* [ ] The correct operating system and CPU architecture were selected
* [ ] `java -version` shows Java 21
* [ ] `javac -version` shows Java 21
* [ ] If `JAVA_HOME` is configured, it points to Zulu JDK 21
* [ ] A Java program was successfully compiled from the terminal
* [ ] A Java program was successfully run from the terminal
* [ ] IntelliJ IDEA is installed
* [ ] Azul Zulu 21 is configured as the Project SDK
* [ ] A Java program was successfully run from IntelliJ IDEA

# Practice Exercise 1: Verify the Environment

Run the following commands from the terminal:

```bash
java -version
javac -version
```

Check whether both commands report Java 21.

Then check the executable locations.

Windows:

```powershell
where.exe java
where.exe javac
```

macOS / Linux:

```bash
which java
which javac
```

# Practice Exercise 2: Run a Program from the Terminal

Create `SetupTest.java`:

```java
public class SetupTest {

    public static void main(String[] args) {
        System.out.println("My Java setup works");
    }
}
```

Compile:

```bash
javac SetupTest.java
```

Run:

```bash
java SetupTest
```

Expected output:

```text
My Java setup works
```

# Practice Exercise 3: Run a Program from IntelliJ IDEA

Create a Java project in IntelliJ IDEA.

Select **Azul Zulu 21** as the Project SDK.

Then create:

```java
public class EnvironmentCheck {

    public static void main(String[] args) {
        System.out.println("IDE and JDK are configured");
    }
}
```

Run the program.

Expected output:

```text
IDE and JDK are configured
```

# Knowledge Check

## Question 1

Which JDK and Java version are we using in this course?

## Question 2

Why do we check both `java -version` and `javac -version`?

## Question 3

What is `PATH` used for?

## Question 4

What does `JAVA_HOME` point to?

## Question 5

What is a Project SDK?

## Question 6

What commands are used to compile and run a Java program from the terminal?

## Question 7

If Java 21 is available in the terminal but IntelliJ IDEA is using another Java version, where should you check?

# Knowledge Check Answers

## Answer 1

In this course, we use **Azul Zulu JDK 21**.

## Answer 2

`java -version` shows the Java runtime version, while `javac -version` shows the compiler version. We need to verify that both are using Java 21.

## Answer 3

`PATH` tells the operating system where to find executable commands.

## Answer 4

`JAVA_HOME` points to the root directory of the JDK installation.

## Answer 5

Project SDK is the JDK that IntelliJ IDEA uses to compile and run a project.

## Answer 6

Compile:

```bash
javac Main.java
```

Run:

```bash
java Main
```

## Answer 7

Check IntelliJ IDEA's Project SDK and configure it to use Azul Zulu 21.

# Lesson Summary

In this lesson, we learned:

* We are using Azul Zulu JDK 21 and IntelliJ IDEA for Java development
* The correct JDK must be selected for the operating system and CPU architecture
* `java -version` and `javac -version` can be used to verify the Java 21 installation
* `PATH` helps the operating system locate Java commands
* `JAVA_HOME` points to the JDK installation directory
* The setup can be verified by compiling and running a Java program from the terminal
* Azul Zulu 21 should be configured as the Project SDK in IntelliJ IDEA
* It is important to verify that both the terminal and IDE are using Java 21

Setting Up the Java Development Environment

## Lesson Overview

In the previous lesson, we configured **Azul Zulu JDK 21** and IntelliJ IDEA.

Now we will create our first Java project using IntelliJ IDEA.

In this lesson, you will:

* Create a Java project
* Use Azul Zulu 21 as the Project SDK
* Understand the project structure
* Create a Java class
* Write a `main` method
* Run the program
* Read console output

By the end of the lesson, you will have a working Java project that you can use for practice in the upcoming lessons.

## Learning Objectives

After completing this lesson, you will be able to:

* Create a Java project in IntelliJ IDEA
* Configure the project name, location, and JDK
* Understand the purpose of the `src` directory
* Create a Java class
* Write a basic `main` method
* Run a Java program from IntelliJ IDEA
* Understand console output and exit codes
* Identify common project setup problems

# What Is a Java Project?

A Java project is a structure used to organize related Java source code and project configuration.

A simple project may look like this:

```text
first-java-project/
└── src/
    └── Main.java
```

We will keep our Java source code inside the `src` directory.

The structure of a larger application can be more complex. We will learn about build tools, test structure, resources, and dependency management later when needed.

# Creating Your First Java Project

Open IntelliJ IDEA.

From the Welcome screen, select:

```text
New Project
```

If a project is already open, you can create a new project from the menu:

```text
File
→ New
→ Project
```

The interface may look slightly different depending on your IntelliJ IDEA version.

## Step 1: Select Java

Select:

```text
Java
```

as the project type or language.

## Step 2: Enter the Project Name

Enter:

```text
first-java-project
```

as the project name.

It is a good practice to keep project names short and meaningful.

Examples:

```text
java-foundation
grade-calculator
oop-practice
```

## Step 3: Select the Project Location

Store the project in a directory that is easy to find and where you have read and write permissions.

Example:

```text
Documents/java-projects/first-java-project
```

or:

```text
Development/java/first-java-project
```

Avoid storing your project inside system directories.

## Step 4: Select the JDK

Select:

```text
Azul Zulu 21
```

as the JDK.

All projects in this course will use Java 21.

If Azul Zulu 21 is not listed, select:

```text
Add JDK
```

and choose the Azul Zulu JDK 21 directory that you installed in the previous lesson.

## Step 5: Select the Build System

Select:

```text
IntelliJ
```

as the build system.

At this stage, we are not using Maven or Gradle.

A simple IntelliJ project helps us focus on the Java language and programming fundamentals.

## Step 6: Create the Project

Conceptually, the configuration should look like this:

```text
Name: first-java-project
Language: Java
Build System: IntelliJ
JDK: Azul Zulu 21
```

Then select:

```text
Create
```

# Project Structure

After creating the project, you will see the project's files and directories in the **Project** panel on the left side.

A simple structure may look like:

```text
first-java-project/
└── src/
```

IntelliJ IDEA may create additional configuration or generated directories. We do not need to worry about them yet.

The most important directory at this stage is:

```text
src
```

# What Is the `src` Directory?

`src` is the **source directory**.

The Java source code we write will be stored inside this directory.

```text
first-java-project/
└── src/
    ├── Main.java
    ├── Student.java
    └── GradeCalculator.java
```

IntelliJ IDEA uses `src` as a source root, which allows it to:

* Compile the Java code inside it
* Analyze the code
* Detect errors
* Run the code

In this lesson, we will have only one class.

# Creating Your First Java Class

In the Project panel, right-click the:

```text
src
```

directory.

Select:

```text
New
→ Java Class
```

Enter the class name:

```text
Main
```

IntelliJ IDEA will create:

```text
Main.java
```

The initial code may look like:

```java
public class Main {
}
```

# Class and File Name

Our class is named:

```text
Main
```

Therefore, the file name will be:

```text
Main.java
```

```java
public class Main {
}
```

Java is case-sensitive.

So:

```text
Main
```

and:

```text
main
```

are not the same name.

Java class names generally follow the **PascalCase** naming convention.

Examples:

```text
Main
Student
GradeCalculator
BankAccount
```

# Adding the `main` Method

Now write the following inside the `Main` class:

```java
public class Main {

    public static void main(String[] args) {

    }
}
```

A basic Java application usually starts execution from this `main` method.

There are several new keywords in this signature:

```java
public static void main(String[] args)
```

You do not need to memorize or deeply understand them yet.

In the next lesson, we will understand each part of the program separately.

# Writing Your First Output

Inside the `main` method, write:

```java
System.out.println("Hello Java");
```

Complete program:

```java
public class Main {

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

`System.out.println(...)` displays output in the console.

When the program runs, we will get:

```text
Hello Java
```

# Running the Program

IntelliJ IDEA usually shows a Run icon next to the `main` method.

Click the Run icon and select:

```text
Run 'Main.main()'
```

You can also right-click `Main.java` and use the same Run option.

# Console Output

If the program runs successfully, you will see the following in the Run window:

```text
Hello Java
```

You may also see a message such as:

```text
Process finished with exit code 0
```

## What Does Exit Code `0` Mean?

A process exit code can be used to tell the operating system how a program finished.

In general:

```text
exit code 0
```

means the program finished normally.

However, exit code `0` does not mean that the program's logic is necessarily correct.

It only indicates that the process did not terminate abnormally.

# Modify the Program and Run It Again

Change the code to:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Welcome to Java");
        System.out.println("My first Java project is running");
    }
}
```

Run it again.

Output:

```text
Welcome to Java
My first Java project is running
```

There are two `System.out.println(...)` statements, so two separate lines are printed.

# Project SDK

The JDK that IntelliJ IDEA uses to compile and run a project is called the **Project SDK**.

Our project configuration should be:

```text
Project SDK: Azul Zulu 21
```

If the project does not run or uses the wrong Java version, check the Project SDK first.

# Common Project Problems

## Project SDK Is Not Configured

Possible message:

```text
Project SDK is not defined
```

From the project settings, select:

```text
Azul Zulu 21
```

## Run Option Is Not Visible

Check whether the class contains the standard `main` method:

```java
public static void main(String[] args)
```

Also make sure:

* The file is inside the `src` directory
* The Project SDK is configured
* There are no compilation errors in the code

## Missing Semicolon

Wrong:

```java
System.out.println("Hello Java")
```

Correct:

```java
System.out.println("Hello Java");
```

If a required semicolon is missing at the end of a Java statement, the compiler will report an error.

## Class and File Name Do Not Match

If the code is:

```java
public class Main {
}
```

then the source file should be:

```text
Main.java
```

## Wrong Capitalization

Java is case-sensitive.

Class:

```java
public class Main {
}
```

Therefore, `Main` and `main` are different identifiers.

## Wrong JDK Selected

If the project is using a JDK other than Java 21, check the Project SDK.

For this project, use:

```text
Azul Zulu 21
```

# Your First Complete Program

Now write the following in `Main.java`:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Java and OOP Foundation");
        System.out.println("My first Java project is running.");
        System.out.println("I am ready to learn Java.");
    }
}
```

Expected output:

```text
Java and OOP Foundation
My first Java project is running.
I am ready to learn Java.
```

If the program runs successfully, your first Java project has been created and configured.

# Project Creation Checklist

Before moving to the next lesson, make sure:

* [ ] You created a Java project in IntelliJ IDEA
* [ ] You selected Azul Zulu 21 as the Project SDK
* [ ] You found the `src` directory
* [ ] You created the `Main` class
* [ ] The `Main.java` file was created
* [ ] You wrote the standard `main` method
* [ ] You used `System.out.println`
* [ ] You successfully ran the program
* [ ] You received the expected output

# Practice Exercise 1: Create a Project

Create a project in IntelliJ IDEA:

```text
Project name: java-foundation
JDK: Azul Zulu 21
Class name: Main
```

`Main.java`:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Java Foundation project created");
    }
}
```

Expected output:

```text
Java Foundation project created
```

# Practice Exercise 2: Modify the Output

Modify the program to print the following information on separate lines:

* Your name
* Course name
* Java version
* One goal for learning Java

Example:

```text
Name: Sakib
Course: Java and OOP Foundation
Java: 21
Goal: Learn backend development
```

Use your own information.

# Practice Exercise 3: Fix the Error

Fix the error in the following code:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Hello Java")
        System.out.println("My first project");
    }
}
```

Expected output:

```text
Hello Java
My first project
```

# Knowledge Check

## Question 1

What is a Java project?

## Question 2

What is the purpose of the `src` directory?

## Question 3

Which JDK are we using for projects in this course?

## Question 4

If there is a public class named `Main`, what should the source file be named?

## Question 5

Which method does a basic Java application usually start from?

## Question 6

Which statement did we use to display text in the console?

## Question 7

What does exit code `0` generally mean?

## Question 8

What should you check if the Run option is not visible?

# Knowledge Check Answers

## Answer 1

A Java project is a structure used to organize related Java source code and project configuration.

## Answer 2

Java source code is stored inside the `src` directory. IntelliJ IDEA uses it as a source root to compile, analyze, and run the code.

## Answer 3

In this course, we are using **Azul Zulu JDK 21**.

## Answer 4

The file should be named:

```text
Main.java
```

## Answer 5

A basic Java application usually starts execution from:

```java
public static void main(String[] args)
```

## Answer 6

We used:

```java
System.out.println("...");
```

## Answer 7

Exit code `0` generally means that the program finished normally.

## Answer 8

Check whether:

* A valid `main` method exists
* The file is inside the `src` source directory
* Azul Zulu 21 is configured as the Project SDK
* There are any compilation errors

# Lesson Summary

In this lesson, we learned:

* How to create a Java project in IntelliJ IDEA
* That we are using Azul Zulu 21 as the Project SDK
* Java source code is stored inside the `src` directory
* A Java class can be created using `New → Java Class`
* A public class and its source file name must match
* Java class names generally follow PascalCase
* A basic Java application starts from the `main` method
* `System.out.println` displays output in the console
* Java programs can be run from IntelliJ IDEA
* Exit code `0` indicates normal process completion
* The Project SDK, `main` method, and source directory are important when diagnosing common setup problems

Creating Your First Java Project

## Lesson Overview

In the previous lesson, we created and ran the following Java program:

```java
public class Main {

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

Although the program is small, it contains several fundamental building blocks of a Java program.

In this lesson, we will understand:

* What a class is
* What `public class Main` means
* The role of the `main` method
* The basic meaning of `public`, `static`, and `void`
* Why `String[] args` is present
* What statements and code blocks are
* What `System.out.println()` does
* Where Java program execution begins

## Learning Objectives

After completing this lesson, you will be able to:

* Explain the structure of a basic Java program
* Identify a class declaration
* Understand the role of the `main` method
* Explain the basic meaning of `public`, `static`, and `void`
* Identify statements and code blocks
* Display output using `System.out.println()`
* Understand the roles of semicolons and braces
* Explain the execution order of a basic program

# Our First Program

```java
public class Main {

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

Output:

```text
Hello Java
```

Program structure:

```text
Main class
└── main method
    └── output statement
```

Now let's look at each part.

# `public class Main`

The first line is:

```java
public class Main {
```

This is a **class declaration**.

Here:

* `public` — access modifier
* `class` — Java keyword
* `Main` — class name
* `{` — beginning of the class body

# What Is a Class?

A class is a fundamental structure in a Java program.

A class can organize data and behavior.

In our first program:

```java
public class Main {
}
```

`Main` is a class.

Later, we will create classes such as:

```text
Student
Course
BankAccount
Order
GradeCalculator
```

When we learn object-oriented programming, we will understand the actual role of classes in much more detail.

For now, remember:

> Java code is generally organized inside classes.

# The `class` Keyword

```java
class
```

is a reserved Java keyword.

It tells the compiler that we are declaring a class.

Example:

```java
class Student {
}
```

Keywords have meanings defined by the language. Therefore, a keyword cannot normally be used as a variable or class name.

# Class Name: `Main`

```java
Main
```

is the name of the class.

`Main` is not a special or mandatory class name.

The following is also valid:

```java
public class Application {

    public static void main(String[] args) {
        System.out.println("Application started");
    }
}
```

In this case, the source file would be named:

```text
Application.java
```

The name of a public class and the source file name must match.

In our case:

```text
Class: Main
File: Main.java
```

# Class Naming Convention

Java class names generally follow the **PascalCase** convention.

Good examples:

```text
Main
Student
Course
BankAccount
GradeCalculator
```

When a name contains multiple words, each word starts with a capital letter:

```text
GradeCalculator
BankAccount
CourseEnrollment
```

# `public`

```java
public class Main
```

Here, `public` is an **access modifier**.

Access modifiers help control where a class or member can be accessed from.

For now, remember:

> `public` indicates wider accessibility.

We will study access modifiers in detail when we learn OOP.

# Curly Braces `{ }`

The class body is placed inside curly braces:

```java
public class Main {

}
```

The opening brace:

```text
{
```

starts a block.

The closing brace:

```text
}
```

ends a block.

Our program contains two nested blocks:

```java
public class Main {                         // Class block starts

    public static void main(String[] args) { // Method block starts
        System.out.println("Hello Java");
    }                                       // Method block ends

}                                           // Class block ends
```

Structure:

```text
Class
{
    Method
    {
        Statement
    }
}
```

# The `main` Method

Now look at the second important line:

```java
public static void main(String[] args) {
```

This is the declaration of the `main` method.

A basic Java application usually begins execution from this method.

The method name is:

```text
main
```

The traditional Java application entry point is:

```java
public static void main(String[] args)
```

# What Is a Method?

A method is a named block of related instructions.

In our program:

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

Method name:

```text
main
```

Method body:

```java
{
    System.out.println("Hello Java");
}
```

Later, we will learn how to create our own methods.

# Why Is `main` Important?

When a Java application is started, the runtime looks for a suitable `main` method and begins execution from there.

Example:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("First");
        System.out.println("Second");
    }
}
```

Execution:

```text
Enter main
    ↓
Print First
    ↓
Print Second
    ↓
Exit main
```

Output:

```text
First
Second
```

# `public static void`

At the beginning of the `main` method, we have:

```java
public static void
```

For now, understanding the basic meaning of each part is enough.

## `public`

```java
public
```

The method can be accessible from outside when the application starts.

## `static`

```java
static
```

Because `main` is `static`, an object of the `Main` class does not need to be created before the `main` method can run.

For now, remember:

> The `main` method is directly available through the class for application startup.

We will understand `static` in more depth after learning about classes and objects.

## `void`

```java
void
```

is the return type of the method.

`void` means that the method does not return a value.

Our `main` method runs the program but does not return a result to its caller.

# `String[] args`

Inside the parentheses of the `main` method, we have:

```java
String[] args
```

This is a parameter used to receive command-line arguments.

Here:

```text
String[]
```

is the parameter type.

```text
args
```

is the parameter name.

At this stage, you do not need to use arrays or command-line arguments.

You only need to recognize the standard `main` method signature:

```java
public static void main(String[] args)
```

We will learn about `String`, arrays, and parameters in later lessons.

# Parentheses `( )`

Parentheses appear after a method name:

```java
main(...)
```

In our case:

```java
main(String[] args)
```

Parentheses can contain a method's input or parameter declaration.

Parentheses are also used when calling a method:

```java
println(...)
```

This concept will become clearer when we learn methods.

# Method Body

The instructions of the `main` method are placed inside curly braces:

```java
public static void main(String[] args) {

}
```

Our method body is:

```java
{
    System.out.println("Hello Java");
}
```

When the program executes, the statements inside the body run.

# What Is a Statement?

Look at this line:

```java
System.out.println("Hello Java");
```

This is a **statement**.

A statement is a complete instruction in a program.

Some other examples of statements are:

```java
int age = 30;
```

```java
int total = 10 + 20;
```

We will learn about these in later lessons.

For now, our statement:

```java
System.out.println("Hello Java");
```

displays a message in the console.

# Semicolon `;`

At the end of the statement, we have:

```text
;
```

Complete statement:

```java
System.out.println("Hello Java");
```

Simple Java statements generally end with a semicolon.

Wrong:

```java
System.out.println("Hello Java")
```

Correct:

```java
System.out.println("Hello Java");
```

If the semicolon is missing, a compilation error will occur.

# `System.out.println()`

```java
System.out.println("Hello Java");
```

This statement sends output to the console.

Output:

```text
Hello Java
```

At a high level, you can think of it as three parts:

```text
System
    ↓
out
    ↓
println(...)
```

Now let's look at the basic meaning of each part.

## `System`

```java
System
```

is a class in the Java standard library.

## `out`

```java
System.out
```

represents standard output.

In our examples, the output appears in the console.

## `println`

```java
println(...)
```

is a method that prints a value and then moves to a new line.

Example:

```java
System.out.println("Java");
System.out.println("Foundation");
```

Output:

```text
Java
Foundation
```

# `"Hello Java"`

```java
"Hello Java"
```

is a text value.

In Java, text written inside double quotes is called a **String literal**.

Examples:

```java
"Java"
```

```java
"Hello Java"
```

```java
"Java and OOP Foundation"
```

If you remove the double quotes, Java will not treat it as text.

Wrong:

```java
System.out.println(Hello Java);
```

Correct:

```java
System.out.println("Hello Java");
```

# What Is the Dot `.` Doing?

In this expression:

```java
System.out.println
```

the dot is used to access one member from another.

Conceptually:

```text
System
└── out
    └── println()
```

You will see this kind of member access many times in Java code.

For now, just recognize the syntax. Its meaning will become clearer after we learn about objects and methods.

# Java Is Case-Sensitive

Java treats uppercase and lowercase letters as different.

Correct:

```java
System.out.println("Hello");
```

Wrong:

```java
system.out.println("Hello");
```

Wrong:

```java
System.Out.Println("Hello");
```

because:

```text
System ≠ system
out ≠ Out
println ≠ Println
```

Similarly:

```text
Main
```

and:

```text
main
```

are not the same identifier.

# Indentation

The Java compiler does not determine program structure from indentation, but indentation is extremely important for readable code.

Recommended:

```java
public class Main {

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

Avoid writing code like this:

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

The second version may compile, but it is difficult to read.

# Execution Order

Look at the following program:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Step 1");
        System.out.println("Step 2");
        System.out.println("Step 3");
    }
}
```

Statements inside the `main` method generally execute from top to bottom.

Output:

```text
Step 1
Step 2
Step 3
```

If the order of the statements changes, the order of the output will also change.

# Complete Program Breakdown

Let's look at the complete program again:

```java
public class Main {

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

| Code            | Meaning                                                           |
| --------------- | ----------------------------------------------------------------- |
| `public`        | Access modifier                                                   |
| `class`         | Keyword used to declare a class                                   |
| `Main`          | Class name                                                        |
| `{ }`           | Code block                                                        |
| `static`        | Makes the class-level method available without creating an object |
| `void`          | The method does not return a value                                |
| `main`          | Application entry method                                          |
| `String[] args` | Parameter used to receive command-line arguments                  |
| `System`        | Java standard library class                                       |
| `out`           | Standard output                                                   |
| `println`       | Method used to print output                                       |
| `"Hello Java"`  | String literal                                                    |
| `;`             | Statement terminator                                              |

# Common Structural Errors

## Missing Semicolon

Wrong:

```java
System.out.println("Hello Java")
```

Correct:

```java
System.out.println("Hello Java");
```

## Missing Quote

Wrong:

```java
System.out.println("Hello Java);
```

Correct:

```java
System.out.println("Hello Java");
```

## Missing Brace

Wrong:

```java
public class Main {

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

Correct:

```java
public class Main {

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

## Wrong Capitalization

Wrong:

```java
system.out.println("Hello Java");
```

Correct:

```java
System.out.println("Hello Java");
```

## Incorrect `main` Name

Wrong:

```java
public static void Main(String[] args) {
}
```

Correct:

```java
public static void main(String[] args) {
}
```

Java is case-sensitive.

# An Important Point

Not every Java class needs a `main` method.

Example:

```java
public class Student {
}
```

This is a valid class.

A `main` method is needed only in a class that we want to use as an application entry point.

A large application may contain many classes, but not all classes are application entry points.

# Important Terms

### Class

A structure used to organize Java code and related data or behavior.

### Class Declaration

The syntax used to define a class.

```java
public class Main {
}
```

### Keyword

A reserved word in the Java language.

Examples:

```text
public
class
static
void
```

### Method

A named block that contains instructions.

### `main` Method

The entry point of a basic Java application.

### Statement

A complete instruction in a program.

### Code Block

Code contained inside curly braces `{ }`.

### String Literal

A text value written inside double quotes.

### Semicolon

Indicates the end of a simple statement.

### Standard Output

The normal output destination of a program. In our examples, this is the console.

# Practice Exercise 1: Identify the Parts of the Program

Look at the following program:

```java
public class CourseApplication {

    public static void main(String[] args) {
        System.out.println("Course started");
    }
}
```

Identify:

1. Class name
2. `class` keyword
3. Method name
4. Return type
5. Parameter
6. Output statement
7. String literal
8. Statement terminator

# Practice Exercise 2: Predict the Output

Before running the program, write the expected output:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Java");
        System.out.println("OOP");
        System.out.println("Foundation");
    }
}
```

# Practice Exercise 3: Fix the Error

Fix the following program:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("Java")
        System.out.println("Foundation");
    }
}
```

Expected output:

```text
Java
Foundation
```

# Practice Exercise 4: Fix the Brace Structure

Fix the following code:

```java
public class Main {

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

# Practice Exercise 5: Write Your Own Program

Create the following output:

```text
Course: Java and OOP Foundation
Java Version: 21
Status: Learning Java
```

Write a complete Java program using a `Main` class and a `main` method.

# Knowledge Check

## Question 1

What is a Java class?

## Question 2

What does the `class` keyword do?

## Question 3

If the name of a public class is `Main`, what should the source file be named?

## Question 4

Which method is the entry point of a basic Java application?

## Question 5

What do you need to remember about `static` at this stage?

## Question 6

What does `void` mean?

## Question 7

What is `String[] args` used for?

## Question 8

What is a statement?

## Question 9

Which symbol generally ends a simple Java statement?

## Question 10

What does `System.out.println()` do?

## Question 11

What does it mean that Java is case-sensitive?

## Question 12

Does every Java class need a `main` method?

# Knowledge Check Answers

## Answer 1

A class is a fundamental structure used to organize Java code and related data or behavior.

## Answer 2

The `class` keyword is used to declare a class.

## Answer 3

The source file should be named:

```text
Main.java
```

## Answer 4

A basic Java application usually begins execution from:

```java
public static void main(String[] args)
```

## Answer 5

Because `main` is `static`, an object of the `Main` class does not need to be created before the `main` method can run.

## Answer 6

`void` means that the method does not return a value.

## Answer 7

`String[] args` is a parameter used to receive command-line arguments.

## Answer 8

A statement is a complete instruction in a program.

## Answer 9

A simple statement generally ends with a semicolon:

```text
;
```

## Answer 10

`System.out.println()` prints a value to the console and moves to a new line afterward.

## Answer 11

Java treats uppercase and lowercase letters as different.

For example:

```text
Main
main
```

are not the same identifier.

## Answer 12

No. Only a suitable entry point is needed to start application execution. Other classes do not need to contain a `main` method.

# Lesson Summary

In this lesson, we learned:

* Java code is generally organized inside classes
* The `class` keyword declares a class
* The name of a public class and its source file must match
* Curly braces define class and method bodies
* A basic Java application begins execution from the `main` method
* Because `main` is `static`, an object does not need to be created before it runs
* `void` means that a method does not return a value
* `String[] args` is a parameter for receiving command-line arguments
* A statement is a complete instruction
* Simple statements generally end with a semicolon
* `System.out.println()` displays output in the console
* String literals are written inside double quotes
* Java is case-sensitive
* Statements inside a method generally execute from top to bottom

Understanding the First Java Program

Java Syntax and Coding Conventions

## Lesson Overview

While a program is running, it needs to store and use different types of data.

For example:

* Student name
* User age
* Course duration
* Product price
* Result of a calculation
* Whether a feature is enabled

In Java, we use **variables** to store these kinds of values.

A variable's value can be changed. However, some values should not change once they have been assigned. In those cases, `final` can be used.

In this lesson, we will learn:

* What a variable is
* Declaration and initialization
* Assignment and reassignment
* Variable type
* Local variables
* The basic concept of variable scope
* `final`
* Constants
* `var`

## Learning Objectives

After completing this lesson, you will be able to:

* Declare and initialize Java variables
* Assign and update variable values
* Distinguish between declaration, initialization, and assignment
* Understand the role of a variable's type
* Use local variables
* Understand basic scope
* Create `final` variables
* Recognize constant naming conventions
* Understand the basic use of `var`

# What Is a Variable?

A variable is a named location in a program where a value is stored.

Example:

```java
int age = 30;
```

Here:

* `int` — data type
* `age` — variable name
* `30` — value

The variable's value can be used later:

```java
int age = 30;

System.out.println(age);
```

Output:

```text
30
```

# Why Do We Need Variables?

Suppose the same course name needs to be used in several places.

Without a variable:

```java
System.out.println("Java and OOP Foundation");
System.out.println("Java and OOP Foundation");
```

Using a variable:

```java
String courseName = "Java and OOP Foundation";

System.out.println(courseName);
System.out.println(courseName);
```

Variables make code:

* More readable
* Able to reuse values
* Easier to use in calculations
* Able to track changing state

# Variable Declaration

A variable declaration tells the compiler the variable's type and name.

Syntax:

```java
dataType variableName;
```

Example:

```java
int age;
```

More examples:

```java
String studentName;
double coursePrice;
boolean isAvailable;
```

The variables have been declared, but no initial value has been assigned yet.

# Variable Initialization

Giving a variable its first value is called **initialization**.

```java
int age = 30;
```

Here, declaration and initialization happen in the same statement.

More examples:

```java
String studentName = "Sakib";
double coursePrice = 4990.0;
boolean isAvailable = true;
```

# Declaration and Assignment Separately

A variable can be declared first and assigned a value later.

```java
int age;

age = 30;
```

Here:

```java
int age;
```

is the declaration.

And:

```java
age = 30;
```

is the assignment.

# Declaration, Initialization, and Assignment

It is important to distinguish between these terms.

### Declaration

Defining the variable's type and name:

```java
int age;
```

### Initialization

Giving the variable its first value:

```java
int age = 30;
```

### Assignment

Putting a value into a variable:

```java
age = 30;
```

# Reassignment

The value of a normal variable can be changed later.

```java
int age = 30;

age = 31;

System.out.println(age);
```

Output:

```text
31
```

The new value replaces the old value.

# Assignment Operator `=`

In Java:

```text
=
```

is the assignment operator.

```java
int total = 10 + 20;
```

Here, first:

```text
10 + 20
```

is evaluated.

Result:

```text
30
```

Then the value is assigned to the `total` variable.

## Assignment and Equality Are Not the Same

Assignment:

```java
age = 18;
```

means the value `18` is stored in `age`.

For comparison, we will later use:

```java
age == 18
```

`=` and `==` are different operators.

# Using Variable Values

```java
int firstNumber = 10;
int secondNumber = 20;

int total = firstNumber + secondNumber;

System.out.println(total);
```

Output:

```text
30
```

Here, the stored values of `firstNumber` and `secondNumber` are used in the calculation.

# Variable Type

Java is a statically typed language.

Once a variable's type is determined, it can only store compatible values.

```java
int age = 30;
```

Here, `age` is an `int` variable.

Invalid:

```java
int age = "thirty";
```

because `"thirty"` is text, while `age` was declared to store an integer.

After a variable is declared, its type cannot be changed.

# Some Common Types

At this stage, we will use only a few types as examples:

```java
int age = 30;
double price = 99.50;
boolean isAvailable = true;
char grade = 'A';
String courseName = "Java Foundation";
```

| Type      | Example             |
| --------- | ------------------- |
| `int`     | `30`                |
| `double`  | `99.50`             |
| `boolean` | `true`              |
| `char`    | `'A'`               |
| `String`  | `"Java Foundation"` |

We will learn Java data types in detail in the next lesson.

# Meaningful Variable Names

A variable name should express the meaning of the value it stores.

Poor:

```java
int x = 30;
```

Better:

```java
int studentAge = 30;
```

Poor:

```java
double p = 4990.0;
```

Better:

```java
double coursePrice = 4990.0;
```

Variables generally follow the `camelCase` naming convention:

```text
studentName
coursePrice
totalMarks
isAvailable
```

## Boolean Variable Names

A boolean variable should preferably have a name that expresses a true or false condition.

Good:

```java
boolean isActive;
boolean hasPermission;
boolean canEnroll;
boolean paymentCompleted;
```

Less clear:

```java
boolean flag;
boolean status;
boolean value;
```

# Using Variables in Output

```java
public class Main {

    public static void main(String[] args) {
        String courseName = "Java and OOP Foundation";
        int durationInWeeks = 8;
        boolean isAvailable = true;

        System.out.println("Course: " + courseName);
        System.out.println("Duration: " + durationInWeeks);
        System.out.println("Available: " + isAvailable);
    }
}
```

Output:

```text
Course: Java and OOP Foundation
Duration: 8
Available: true
```

# Updating a Variable

You can use a variable's current value to assign a new value.

```java
int score = 10;

score = score + 5;

System.out.println(score);
```

Output:

```text
15
```

Step by step:

```text
score = 10
score = 10 + 5
score = 15
```

# Duplicate Declaration

The same variable cannot be declared twice in the same scope.

Wrong:

```java
int age = 30;
int age = 31;
```

If you want to change the value of an existing variable:

```java
int age = 30;

age = 31;
```

The first statement is the declaration.

The second statement is reassignment.

# Local Variable

A variable declared inside a method is called a **local variable**.

```java
public class Main {

    public static void main(String[] args) {
        String studentName = "Sakib";
        int age = 20;

        System.out.println(studentName);
        System.out.println(age);
    }
}
```

Here:

```text
studentName
age
```

are local variables.

# Local Variables Must Be Initialized

A local variable must be assigned a value before it is read.

Wrong:

```java
int age;

System.out.println(age);
```

The compiler will not allow this.

Correct:

```java
int age = 30;

System.out.println(age);
```

or:

```java
int age;

age = 30;

System.out.println(age);
```

# Variable Scope

Scope determines which parts of the code can access a variable.

```java
public class Main {

    public static void main(String[] args) {
        int age = 30;

        System.out.println(age);
    }
}
```

The `age` variable is available inside the block of the `main` method.

This local variable cannot be used outside the `main` method.

## Nested Block

An inner block can use accessible variables from an outer block.

```java
public class Main {

    public static void main(String[] args) {
        int age = 20;

        {
            System.out.println(age);
        }
    }
}
```

However, a variable declared inside an inner block is no longer available after that block ends.

```java
public class Main {

    public static void main(String[] args) {
        {
            String message = "Hello";
            System.out.println(message);
        }

        // message is not accessible here
    }
}
```

At this stage, remember:

> Keeping a variable within the smallest necessary scope makes code easier to understand.

# The `final` Keyword

If you do not want a variable's value to be changed after assignment, you can use `final`.

```java
final int courseDurationInWeeks = 8;
```

Now reassignment is invalid:

```java
courseDurationInWeeks = 10;
```

This will cause a compiler error.

## A `final` Variable Can Be Assigned Later

A local `final` variable can be declared without a value and assigned once later.

```java
final int minimumAge;

minimumAge = 18;
```

After that, it cannot be assigned again.

# Variable vs. Fixed Value

Changing value:

```java
int enrolledStudentCount = 75;

enrolledStudentCount = 76;
```

Fixed value:

```java
final int maximumStudentCapacity = 100;
```

Difference:

```text
enrolledStudentCount     → can change
maximumStudentCapacity   → should not change
```

# Constant

A class-level constant is used for a reusable fixed value in an application.

Example:

```java
public class Main {

    static final int MAXIMUM_STUDENT_CAPACITY = 100;

    public static void main(String[] args) {
        System.out.println(MAXIMUM_STUDENT_CAPACITY);
    }
}
```

Constants generally follow:

```text
UPPER_SNAKE_CASE
```

Examples:

```java
MAXIMUM_STUDENT_CAPACITY
DEFAULT_LANGUAGE
MAXIMUM_LOGIN_ATTEMPTS
```

We will learn more about `static` and class members later.

For now, recognize this pattern:

```java
static final int MAXIMUM_STUDENT_CAPACITY = 100;
```

# Not Every `final` Variable Is a Constant

Local final variable:

```java
final int durationInWeeks = 8;
```

Class-level reusable constant:

```java
static final int COURSE_DURATION_IN_WEEKS = 8;
```

Neither can be reassigned, but their purpose in a codebase may be different.

# Multiple Variable Declaration

Java allows multiple variables of the same type to be declared in one statement.

```java
int firstNumber = 10, secondNumber = 20;
```

However, separate declarations are preferred for readability:

```java
int firstNumber = 10;
int secondNumber = 20;
```

One variable per line is generally clearer.

# `var`

In Java 21, `var` can be used to let the compiler infer the type of a local variable.

```java
var age = 30;
var courseName = "Java Foundation";
var isAvailable = true;
```

The compiler determines the type from the assigned value.

Conceptually:

```java
var age = 30;
```

Here, the inferred type of `age` is `int`.

# `var` Does Not Make Java Dynamically Typed

```java
var age = 30;
```

After its type is inferred, `age` is an `int` variable.

Therefore:

```java
age = "thirty";
```

is not valid.

Java remains statically typed.

# `var` Requires an Initial Value

Wrong:

```java
var age;
```

The compiler cannot infer the type.

Correct:

```java
var age = 30;
```

# When Should You Use `var`?

When you are beginning to learn Java, using explicit types is more useful:

```java
int age = 30;
String courseName = "Java Foundation";
boolean isAvailable = true;
```

This helps build an understanding of types.

Use `var` when the inferred type is clear from the code and readability is not reduced.

At the beginning of this course, we will use explicit types in most examples.

# Common Variable Errors

## Undeclared Variable

Wrong:

```java
System.out.println(courseName);
```

If `courseName` has not been declared earlier, this will cause a compiler error.

Correct:

```java
String courseName = "Java Foundation";

System.out.println(courseName);
```

## Uninitialized Local Variable

Wrong:

```java
int age;

System.out.println(age);
```

Correct:

```java
int age = 30;

System.out.println(age);
```

## Type Mismatch

Wrong:

```java
int age = "30";
```

Correct:

```java
int age = 30;
```

## Duplicate Declaration

Wrong:

```java
int age = 30;
int age = 31;
```

Correct:

```java
int age = 30;

age = 31;
```

## Reassigning a `final` Variable

Wrong:

```java
final int durationInWeeks = 8;

durationInWeeks = 10;
```

A `final` variable cannot be reassigned.

## `var` Without Initialization

Wrong:

```java
var courseName;
```

Correct:

```java
var courseName = "Java Foundation";
```

# A Complete Example

```java
public class Main {

    static final int MAXIMUM_STUDENT_CAPACITY = 100;

    public static void main(String[] args) {
        String courseName = "Java and OOP Foundation";
        int enrolledStudentCount = 75;
        boolean enrollmentOpen = true;

        enrolledStudentCount = 76;

        System.out.println("Course: " + courseName);
        System.out.println("Enrolled students: " + enrolledStudentCount);
        System.out.println("Maximum capacity: " + MAXIMUM_STUDENT_CAPACITY);
        System.out.println("Enrollment open: " + enrollmentOpen);
    }
}
```

Output:

```text
Course: Java and OOP Foundation
Enrolled students: 76
Maximum capacity: 100
Enrollment open: true
```

In this program:

* `courseName` is a normal variable
* `enrolledStudentCount` is reassigned
* `enrollmentOpen` stores a boolean value
* `MAXIMUM_STUDENT_CAPACITY` is a fixed constant

# Important Terms

### Variable

A named location where a value is stored.

### Data Type

Determines what kind of value a variable can store.

### Declaration

Defining a variable's type and name.

```java
int age;
```

### Initialization

Giving a variable its first value.

```java
int age = 30;
```

### Assignment

Putting a value into a variable.

```java
age = 30;
```

### Reassignment

Replacing an existing value with a new value.

```java
age = 31;
```

### Local Variable

A variable declared inside a method or block.

### Scope

The region of code from which a variable is accessible.

### `final`

Prevents a variable from being reassigned.

### Constant

A reusable fixed value.

### `var`

Allows the compiler to infer the type of a local variable.

# Practice Exercise 1: Statement Breakdown

Look at the following statement:

```java
int studentAge = 20;
```

Identify:

1. Data type
2. Variable name
3. Assignment operator
4. Initial value
5. Statement terminator

# Practice Exercise 2: Declaration, Initialization, or Assignment?

Identify each statement:

```java
int age;
```

```java
int score = 80;
```

```java
age = 30;
```

# Practice Exercise 3: Create Variables

Write appropriate variables for the following information:

1. Student name
2. Student age
3. Course duration
4. Whether the course is available
5. Student grade

Use meaningful `camelCase` names.

# Practice Exercise 4: Predict the Output

```java
public class Main {

    public static void main(String[] args) {
        int score = 10;

        score = score + 5;
        score = score * 2;

        System.out.println(score);
    }
}
```

Write the final output before running the program.

# Practice Exercise 5: Fix the Errors

```java
public class Main {

    public static void main(String[] args) {
        int studentAge;

        studentAge = "20";

        System.out.println(studentAge);
    }
}
```

Expected output:

```text
20
```

# Practice Exercise 6: `final`

Create a `final` variable:

```text
courseDurationInWeeks = 8
```

Then explain why the following assignment will not compile:

```java
courseDurationInWeeks = 10;
```

# Practice Exercise 7: `var`

Rewrite the following explicit declarations using `var`:

```java
int age = 30;
String courseName = "Java Foundation";
boolean isAvailable = true;
```

Write the inferred type of each variable.

# Knowledge Check

## Question 1

What is a variable?

## Question 2

What is the difference between declaration and initialization?

## Question 3

Which operator is the assignment operator?

## Question 4

What is reassignment?

## Question 5

Can a variable's type be changed after it has been declared?

## Question 6

What is a local variable?

## Question 7

Can an uninitialized local variable be read?

## Question 8

What is scope?

## Question 9

What does `final` do?

## Question 10

What is the common naming convention for constants?

## Question 11

What does `var` do?

## Question 12

Does using `var` make Java dynamically typed?

# Knowledge Check Answers

## Answer 1

A variable is a named location in a program where a value is stored.

## Answer 2

Declaration defines a variable's type and name. Initialization gives the variable its first value.

## Answer 3

The assignment operator is:

```text
=
```

## Answer 4

Reassignment means replacing an existing value with a new value.

## Answer 5

No. A variable's type cannot be changed after it has been declared.

## Answer 6

A variable declared inside a method or block is a local variable.

## Answer 7

No. A local variable must be initialized before it is read.

## Answer 8

Scope determines which parts of the code can access a variable.

## Answer 9

`final` prevents a variable from being reassigned.

## Answer 10

Constants generally follow:

```text
UPPER_SNAKE_CASE
```

## Answer 11

`var` allows the compiler to infer the type of a local variable from its assigned value.

## Answer 12

No. After the inferred type is determined, the variable remains statically typed.

# Lesson Summary

In this lesson, we learned:

* Variables store data in a program
* Declaration defines a variable's type and name
* Initialization gives a variable its first value
* The assignment operator `=` assigns a value
* Normal variables can be reassigned
* Java variables are statically typed
* Meaningful variable names make code more readable
* Variables generally follow camelCase
* Local variables are declared inside methods or blocks
* Local variables must be initialized before they are used
* Scope determines where a variable is accessible
* `final` prevents reassignment
* Reusable constants generally follow `UPPER_SNAKE_CASE`
* `var` allows local variable type inference
* Java remains statically typed when `var` is used

Variables and Constants

## Lesson Overview

In Java, every variable stores a specific type of value.

For example:

* Whole numbers
* Decimal numbers
* A character
* `true` or `false`

To represent these basic values, Java provides eight **primitive data types**:

* `byte`
* `short`
* `int`
* `long`
* `float`
* `double`
* `char`
* `boolean`

In this lesson, we will understand each primitive type, its range, literal syntax, and practical use.

## Learning Objectives

After completing this lesson, you will be able to:

* Explain what a primitive data type is
* Identify Java's eight primitive types
* Select an appropriate integer type for whole numbers
* Understand the difference between `float` and `double`
* Use `char` and `boolean`
* Understand why `L` and `F` suffixes are needed
* Use underscores in numeric literals
* Understand the basic concept of integer overflow
* Explain floating-point precision limitations
* Select the appropriate primitive type based on the requirement

# What Is a Data Type?

A data type determines what kind of value a variable can store.

Example:

```java
int age = 30;
```

Here, `int` indicates that `age` will store an integer value.

```java
double averageMark = 85.5;
```

Here, `double` stores a decimal value.

```java
boolean isAvailable = true;
```

Here, `boolean` stores a logical state.

# What Is a Primitive Data Type?

A primitive data type is a built-in fundamental type in the Java language.

Primitive types are not objects; they represent basic values.

```java
int age = 30;
char grade = 'A';
boolean isPassed = true;
```

Java's eight primitive types can be divided into four categories:

| Category       | Types                          |
| -------------- | ------------------------------ |
| Integer        | `byte`, `short`, `int`, `long` |
| Floating-point | `float`, `double`              |
| Character      | `char`                         |
| Boolean        | `boolean`                      |

# Primitive Types at a Glance

| Type      |    Size | Example          | Common Use                         |
| --------- | ------: | ---------------- | ---------------------------------- |
| `byte`    |  8 bits | `100`            | Very small integers or binary data |
| `short`   | 16 bits | `1200`           | Small integers                     |
| `int`     | 32 bits | `5000`           | General whole numbers              |
| `long`    | 64 bits | `8_000_000_000L` | Large whole numbers                |
| `float`   | 32 bits | `10.5F`          | Lower-precision decimals           |
| `double`  | 64 bits | `10.5`           | General decimal calculations       |
| `char`    | 16 bits | `'A'`            | A single UTF-16 code unit          |
| `boolean` |       — | `true`           | True/false state                   |

The Java language does not define a fixed storage size for `boolean`, so there is no need to memorize a specific bit size for it.

# Integer Types

Java's integer primitive types are:

```text
byte
short
int
long
```

These types store whole numbers without a decimal part.

Examples:

```text
-20
0
25
1000
5000000
```

# `byte`

`byte` is an 8-bit signed integer.

Range:

```text
-128 to 127
```

Example:

```java
byte percentage = 100;
byte temperature = -10;
```

A value outside this range cannot be stored directly:

```java
byte value = 128;
```

This will not compile.

## When Should You Use `byte`?

`byte` is not commonly needed for general application data.

It can be useful for:

* Raw binary data
* File or network bytes
* Memory-sensitive large arrays
* External formats that require 8-bit values

# `short`

`short` is a 16-bit signed integer.

Range:

```text
-32,768 to 32,767
```

Example:

```java
short roomNumber = 1200;
short maximumScore = 30000;
```

`short` is also not commonly used in general Java applications.

# `int`

`int` is a 32-bit signed integer.

Range:

```text
-2,147,483,648
to
2,147,483,647
```

For general whole numbers, `int` is the most common choice in Java.

```java
int age = 30;
int studentCount = 500;
int lessonCount = 120;
int quantity = 5;
```

## When Should You Use `int`?

In general, `int` can be used for values such as:

* Age
* Quantity
* Marks
* Retry count
* Page number
* Lesson count
* Inventory count
* General counters

# `long`

`long` is a 64-bit signed integer.

Range:

```text
-9,223,372,036,854,775,808
to
9,223,372,036,854,775,807
```

Use `long` for whole numbers that are larger than the `int` range.

```java
long totalUsers = 5_000_000_000L;
long fileSizeInBytes = 8_000_000_000L;
```

## `L` Suffix

Use an uppercase `L` at the end of large `long` literals:

```java
long population = 8_000_000_000L;
```

`L` tells the compiler that the literal is a `long`.

Although lowercase `l` is technically allowed, avoid it:

```java
long value = 100l;
```

It can look similar to the digit `1`.

Preferred:

```java
long value = 100L;
```

# Choosing an Integer Type

Practical rule:

* General whole number → `int`
* If the `int` range is not enough → `long`
* `byte` or `short` → only when there is a specific reason

Example:

```java
int studentAge = 20;
int lessonCount = 120;
long totalPlatformUsers = 5_000_000_000L;
```

# Underscores in Numeric Literals

Underscores can be used between digits to make large numbers easier to read.

```java
int oneMillion = 1_000_000;
long population = 8_000_000_000L;
```

The compiler ignores these underscores.

```java
int value = 1_000;
```

and:

```java
int value = 1000;
```

represent the same value.

# Integer Division

When two integers are divided, the result follows integer arithmetic.

```java
int result = 5 / 2;

System.out.println(result);
```

Output:

```text
2
```

Not `2.5`.

To get a decimal result, at least one operand must be floating-point:

```java
double result = 5.0 / 2;

System.out.println(result);
```

Output:

```text
2.5
```

# Integer Overflow

If the result exceeds the maximum range of an integer type, overflow can occur.

```java
int value = 2_147_483_647;

value = value + 1;

System.out.println(value);
```

Output:

```text
-2147483648
```

The value wraps after reaching the maximum.

This is important because Java integer overflow does not always produce an exception.

When working with large values, you should understand the range of the selected type.

## Literal Type Also Matters

Consider this calculation:

```java
long total = 2_000_000_000 + 1_000_000_000;
```

Even though the result variable is `long`, the addition can first be performed using `int` arithmetic.

Safer:

```java
long total = 2_000_000_000L + 1_000_000_000L;
```

Now the calculation uses the `long` range.

# Floating-Point Types

Java provides two primitive types for decimal or fractional values:

* `float`
* `double`

# `float`

`float` is a 32-bit floating-point type.

Its approximate precision is generally 6–7 significant decimal digits.

Example:

```java
float temperature = 36.5F;
```

Decimal literals are `double` by default, so a `float` literal needs an `F` suffix.

Correct:

```java
float temperature = 36.5F;
```

Invalid:

```java
float temperature = 36.5;
```

# `double`

`double` is a 64-bit floating-point type.

It provides more precision than `float` and is more commonly used for general decimal calculations in Java.

```java
double averageMark = 85.75;
double temperature = 36.5;
double distance = 12.75;
```

Decimal literals are `double` by default, so no suffix is required.

# `float` or `double`?

| Type     |    Size |    Approximate Precision |
| -------- | ------: | -----------------------: |
| `float`  | 32 bits |   6–7 significant digits |
| `double` | 64 bits | 15–16 significant digits |

General rule:

> Use `double` for general decimal calculations.

`float` is useful when 32-bit floating-point is specifically required or memory usage is important.

# Floating-Point Precision

`float` and `double` represent decimal values using binary floating-point format.

Not every decimal number can be represented exactly in binary.

Example:

```java
double result = 0.1 + 0.2;

System.out.println(result);
```

Output may be:

```text
0.30000000000000004
```

This is not a Java bug.

It is a limitation of floating-point representation.

# Why Should We Avoid `double` for Money?

For exact values such as money, floating-point approximation can create problems.

Risky:

```java
double amount = 0.1 + 0.2;
```

In this course, we will represent monetary values exactly using integer **minor units**.

Example:

```java
long priceInPaisa = 499_050L;
```

If:

```text
100 paisa = 1 BDT
```

then:

```text
499,050 paisa = BDT 4,990.50
```

Similarly, for a cent-based currency:

```java
long priceCents = 4_990L;
```

It is important to make the monetary unit clear in the variable name.

# `char`

`char` represents a single UTF-16 code unit.

The literal is written inside single quotes:

```java
char grade = 'A';
char symbol = '#';
char banglaLetter = 'ক';
```

Single character:

```java
'A'
```

String:

```java
"Java"
```

These are not the same.

## `char` and `String`

```java
char firstLetter = 'J';
String language = "Java";
```

A `char` stores one code unit.

A `String` represents a sequence of text and is not a primitive type.

This distinction will become clearer in the later String lesson.

## Invalid `char`

Wrong:

```java
char language = 'Java';
```

Correct:

```java
char firstLetter = 'J';
```

or:

```java
String language = "Java";
```

# `boolean`

`boolean` represents a logical state.

Its possible values are:

```text
true
false
```

Example:

```java
boolean isAvailable = true;
boolean paymentCompleted = false;
boolean hasPermission = true;
```

In Java, a number cannot be used as a boolean.

Invalid:

```java
boolean isActive = 1;
```

Correct:

```java
boolean isActive = true;
```

Similarly:

```java
boolean isActive = "true";
```

is invalid because `"true"` is a `String`.

# Boolean Variable Naming

Boolean variable names should make the condition clear.

Good:

```java
boolean isActive;
boolean isAvailable;
boolean hasPermission;
boolean canEnroll;
boolean paymentCompleted;
```

Less clear:

```java
boolean flag;
boolean value;
boolean status;
```

# Primitive and Reference Types

A primitive type represents a basic value:

```java
int age = 30;
double average = 85.5;
char grade = 'A';
boolean passed = true;
```

`String` is not a primitive type.

```java
String studentName = "Sakib";
```

`String` is a reference type.

For now, remember this distinction:

```text
Primitive → basic value
Reference type → object/reference-based value
```

We will understand reference types in more detail when we learn object-oriented programming.

# Choosing the Correct Data Type

When choosing a data type, consider the nature of the value and its possible range.

## Student Age

```java
int age = 20;
```

Even though the value would fit inside a `byte`, `int` is generally more practical for normal application code.

## Lesson Count

```java
int lessonCount = 50;
```

## Large User Count

```java
long userCount = 5_000_000_000L;
```

## Average Mark

```java
double averageMark = 85.67;
```

## Grade

```java
char grade = 'A';
```

## Availability

```java
boolean isAvailable = true;
```

## Exact Money

```java
long priceCents = 499_000L;
```

or another minor unit depending on the currency:

```java
long priceInPaisa = 499_000L;
```

# Primitive Type Selection Guide

| Requirement                         | Suggested Type     |
| ----------------------------------- | ------------------ |
| General whole number                | `int`              |
| Very large whole number             | `long`             |
| General decimal calculation         | `double`           |
| 32-bit approximate decimal required | `float`            |
| Single UTF-16 code unit             | `char`             |
| True/false state                    | `boolean`          |
| Exact monetary value                | `long` minor units |
| Raw 8-bit binary value              | `byte`             |

# Common Errors

## Value Outside the `byte` Range

Wrong:

```java
byte value = 200;
```

Better:

```java
int value = 200;
```

## Missing `L` in a `long` Literal

Wrong:

```java
long population = 8_000_000_000;
```

Correct:

```java
long population = 8_000_000_000L;
```

## Missing `F` in a `float` Literal

Wrong:

```java
float temperature = 36.5;
```

Correct:

```java
float temperature = 36.5F;
```

## Integer Division

```java
double result = 5 / 2;
```

Result:

```text
2.0
```

because `5 / 2` performs integer division first.

Correct:

```java
double result = 5.0 / 2;
```

Result:

```text
2.5
```

## Wrong Quotes for `char`

Wrong:

```java
char grade = "A";
```

Correct:

```java
char grade = 'A';
```

## Wrong Boolean Value

Wrong:

```java
boolean active = 1;
```

Correct:

```java
boolean active = true;
```

## Integer Overflow

Risky:

```java
int total = 2_000_000_000 + 1_000_000_000;
```

Use a wider type:

```java
long total = 2_000_000_000L + 1_000_000_000L;
```

# Complete Example

```java
public class Main {

    public static void main(String[] args) {
        String studentName = "Sakib";

        int mathematicsMark = 80;
        int englishMark = 90;
        int scienceMark = 85;

        int totalMarks =
                mathematicsMark
                + englishMark
                + scienceMark;

        double averageMark = totalMarks / 3.0;
        char grade = 'A';
        boolean isPassed = true;

        System.out.println("Student: " + studentName);
        System.out.println("Total: " + totalMarks);
        System.out.println("Average: " + averageMark);
        System.out.println("Grade: " + grade);
        System.out.println("Passed: " + isPassed);
    }
}
```

Output:

```text
Student: Sakib
Total: 255
Average: 85.0
Grade: A
Passed: true
```

In this program:

* Marks → `int`
* Average → `double`
* Grade → `char`
* Passed status → `boolean`
* Student name → `String`, which is not primitive

# Important Terms

### Primitive Data Type

A built-in fundamental Java type that represents a basic value.

### Integer

A whole number without a decimal part.

### Floating-Point

An approximate numeric type used to represent decimal or fractional values.

### Range

The minimum and maximum values a type can store.

### Precision

The number of significant digits a floating-point type can represent.

### Literal

A value written directly in source code.

```java
100
10.5
'A'
true
```

### Overflow

When a numeric result exceeds the maximum range of its type and wraps around.

### Integer Division

Division using integer operands where the fractional part is discarded.

### Floating-Point Precision

The approximation of some decimal values because of binary representation.

# Practice Exercise 1: Select the Type

Choose a suitable type for each value:

1. Student age
2. Course lesson count
3. 5 billion users
4. Average mark
5. Grade `A`
6. Whether a user is active
7. File size in bytes
8. Temperature
9. Maximum login attempts
10. A Bangla letter

# Practice Exercise 2: Literal Type

Write the usual type of each literal:

```java
100
100L
10.5
10.5F
'A'
true
```

# Practice Exercise 3: Find the Invalid Declarations

```java
byte age = 25;
byte value = 200;
int lessonCount = 120;
long population = 8_000_000_000L;
float temperature = 36.5F;
double average = 81.67;
char grade = "A";
boolean available = true;
boolean active = 1;
```

Correct the invalid declarations.

# Practice Exercise 4: Integer Division

Predict the output:

```java
int firstResult = 5 / 2;
double secondResult = 5 / 2;
double thirdResult = 5.0 / 2;

System.out.println(firstResult);
System.out.println(secondResult);
System.out.println(thirdResult);
```

# Practice Exercise 5: Prevent Overflow

Correct the following code:

```java
long total = 2_000_000_000 + 2_000_000_000;
```

Expected result:

```text
4000000000
```

# Practice Exercise 6: Represent Money

Course price:

```text
BDT 4,990.50
```

Assume:

```text
1 BDT = 100 paisa
```

Answer:

1. What is the value in paisa?
2. Which primitive type would you use?
3. What would be a meaningful variable name?

# Practice Exercise 7: Student Result

Write a program containing:

* Student name → `String`
* Mathematics mark → `int`
* English mark → `int`
* Science mark → `int`
* Total → `int`
* Average → `double`
* Grade → `char`
* Passed → `boolean`

You may use your own values.

# Knowledge Check

## Question 1

How many primitive data types are there in Java?

## Question 2

What are the eight primitive types?

## Question 3

What are the integer primitive types?

## Question 4

Which type is generally used for ordinary whole numbers?

## Question 5

Which type is used for whole numbers larger than the `int` range?

## Question 6

What suffix is used for a `long` literal?

## Question 7

What type is a decimal literal by default?

## Question 8

What suffix is used for a `float` literal?

## Question 9

Which is more common for general decimal calculations: `float` or `double`?

## Question 10

What is the result of `5 / 2`?

## Question 11

What is integer overflow?

## Question 12

Why might `0.1 + 0.2` not be exactly `0.3`?

## Question 13

What will we use in this course to represent exact monetary values?

## Question 14

Which quotation marks does `char` use?

## Question 15

What are the possible values of `boolean`?

## Question 16

Is `String` a primitive type?

# Knowledge Check Answers

## Answer 1

Java has eight primitive data types.

## Answer 2

```text
byte
short
int
long
float
double
char
boolean
```

## Answer 3

```text
byte
short
int
long
```

## Answer 4

`int` is generally used for ordinary whole numbers.

## Answer 5

`long` is used.

## Answer 6

```text
L
```

## Answer 7

A decimal literal is `double` by default.

## Answer 8

```text
F
```

## Answer 9

`double` is more common for general decimal calculations.

## Answer 10

```text
2
```

because this is integer division.

## Answer 11

Integer overflow occurs when a numeric result exceeds the maximum range of its integer type and wraps around.

## Answer 12

Because `double` uses binary floating-point representation, and not every decimal value can be represented exactly.

## Answer 13

We will use integer minor units, generally stored in a `long`, for exact monetary values.

## Answer 14

Single quotes:

```java
'A'
```

## Answer 15

```text
true
false
```

## Answer 16

No. `String` is a reference type.

# Lesson Summary

In this lesson, we learned:

* Java has eight primitive data types
* `byte`, `short`, `int`, and `long` store whole numbers
* `int` is the most common choice for general integers
* `long` is used for larger integers
* `L` is used at the end of `long` literals
* `float` and `double` represent decimal values
* Decimal literals are `double` by default
* `float` literals require an `F` suffix
* `double` is preferred for general decimal calculations
* Integer division discards the fractional part
* Integer overflow can produce incorrect values
* `float` and `double` represent approximate floating-point values
* Integer minor units should be used for exact monetary values
* `char` represents a single UTF-16 code unit
* `boolean` stores only `true` or `false`
* `String` is not a primitive type
* Choosing the correct data type is important for correctness and readability

Primitive Data Types

## Lesson Overview

Text data is used almost everywhere in software applications.

For example:

* User name
* Email address
* Course title
* Product description
* Error message
* Search query
* Notification

In Java, we use `String` to represent text.

```java
String courseName = "Java and OOP Foundation";
```

`String` is not a primitive data type. It is a class from the Java standard library.

In this lesson, we will learn:

* What `String` is
* String literals
* Empty, blank, and `null`
* String concatenation
* String length and character access
* Common String methods
* String comparison
* String immutability
* Escape sequences
* Text blocks
* The difference between `String` and `char`

## Learning Objectives

After completing this lesson, you will be able to:

* Create String variables
* Distinguish between empty, blank, and `null`
* Concatenate Strings
* Access String length and characters
* Use common String methods
* Compare String content using `.equals()`
* Understand what String immutability means
* Use escape sequences
* Use text blocks for multi-line text

# What Is `String`?

`String` represents text.

```java
String studentName = "Sakib";
String courseName = "Java Foundation";
String email = "hello@liveklass.io";
```

Here:

```java
String courseName = "Java Foundation";
```

* `String` — type
* `courseName` — variable name
* `"Java Foundation"` — String value

# `String` Is Not Primitive

Java's primitive types are:

```text
byte
short
int
long
float
double
char
boolean
```

`String` is not part of this list.

`String` is a class, and a `String` variable is a reference-type variable.

However, Java provides convenient syntax for String literals:

```java
"Java Foundation"
```

# String Literal

Text written inside double quotes is a String literal.

```java
"Java"
```

```java
"Welcome to LiveKlass"
```

```java
""
```

The last value is an empty String.

# String Variable

To declare a variable:

```java
String name;
```

To initialize it:

```java
String name = "Sakib";
```

or:

```java
String name;

name = "Sakib";
```

# Empty String

An empty String contains no characters.

```java
String value = "";
```

Length:

```java
System.out.println(value.length());
```

Output:

```text
0
```

# Blank String

A blank String can be empty or contain only whitespace.

Examples:

```java
""
```

```java
" "
```

```java
"   "
```

You can check this using Java's `isBlank()` method:

```java
String value = "   ";

System.out.println(value.isBlank());
```

Output:

```text
true
```

# Difference Between Empty and Blank

```java
String emptyValue = "";
String blankValue = "   ";
```

```java
System.out.println(emptyValue.isEmpty());
System.out.println(blankValue.isEmpty());
```

Output:

```text
true
false
```

But:

```java
System.out.println(emptyValue.isBlank());
System.out.println(blankValue.isBlank());
```

Output:

```text
true
true
```

Difference:

* `isEmpty()` → checks whether the length is `0`
* `isBlank()` → checks whether the String is empty or contains only whitespace

# `null`

`null` means that the variable currently does not reference a String object.

```java
String courseName = null;
```

This is not an empty String.

```java
String emptyValue = "";
String missingValue = null;
```

Difference:

```text
""   → A String exists, but it contains no characters
null → There is no String object reference
```

# Calling a Method on `null`

The following code will fail at runtime:

```java
String courseName = null;

System.out.println(courseName.length());
```

because `courseName` does not reference a String object.

This can cause a `NullPointerException`.

This is why understanding the difference between `null` and an empty String is important.

# String Concatenation

Combining multiple Strings is called concatenation.

In Java, the `+` operator can be used.

```java
String firstName = "Sakib";
String lastName = "Sami";

String fullName = firstName + " " + lastName;

System.out.println(fullName);
```

Output:

```text
Sakib Sami
```

# Concatenating Text and Other Values

```java
String courseName = "Java Foundation";
int durationInWeeks = 8;

System.out.println(
        "Course: " + courseName
        + ", Duration: " + durationInWeeks + " weeks"
);
```

Output:

```text
Course: Java Foundation, Duration: 8 weeks
```

# Concatenation and Calculation

Look at this code:

```java
System.out.println("Total: " + 10 + 20);
```

Output:

```text
Total: 1020
```

because evaluation happens from left to right:

```text
"Total: " + 10
→ "Total: 10"

"Total: 10" + 20
→ "Total: 1020"
```

Use parentheses if the calculation should happen first:

```java
System.out.println("Total: " + (10 + 20));
```

Output:

```text
Total: 30
```

# `length()`

To get the length of a String:

```java
String language = "Java";

System.out.println(language.length());
```

Output:

```text
4
```

For simple Latin text, you can think of this as the character count. Technically, Java's `String.length()` counts UTF-16 code units.

# String Index

String positions start from `0`.

```text
String: Java
Index:  0123
```

| Character | Index |
| --------- | ----: |
| `J`       |   `0` |
| `a`       |   `1` |
| `v`       |   `2` |
| `a`       |   `3` |

# `charAt()`

To get the character at a specific position:

```java
String language = "Java";

char firstCharacter = language.charAt(0);

System.out.println(firstCharacter);
```

Output:

```text
J
```

## Last Character

The last index is:

```text
length - 1
```

Example:

```java
String language = "Java";

char lastCharacter =
        language.charAt(language.length() - 1);

System.out.println(lastCharacter);
```

Output:

```text
a
```

## Invalid Index

```java
String language = "Java";

language.charAt(4);
```

This will fail at runtime.

The valid indexes are:

```text
0
1
2
3
```

# `substring()`

You can use `substring()` to extract part of a String.

```java
String value = "Java Foundation";

String language = value.substring(0, 4);

System.out.println(language);
```

Output:

```text
Java
```

Here:

* Start index `0` is included
* End index `4` is excluded

## From an Index to the End

```java
String value = "Java Foundation";

String secondPart = value.substring(5);

System.out.println(secondPart);
```

Output:

```text
Foundation
```

# `toUpperCase()` and `toLowerCase()`

```java
String language = "Java";

System.out.println(language.toUpperCase());
System.out.println(language.toLowerCase());
```

Output:

```text
JAVA
java
```

# `strip()`

To remove whitespace from the beginning and end of a String:

```java
String name = "   Sakib   ";

String cleanName = name.strip();

System.out.println(cleanName);
```

Output:

```text
Sakib
```

Whitespace in the middle is not removed.

```java
String name = "Sakib Sami";

System.out.println(name.strip());
```

Output:

```text
Sakib Sami
```

# `contains()`

Checks whether specific text exists inside a String.

```java
String courseName = "Java and OOP Foundation";

System.out.println(courseName.contains("OOP"));
```

Output:

```text
true
```

It is case-sensitive.

```java
System.out.println(courseName.contains("oop"));
```

Output:

```text
false
```

# `startsWith()` and `endsWith()`

```java
String courseName = "Java Foundation";

System.out.println(
        courseName.startsWith("Java")
);
```

Output:

```text
true
```

File name example:

```java
String fileName = "Main.java";

System.out.println(
        fileName.endsWith(".java")
);
```

Output:

```text
true
```

# `replace()`

To replace text in a String:

```java
String message = "I am learning Python";

String updatedMessage =
        message.replace("Python", "Java");

System.out.println(updatedMessage);
```

Output:

```text
I am learning Java
```

# Common String Methods

| Method          | Purpose                                               |
| --------------- | ----------------------------------------------------- |
| `length()`      | Returns the length                                    |
| `charAt(index)` | Returns the character at a specific position          |
| `substring()`   | Returns part of a String                              |
| `toUpperCase()` | Returns an uppercase version                          |
| `toLowerCase()` | Returns a lowercase version                           |
| `strip()`       | Removes surrounding whitespace                        |
| `contains()`    | Checks whether text exists                            |
| `startsWith()`  | Checks a prefix                                       |
| `endsWith()`    | Checks a suffix                                       |
| `replace()`     | Replaces text                                         |
| `isEmpty()`     | Checks whether the length is `0`                      |
| `isBlank()`     | Checks whether the String is empty or whitespace-only |

# Comparing Strings

Use `.equals()` to compare the content of two Strings.

```java
String firstLanguage = "Java";
String secondLanguage = "Java";

System.out.println(
        firstLanguage.equals(secondLanguage)
);
```

Output:

```text
true
```

# Case Matters

```java
String firstLanguage = "Java";
String secondLanguage = "java";

System.out.println(
        firstLanguage.equals(secondLanguage)
);
```

Output:

```text
false
```

# Compare While Ignoring Case

```java
System.out.println(
        firstLanguage.equalsIgnoreCase(secondLanguage)
);
```

Output:

```text
true
```

# Do Not Use `==` to Compare String Content

Look at the following example:

```java
String firstValue = new String("Java");
String secondValue = new String("Java");

System.out.println(firstValue == secondValue);
System.out.println(firstValue.equals(secondValue));
```

Output:

```text
false
true
```

because:

* `==` compares whether the references point to the same object
* `.equals()` compares String content

Therefore, for String content use:

```java
firstValue.equals(secondValue)
```

# String Is Immutable

Java String is **immutable**.

This means:

> After a String object is created, its existing content cannot be changed.

Look at this code:

```java
String language = "Java";

language.toUpperCase();

System.out.println(language);
```

Output:

```text
Java
```

Why?

`toUpperCase()` does not modify the original String. It returns a new String.

# Store the Returned String

```java
String language = "Java";

language = language.toUpperCase();

System.out.println(language);
```

Output:

```text
JAVA
```

Remember the same behavior for methods such as `strip()`, `replace()`, and `toLowerCase()`.

# Escape Sequences

Escape sequences are used to represent special characters inside String literals.

Common escape sequences:

| Escape | Meaning      |
| ------ | ------------ |
| `\n`   | New line     |
| `\t`   | Tab          |
| `\"`   | Double quote |
| `\\`   | Backslash    |

# New Line

```java
System.out.println("Java\nFoundation");
```

Output:

```text
Java
Foundation
```

# Tab

```java
System.out.println("Name\tScore");
System.out.println("Sakib\t90");
```

# Double Quote

```java
System.out.println(
        "He said, \"Learn Java.\""
);
```

Output:

```text
He said, "Learn Java."
```

# Backslash

Windows path:

```text
C:\Java\Projects
```

Java String:

```java
String path = "C:\\Java\\Projects";
```

# Text Blocks

Java supports text blocks for writing readable multi-line text.

```java
String message = """
        Java and OOP Foundation
        Language: Bangla
        Level: Beginner
        """;
```

Print:

```java
System.out.println(message);
```

Output:

```text
Java and OOP Foundation
Language: Bangla
Level: Beginner
```

Text blocks can be useful for:

* Multi-line messages
* JSON
* SQL
* HTML
* Test data

# `String` and `char`

`String` and `char` are different types.

```java
char grade = 'A';
String courseName = "Java";
```

| `char`                  | `String`       |
| ----------------------- | -------------- |
| Primitive type          | Reference type |
| Single UTF-16 code unit | Text sequence  |
| Single quotes           | Double quotes  |
| `'A'`                   | `"A"`          |

# There Is No Empty `char`

Invalid:

```java
char value = '';
```

But an empty String is valid:

```java
String value = "";
```

# Common Errors

## Using Single Quotes for a String

Wrong:

```java
String language = 'Java';
```

Correct:

```java
String language = "Java";
```

## Calling a Method on `null`

Wrong:

```java
String value = null;

System.out.println(value.length());
```

This can cause a `NullPointerException` at runtime.

## Comparing Content With `==`

Avoid:

```java
firstValue == secondValue
```

To compare content:

```java
firstValue.equals(secondValue)
```

## Ignoring the Returned String

Wrong expectation:

```java
String value = "java";

value.toUpperCase();

System.out.println(value);
```

Output:

```text
java
```

Correct:

```java
value = value.toUpperCase();
```

## Invalid Index

```java
String value = "Java";

value.charAt(4);
```

This will fail at runtime.

Valid last index:

```text
3
```

## Concatenation Instead of Addition

```java
System.out.println("Result: " + 10 + 20);
```

Output:

```text
Result: 1020
```

Correct:

```java
System.out.println(
        "Result: " + (10 + 20)
);
```

Output:

```text
Result: 30
```

# Complete Example

```java
public class Main {

    public static void main(String[] args) {
        String rawCourseName =
                "   Java and OOP Foundation   ";

        String courseName = rawCourseName.strip();

        System.out.println(
                "Course: " + courseName
        );

        System.out.println(
                "Length: " + courseName.length()
        );

        System.out.println(
                "Starts with Java: "
                + courseName.startsWith("Java")
        );

        System.out.println(
                "Contains OOP: "
                + courseName.contains("OOP")
        );

        System.out.println(
                "Uppercase: "
                + courseName.toUpperCase()
        );
    }
}
```

Possible output:

```text
Course: Java and OOP Foundation
Length: 23
Starts with Java: true
Contains OOP: true
Uppercase: JAVA AND OOP FOUNDATION
```

# Important Terms

### String

A Java class used to represent a sequence of text.

### String Literal

Text written inside double quotes.

```java
"Java"
```

### Empty String

A zero-length String.

```java
""
```

### Blank String

An empty or whitespace-only String.

### `null`

The absence of an object reference.

### Concatenation

Combining Strings and other values.

### Index

A position inside a String, starting from `0`.

### Immutability

The property that an existing String object's content cannot be changed.

### Escape Sequence

Syntax used to represent special characters inside a String.

### Text Block

Syntax used to write multi-line Strings.

# Practice Exercise 1: Create Strings

Create String variables for the following information:

1. Student name
2. Course name
3. Email address
4. Country
5. Error message

# Practice Exercise 2: Empty, Blank, or `null`?

Classify each value:

```java
String firstValue = "";
String secondValue = "   ";
String thirdValue = null;
String fourthValue = "Java";
```

# Practice Exercise 3: Length and Index

```java
String language = "Java";
```

Answer:

1. What is the length?
2. What is the index of the first character?
3. What is the index of the last character?
4. What does `charAt(2)` return?

# Practice Exercise 4: Concatenation

```java
String firstName = "Sakib";
String lastName = "Sami";
```

Expected output:

```text
Full name: Sakib Sami
```

# Practice Exercise 5: Predict the Output

```java
System.out.println("Result: " + 10 + 20);
System.out.println("Result: " + (10 + 20));
```

# Practice Exercise 6: Normalize Text

Input:

```java
String rawName = "   md sakib   ";
```

Use `strip()` and `toUpperCase()` to produce:

```text
MD SAKIB
```

# Practice Exercise 7: Compare Strings

```java
String firstValue = "Java";
String secondValue = "java";
```

Print:

* The `.equals()` result
* The `.equalsIgnoreCase()` result

# Practice Exercise 8: Fix the Immutability Issue

```java
String language = "java";

language.toUpperCase();

System.out.println(language);
```

Expected output:

```text
JAVA
```

# Practice Exercise 9: Escape Sequence

Use a String to produce:

```text
Course: "Java Foundation"
Path: C:\Java\Projects
```

# Practice Exercise 10: Text Block

Use a text block to produce:

```text
Course: Java and OOP Foundation
Language: Bangla
Level: Beginner
```

# Knowledge Check

## Question 1

What is `String`?

## Question 2

Is `String` a primitive type?

## Question 3

Which quotation marks are used for String literals?

## Question 4

What is the difference between an empty String and `null`?

## Question 5

What is the difference between `isEmpty()` and `isBlank()`?

## Question 6

Which operator can be used for String concatenation?

## Question 7

Where does a String index start?

## Question 8

What does `charAt()` do?

## Question 9

In `substring(0, 4)`, is index `4` included?

## Question 10

Which method should be used to compare String content?

## Question 11

What is the difference between `==` and `.equals()`?

## Question 12

What does it mean that String is immutable?

## Question 13

Does `toUpperCase()` modify the original String?

## Question 14

What does `strip()` do?

## Question 15

What are text blocks used for?

## Question 16

What is the main difference between `String` and `char`?

# Knowledge Check Answers

## Answer 1

`String` is a Java class used to represent a sequence of text.

## Answer 2

No. `String` is a reference type.

## Answer 3

Double quotes:

```java
"Java"
```

## Answer 4

An empty String is a valid zero-length String object. `null` means that the variable does not reference a String object.

## Answer 5

`isEmpty()` checks whether the length is `0`. `isBlank()` checks whether the String is empty or contains only whitespace.

## Answer 6

```text
+
```

## Answer 7

The index starts from `0`.

## Answer 8

It returns the `char` value at a specific index.

## Answer 9

No. The end index is excluded.

## Answer 10

```java
equals()
```

## Answer 11

`==` compares reference identity. `.equals()` compares String content.

## Answer 12

The content of an existing String object cannot be changed.

## Answer 13

No. It returns a new String.

## Answer 14

It removes whitespace from the beginning and end of a String and returns a new String.

## Answer 15

Text blocks are used to write readable multi-line Strings.

## Answer 16

`char` is a primitive type that represents a single UTF-16 code unit. `String` is a reference type that represents a sequence of text.

# Lesson Summary

In this lesson, we learned:

* `String` represents text
* `String` is not a primitive type
* String literals are written inside double quotes
* Empty String, blank String, and `null` are different
* Calling a method on `null` can cause a `NullPointerException`
* `+` can be used to concatenate Strings
* Parentheses help control the order of calculation and concatenation
* `length()` returns the length of a String
* String indexes start from `0`
* `charAt()` returns the character at a specific position
* `substring()` returns part of a String
* `strip()` removes surrounding whitespace
* `contains()`, `startsWith()`, and `endsWith()` help inspect Strings
* `replace()` returns a new modified String
* `.equals()` should be used to compare String content
* `.equalsIgnoreCase()` can be used for case-insensitive comparison
* `==` should not be used for String content comparison
* String is immutable
* String methods generally return new Strings instead of modifying the original
* Escape sequences represent special characters
* Text blocks help write readable multi-line text
* `String` and `char` are different types

Strings and Text Values

Operators and Expressions

## Lesson Overview

In a program, not every value has the same data type.

Sometimes:

* An `int` value needs to be used as a `long`
* A `double` value needs to be converted to an `int`
* The text `"30"` needs to be converted to numeric `30`
* A number needs to be converted to a `String` for output
* The numeric value of a `char` needs to be determined

The process of changing a value from one type to another is called **type conversion**.

Java performs some conversions automatically. Other conversions must be performed explicitly.

In this lesson, we will learn:

* Implicit and explicit conversion
* Widening conversion
* Narrowing conversion
* Casting
* Data loss
* Numeric expression conversion
* `char` and number conversion
* Parsing String values into numbers
* Converting numbers to String

## Learning Objectives

After completing this lesson, you will be able to:

* Explain type conversion
* Distinguish between widening and narrowing conversion
* Understand automatic numeric conversion
* Write explicit casts
* Convert decimal values to integers
* Understand the possibility of data loss
* Apply casts at the correct point in a calculation
* Convert between `char` and integer values
* Parse numbers from Strings
* Convert primitive values to String

# What Is Type Conversion?

Type conversion means changing a value from one data type to another.

Example:

```java
int studentCount = 100;

long totalStudents = studentCount;
```

Here, the `int` value has been converted to `long`.

Another example:

```java
double price = 99.75;

int wholePrice = (int) price;
```

Result:

```text
99
```

Here, the decimal part has been lost.

# Two Types of Conversion

In Java, we will mainly look at two types of conversion:

1. **Implicit conversion**
2. **Explicit conversion**

# Implicit Conversion

When Java performs a compatible type conversion automatically, it is called implicit conversion.

```java
int value = 100;

long largerValue = value;
```

No cast was required here.

Java automatically converted the `int` value to `long`.

# Explicit Conversion

When the developer explicitly specifies the target type and requests a conversion, it is called explicit conversion.

```java
double value = 99.75;

int wholeValue = (int) value;
```

Here:

```java
(int)
```

is a cast.

# Widening Conversion

Conversion from a smaller numeric type to a wider compatible type is called widening conversion.

Simplified order:

```text
byte
  ↓
short
  ↓
int
  ↓
long
  ↓
float
  ↓
double
```

Example:

```java
byte score = 100;

int expandedScore = score;
```

Another example:

```java
int studentCount = 50_000;

long totalStudentCount = studentCount;
```

These conversions are generally automatic.

# Why Is Widening Automatic?

A wider type can generally accommodate the range of a smaller type.

For example:

```text
byte:
-128 to 127
```

All of these values fit inside an `int`.

Therefore:

```java
byte value = 100;

int result = value;
```

can be performed automatically.

# Some Widening Examples

```java
byte smallValue = 100;
int intValue = smallValue;
```

```java
int quantity = 5;
long largeQuantity = quantity;
```

```java
int score = 90;
double decimalScore = score;
```

In the last example:

```text
90
```

becomes:

```text
90.0
```

# Narrowing Conversion

Conversion from a wider type to a smaller type is called narrowing conversion.

```java
double price = 99.75;

int wholePrice = (int) price;
```

During narrowing:

* The decimal part may be lost
* The value may be outside the target type's range
* Precision may be lost

For this reason, an explicit cast is required.

# Casting Syntax

Syntax:

```java
(targetType) value
```

Example:

```java
double average = 85.75;

int wholeAverage = (int) average;
```

Here:

```text
Target type: int
Source type: double
```

# Narrowing Without a Cast

Invalid:

```java
double price = 99.75;

int wholePrice = price;
```

Correct:

```java
int wholePrice = (int) price;
```

# Casting Does Not Round

```java
double value = 99.99;

int result = (int) value;
```

Result:

```text
99
```

Casting does not choose the nearest integer.

The decimal part is simply discarded.

## Negative Value

```java
double value = -99.99;

int result = (int) value;
```

Result:

```text
-99
```

The conversion truncates toward zero.

# Truncation

Discarding the decimal part is called truncation.

```text
99.99   → 99
99.10   → 99
-99.99  → -99
-99.10  → -99
```

# Narrowing Is Not Always Safe

```java
int value = 130;

byte result = (byte) value;

System.out.println(result);
```

Output:

```text
-126
```

because `130` is outside the `byte` range.

Important:

> A cast tells the compiler to allow the conversion. It does not guarantee that the result will be logically correct.

# Integer and Decimal Conversion

Integer to decimal:

```java
int score = 90;

double decimalScore = score;
```

Result:

```text
90.0
```

Decimal to integer:

```java
double score = 90.75;

int wholeScore = (int) score;
```

Result:

```text
90
```

# Type Conversion Inside Expressions

When operands have different numeric types, Java can use a wider compatible type for the expression.

```java
int quantity = 3;
double price = 99.50;

double total =
        quantity * price;
```

Result:

```text
298.5
```

because the expression contains a `double`.

# Small Integer Arithmetic

Arithmetic involving `byte` and `short` is generally evaluated as `int`.

```java
byte firstValue = 10;
byte secondValue = 20;

int total =
        firstValue + secondValue;
```

This is valid.

But:

```java
byte total =
        firstValue + secondValue;
```

will not compile because the expression result is `int`.

# Cast Position Matters

Suppose:

```java
int total = 5;
int count = 2;
```

Wrong:

```java
double average =
        (double) (total / count);
```

Step:

```text
5 / 2 → 2
(double) 2 → 2.0
```

The fractional part has already been lost.

# Cast Before Division

Correct:

```java
double average =
        (double) total / count;
```

Step:

```text
(double) total → 5.0
5.0 / 2 → 2.5
```

Result:

```text
2.5
```

# Cast Before or After the Expression?

These two are not the same:

```java
(int) 10.75 + 5
```

Here, first:

```text
10.75 → 10
```

Then:

```text
10 + 5 = 15
```

On the other hand:

```java
(int) (10.75 + 5.50)
```

First:

```text
10.75 + 5.50 = 16.25
```

Then:

```text
16.25 → 16
```

Parentheses make the target of the cast clear.

# Conversion Before Arithmetic Overflow

Look at this code:

```java
int price = 2_000_000_000;
int quantity = 2;

long total =
        price * quantity;
```

`price * quantity` can first be evaluated using `int` arithmetic and overflow.

Safer:

```java
long total =
        (long) price * quantity;
```

Now `price` is converted to `long` first, so the multiplication uses `long` arithmetic.

# Numeric Conversion from `char`

A `char` represents a UTF-16 code unit.

```java
char letter = 'A';

int code = letter;

System.out.println(code);
```

Output:

```text
65
```

Conversion from `char` to `int` is automatic.

# Numeric Value to `char`

```java
int code = 65;

char letter = (char) code;

System.out.println(letter);
```

Output:

```text
A
```

An explicit cast is required here.

# Character Arithmetic

```java
char letter = 'A';

char nextLetter =
        (char) (letter + 1);

System.out.println(nextLetter);
```

Output:

```text
B
```

`letter + 1` produces an `int` result, so it is cast back to `char`.

# A Digit Character and a Number Are Not the Same

```java
char digitCharacter = '7';

int code = digitCharacter;

System.out.println(code);
```

Output:

```text
55
```

This is not numeric `7`. It is the code value of the `'7'` character.

# String to Number Conversion

External input may often arrive as text.

```java
String ageText = "30";
```

To use it in a numeric calculation, it must be parsed.

```java
int age =
        Integer.parseInt(ageText);
```

# String to `int`

```java
String quantityText = "3";

int quantity =
        Integer.parseInt(quantityText);

int total =
        quantity * 500;

System.out.println(total);
```

Output:

```text
1500
```

# String to `long`

```java
String populationText =
        "8000000000";

long population =
        Long.parseLong(populationText);
```

# String to `double`

```java
String priceText = "99.50";

double price =
        Double.parseDouble(priceText);
```

# String to `boolean`

```java
String activeText = "true";

boolean active =
        Boolean.parseBoolean(activeText);
```

Result:

```text
true
```

`Boolean.parseBoolean()` recognizes `"true"` case-insensitively.

```java
Boolean.parseBoolean("TRUE")
```

Result:

```text
true
```

Other text:

```java
Boolean.parseBoolean("yes")
```

Result:

```text
false
```

# Parsing and Casting Are Not the Same

Casting:

```java
double value = 10.5;

int result = (int) value;
```

Parsing:

```java
String value = "10";

int result =
        Integer.parseInt(value);
```

Difference:

* Casting converts a value between compatible types
* Parsing interprets text and creates a new typed value

# String Cannot Be Directly Cast to a Number

Invalid:

```java
String ageText = "30";

int age = (int) ageText;
```

Correct:

```java
int age =
        Integer.parseInt(ageText);
```

# Invalid Numeric Text

```java
String ageText = "thirty";

int age =
        Integer.parseInt(ageText);
```

This will cause a `NumberFormatException` at runtime.

`"thirty"` is not a valid integer representation.

# Normalize Whitespace Before Parsing

For this input:

```java
String ageText = " 30 ";
```

remove surrounding whitespace before parsing:

```java
int age =
        Integer.parseInt(
                ageText.strip()
        );
```

# Decimal Text Cannot Be Parsed Directly as an Integer

Invalid:

```java
String valueText = "10.5";

int value =
        Integer.parseInt(valueText);
```

Correct:

```java
double value =
        Double.parseDouble(valueText);
```

Then, if needed:

```java
int wholeValue =
        (int) value;
```

# Number to String Conversion

To convert a primitive value to text, you can use `String.valueOf()`.

```java
int age = 30;

String ageText =
        String.valueOf(age);
```

More examples:

```java
String priceText =
        String.valueOf(99.50);
```

```java
String activeText =
        String.valueOf(true);
```

```java
String gradeText =
        String.valueOf('A');
```

# Automatic String Conversion During Concatenation

```java
int age = 30;

String message =
        "Age: " + age;
```

Java uses the text representation of the `age` value.

Output:

```text
Age: 30
```

# `boolean` Is Not a Numeric Type

Invalid:

```java
boolean active = true;

int value = (int) active;
```

Similarly:

```java
int value = 1;

boolean active =
        (boolean) value;
```

is not valid.

In Java, `true`/`false` and numeric `1`/`0` belong to different parts of the type system.

# Complete Example: User Input Conversion

```java
public class Main {

    public static void main(String[] args) {
        String ageInput = "30";
        String scoreInput = "85.5";
        String activeInput = "true";

        int age =
                Integer.parseInt(ageInput);

        double score =
                Double.parseDouble(scoreInput);

        boolean active =
                Boolean.parseBoolean(activeInput);

        System.out.println(
                "Age next year: " + (age + 1)
        );

        System.out.println(
                "Score: " + score
        );

        System.out.println(
                "Active: " + active
        );
    }
}
```

Output:

```text
Age next year: 31
Score: 85.5
Active: true
```

# Complete Example: Average Calculation

```java
public class Main {

    public static void main(String[] args) {
        int totalMarks = 250;
        int subjectCount = 3;

        double average =
                (double) totalMarks
                / subjectCount;

        System.out.println(
                "Average: " + average
        );
    }
}
```

Output:

```text
Average: 83.33333333333333
```

# Common Errors

## Assuming a Cast Rounds

```java
double value = 9.9;

int result = (int) value;
```

Result:

```text
9
```

A cast truncates.

## Casting Too Late

Wrong:

```java
double average =
        (double) (5 / 2);
```

Result:

```text
2.0
```

Correct:

```java
double average =
        (double) 5 / 2;
```

Result:

```text
2.5
```

## Out-of-Range Narrowing

```java
int value = 130;

byte result =
        (byte) value;
```

Result:

```text
-126
```

A successful cast does not mean the value is safe.

## Invalid Numeric Text

Wrong:

```java
int age =
        Integer.parseInt("30 years");
```

Correct input:

```java
int age =
        Integer.parseInt("30");
```

## Wrong Parser for a Large Value

Wrong:

```java
int population =
        Integer.parseInt(
                "8000000000"
        );
```

The value is outside the `int` range.

Use:

```java
long population =
        Long.parseLong(
                "8000000000"
        );
```

## Direct Number-to-String Cast

Invalid:

```java
int age = 30;

String ageText =
        (String) age;
```

Correct:

```java
String ageText =
        String.valueOf(age);
```

# Conversion Guide

| Requirement        | Approach                 |
| ------------------ | ------------------------ |
| `int` → `long`     | Automatic widening       |
| `int` → `double`   | Automatic widening       |
| `double` → `int`   | Explicit cast            |
| `char` → `int`     | Automatic widening       |
| `int` → `char`     | Explicit cast            |
| String → `int`     | `Integer.parseInt()`     |
| String → `long`    | `Long.parseLong()`       |
| String → `double`  | `Double.parseDouble()`   |
| String → `boolean` | `Boolean.parseBoolean()` |
| Primitive → String | `String.valueOf()`       |

# Important Terms

### Type Conversion

Changing a value from one type to another.

### Implicit Conversion

A conversion Java performs automatically.

### Explicit Conversion

A conversion explicitly requested by the developer.

### Widening Conversion

Conversion from a smaller compatible type to a wider type.

### Narrowing Conversion

Conversion from a wider type to a smaller type.

### Casting

Explicit conversion using:

```java
(targetType) value
```

### Truncation

Discarding the decimal part of a value.

### Parsing

Interpreting text content and creating a typed value from it.

### Numeric Promotion

Using a compatible wider numeric type when evaluating an expression.

# Practice Exercise 1: Widening or Narrowing?

Classify each conversion:

1. `byte` → `int`
2. `int` → `long`
3. `long` → `int`
4. `float` → `double`
5. `double` → `int`
6. `char` → `int`
7. `int` → `char`

# Practice Exercise 2: Cast Decimal Values

Cast the following values to `int`:

```text
99.99
99.01
-99.99
-99.01
```

Predict the result.

# Practice Exercise 3: Fix the Average

Wrong:

```java
int totalMarks = 250;
int subjectCount = 3;

double average =
        totalMarks / subjectCount;
```

Use casting to produce a decimal average.

# Practice Exercise 4: Cast Position

Predict the output:

```java
double firstResult =
        (double) (5 / 2);

double secondResult =
        (double) 5 / 2;
```

Explain the difference.

# Practice Exercise 5: Character Conversion

```java
char letter = 'A';
```

Do the following:

1. Get the integer code from the `char`
2. Create a `char` from integer `66`

# Practice Exercise 6: Parse Values

```java
String ageText = "30";
String populationText = "8000000000";
String scoreText = "85.5";
String activeText = "true";
```

Parse each value into the appropriate type.

# Practice Exercise 7: Normalize Before Parsing

```java
String quantityText = "   5   ";
```

Use `strip()` and parse it to `int`, then multiply the result by `2`.

Expected output:

```text
10
```

# Practice Exercise 8: Convert to String

Convert the following values to String using `String.valueOf()`:

```java
int age = 30;
double score = 85.5;
boolean active = true;
char grade = 'A';
```

# Knowledge Check

## Question 1

What is type conversion?

## Question 2

What is implicit conversion?

## Question 3

What is explicit conversion?

## Question 4

What is widening conversion?

## Question 5

What is narrowing conversion?

## Question 6

What is the casting syntax?

## Question 7

Does converting `int` to `long` require a cast?

## Question 8

Does converting `double` to `int` require a cast?

## Question 9

What is the result of `(int) 99.99`?

## Question 10

Does casting perform rounding?

## Question 11

Why is it important to cast before division?

## Question 12

Is conversion from `char` to `int` automatic?

## Question 13

What is required to convert `int` to `char`?

## Question 14

Which method parses a String into an `int`?

## Question 15

Which method parses a String into a `long`?

## Question 16

Which method parses a String into a `double`?

## Question 17

What general method converts a primitive value to String?

## Question 18

What can happen when invalid numeric text is parsed?

## Question 19

Can a boolean be cast to a numeric type?

## Question 20

Are casting and parsing the same?

# Knowledge Check Answers

## Answer 1

Changing a value from one data type to another is called type conversion.

## Answer 2

When Java performs a conversion automatically, it is called implicit conversion.

## Answer 3

When the developer explicitly uses a cast or conversion method, it is called explicit conversion.

## Answer 4

Conversion from a smaller compatible type to a wider type is called widening conversion.

## Answer 5

Conversion from a wider type to a smaller type is called narrowing conversion.

## Answer 6

```java
(targetType) value
```

## Answer 7

No. This is generally an automatic widening conversion.

## Answer 8

Yes.

```java
int value =
        (int) doubleValue;
```

## Answer 9

```text
99
```

## Answer 10

No. It truncates the decimal part.

## Answer 11

If integer division happens first, the fractional part is lost. Therefore, if a decimal result is required, one operand must be converted to floating-point before the division occurs.

## Answer 12

Yes.

## Answer 13

An explicit cast.

```java
(char) 65
```

## Answer 14

```java
Integer.parseInt()
```

## Answer 15

```java
Long.parseLong()
```

## Answer 16

```java
Double.parseDouble()
```

## Answer 17

```java
String.valueOf()
```

## Answer 18

A `NumberFormatException` can occur.

## Answer 19

No.

## Answer 20

No. Casting converts compatible typed values. Parsing interprets text and creates a typed value.

# Lesson Summary

In this lesson, we learned:

* Type conversion changes a value from one type to another
* Java performs some conversions automatically
* Widening conversion is generally automatic
* Narrowing conversion requires an explicit cast
* Casting syntax is `(targetType) value`
* Casting from decimal to integer truncates the fractional part
* Casting does not perform rounding
* Narrowing conversion can cause data loss
* A successful cast does not guarantee that the resulting value is safe
* Numeric expression results depend on operand types
* Decimal division requires floating-point conversion before division occurs
* `char` to `int` conversion is automatic
* `int` to `char` requires an explicit cast
* String-to-number conversion is performed through parsing
* `Integer.parseInt()`, `Long.parseLong()`, and `Double.parseDouble()` are common parsing methods
* `String.valueOf()` can convert primitive values to String
* Parsing invalid numeric text can cause a runtime error
* Boolean values cannot be cast to numeric types
* Casting and parsing are different processes

Type Conversion and Casting

## Lesson Overview

So far, most of the values in our programs have been written directly inside the source code.

```java
String studentName = "Sakib";
int age = 20;
```

These are hard-coded values.

However, in an interactive program, the user can provide data while the program is running.

For example:

* Name
* Age
* Mark
* Product quantity
* Search text
* Course selection

In a console-based Java application, we can use `Scanner` to read keyboard input.

In this lesson, we will learn:

* What `Scanner` is
* How to import and create a `Scanner`
* How to display a prompt to the user
* How to read input using `nextLine()`
* How to parse numbers from text input
* How to read multiple inputs
* The common `nextInt()` and `nextLine()` problem
* Basic input validation
* How to close a Scanner

## Learning Objectives

After completing this lesson, you will be able to:

* Read user input from the console
* Import and create a `Scanner`
* Use `nextLine()` to read a full line
* Normalize String input
* Parse `int` and `double` values from String input
* Read multiple inputs sequentially
* Understand the problem that can occur when mixing `nextInt()` and `nextLine()`
* Perform basic input validation
* Write a simple interactive console program

# What Is User Input?

User input is data provided by the user while a program is running.

Example:

```text
Enter your name: Sakib
Enter your age: 20
```

Here:

```text
Sakib
20
```

are values provided by the user.

The program can store and process these values.

# Hard-Coded Value vs. User Input

Hard-coded:

```java
String name = "Sakib";
```

The value is fixed inside the source code.

User input:

```java
String name = scanner.nextLine();
```

Here, the user provides the value while the program is running.

# What Is `Scanner`?

`Scanner` is a class from the Java standard library that helps read input.

For keyboard input, we use `Scanner` with:

```java
System.in
```

`System.in` is the standard input stream.

# Importing `Scanner`

`Scanner` is a class from the `java.util` package.

Write this at the beginning of the source file:

```java
import java.util.Scanner;
```

Basic structure:

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

    }
}
```

# Creating a Scanner

To read keyboard input:

```java
Scanner scanner =
        new Scanner(System.in);
```

Here:

* `Scanner` — type
* `scanner` — variable name
* `new Scanner(...)` — creates a Scanner object
* `System.in` — keyboard input source

# First Input Program

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner =
                new Scanner(System.in);

        System.out.print(
                "Enter your name: "
        );

        String name =
                scanner.nextLine();

        System.out.println(
                "Hello, " + name
        );

        scanner.close();
    }
}
```

Possible interaction:

```text
Enter your name: Sakib
Hello, Sakib
```

# Displaying a Prompt

You should clearly tell the user what input is expected.

```java
System.out.print(
        "Enter your name: "
);
```

`print()` does not create a new line.

Therefore, the interaction looks like:

```text
Enter your name: Sakib
```

A clear prompt helps reduce invalid input.

Better:

```text
Enter your age in years:
```

Compared with:

```text
Input:
```

# `nextLine()`

To read an entire line:

```java
String value =
        scanner.nextLine();
```

Input:

```text
Md Samiul Alim Sakib
```

Stored value:

```text
Md Samiul Alim Sakib
```

The entire line, including spaces, is read.

# Normalizing Input

User input may contain extra whitespace at the beginning or end.

```java
String name =
        scanner
                .nextLine()
                .strip();
```

Input:

```text
   Sakib
```

Stored value:

```text
Sakib
```

For text input, `.strip()` is often useful.

# Reading Numeric Input

`nextLine()` always returns text.

Suppose the user enters:

```text
20
```

We can first read it as a String:

```java
String ageText =
        scanner.nextLine();
```

Then parse it into an `int`:

```java
int age =
        Integer.parseInt(
                ageText.strip()
        );
```

# Integer Input Example

```java
System.out.print(
        "Enter your age: "
);

int age =
        Integer.parseInt(
                scanner
                        .nextLine()
                        .strip()
        );

System.out.println(
        "Next year you will be "
        + (age + 1)
);
```

Interaction:

```text
Enter your age: 20
Next year you will be 21
```

# Decimal Input

For decimal input:

```java
System.out.print(
        "Enter course price: "
);

double price =
        Double.parseDouble(
                scanner
                        .nextLine()
                        .strip()
        );
```

Input:

```text
4990.50
```

Variable:

```text
price = 4990.5
```

# Boolean Input

To parse `true` or `false` text:

```java
System.out.print(
        "Is enrollment open? "
);

boolean enrollmentOpen =
        Boolean.parseBoolean(
                scanner
                        .nextLine()
                        .strip()
        );
```

Input:

```text
true
```

Result:

```text
true
```

However:

```text
yes
```

is not considered `true` by `Boolean.parseBoolean()`.

If you want user-friendly yes/no input, you can compare the String:

```java
String answer =
        scanner
                .nextLine()
                .strip();

boolean confirmed =
        answer.equalsIgnoreCase("yes")
        || answer.equalsIgnoreCase("y");
```

# Reading Multiple Inputs

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner =
                new Scanner(System.in);

        System.out.print(
                "Enter your name: "
        );

        String name =
                scanner
                        .nextLine()
                        .strip();

        System.out.print(
                "Enter your age: "
        );

        int age =
                Integer.parseInt(
                        scanner
                                .nextLine()
                                .strip()
                );

        System.out.println();
        System.out.println(
                "Name: " + name
        );

        System.out.println(
                "Age: " + age
        );

        scanner.close();
    }
}
```

Possible interaction:

```text
Enter your name: Sakib
Enter your age: 20

Name: Sakib
Age: 20
```

# Why Are We Using `nextLine()` More Often?

`Scanner` also provides methods for directly reading typed input:

```java
nextInt()
nextDouble()
nextBoolean()
```

Example:

```java
int age =
        scanner.nextInt();
```

These are valid.

However, mixing token-based methods with `nextLine()` can cause a common newline problem.

For beginners, reading all input using `nextLine()` and parsing it afterward keeps the input flow more consistent.

# The `nextInt()` and `nextLine()` Problem

Look at this code:

```java
System.out.print(
        "Enter your age: "
);

int age =
        scanner.nextInt();

System.out.print(
        "Enter your name: "
);

String name =
        scanner.nextLine();
```

After the user enters their age and presses Enter, the name input may appear to be skipped.

# Why Does the Input Get Skipped?

User input:

```text
20\n
```

`nextInt()` reads:

```text
20
```

but the newline produced by Enter:

```text
\n
```

can remain in the input stream.

The next call:

```java
scanner.nextLine();
```

may consume that remaining newline and return an empty String.

# Fixing the Problem

One option:

```java
int age =
        scanner.nextInt();

scanner.nextLine();

String name =
        scanner.nextLine();
```

The extra `nextLine()` consumes the leftover newline.

However, for beginner code, a more consistent approach is:

```java
int age =
        Integer.parseInt(
                scanner
                        .nextLine()
                        .strip()
        );
```

In other words, read every input as a full line.

# Recommended Input Pattern

For simple console programs in this course, we will generally use this pattern:

```java
String input =
        scanner
                .nextLine()
                .strip();
```

For text, use it directly:

```java
String name = input;
```

For an integer:

```java
int age =
        Integer.parseInt(input);
```

For a decimal:

```java
double price =
        Double.parseDouble(input);
```

This approach:

* Consumes the full line
* Allows whitespace normalization
* Keeps the input style consistent
* Reduces `nextInt()` / `nextLine()` problems

# Invalid Numeric Input

Suppose:

```java
int age =
        Integer.parseInt(
                scanner.nextLine()
        );
```

The user enters:

```text
twenty
```

This is not valid integer text.

At runtime, a:

```text
NumberFormatException
```

can occur.

# Type Validity and Business Validity

An input is not necessarily valid just because it is a valid integer.

Example:

```text
Age: -50
```

`-50` is a valid integer.

But it is not valid as an age.

Suppose acceptable age is:

```text
0 to 150
```

Check:

```java
boolean validAge =
        age >= 0
        && age <= 150;
```

Therefore, there can be two types of validation:

1. Whether the input is of the expected type
2. Whether the value is acceptable according to business rules

# Blank Input

```java
String name =
        scanner
                .nextLine()
                .strip();

boolean missing =
        name.isBlank();
```

Input:

```text
   
```

Result:

```text
true
```

`isBlank()` is useful for checking required text input.

# Closing the Scanner

After you finish reading input:

```java
scanner.close();
```

Example:

```java
Scanner scanner =
        new Scanner(System.in);

// Read all input

scanner.close();
```

After a Scanner is closed, it cannot be used to read input again.

Therefore, close it only after all input operations are complete.

# Reuse One Scanner

Avoid:

```java
Scanner nameScanner =
        new Scanner(System.in);

Scanner ageScanner =
        new Scanner(System.in);
```

For the same `System.in` stream, generally create one Scanner and reuse it:

```java
Scanner scanner =
        new Scanner(System.in);
```

# Complete Interactive Program

Now let's create a simple student result program.

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner =
                new Scanner(System.in);

        System.out.print(
                "Enter student name: "
        );

        String studentName =
                scanner
                        .nextLine()
                        .strip();

        System.out.print(
                "Enter mathematics mark: "
        );

        int mathematicsMark =
                Integer.parseInt(
                        scanner
                                .nextLine()
                                .strip()
                );

        System.out.print(
                "Enter English mark: "
        );

        int englishMark =
                Integer.parseInt(
                        scanner
                                .nextLine()
                                .strip()
                );

        System.out.print(
                "Enter science mark: "
        );

        int scienceMark =
                Integer.parseInt(
                        scanner
                                .nextLine()
                                .strip()
                );

        int totalMarks =
                mathematicsMark
                + englishMark
                + scienceMark;

        double averageMark =
                totalMarks / 3.0;

        System.out.println();
        System.out.println(
                "Student: " + studentName
        );

        System.out.println(
                "Total: " + totalMarks
        );

        System.out.println(
                "Average: " + averageMark
        );

        scanner.close();
    }
}
```

Possible interaction:

```text
Enter student name: Sakib
Enter mathematics mark: 80
Enter English mark: 90
Enter science mark: 85

Student: Sakib
Total: 255
Average: 85.0
```

# Common Errors

## Not Importing `Scanner`

Wrong:

```java
Scanner scanner =
        new Scanner(System.in);
```

If there is no import, the compiler will not recognize `Scanner`.

Add:

```java
import java.util.Scanner;
```

## Omitting `new`

Wrong:

```java
Scanner scanner =
        Scanner(System.in);
```

Correct:

```java
Scanner scanner =
        new Scanner(System.in);
```

## Wrong Input Source

Wrong:

```java
Scanner scanner =
        new Scanner(System.out);
```

For keyboard input:

```java
Scanner scanner =
        new Scanner(System.in);
```

## Using `next()` for a Full Name

```java
String name =
        scanner.next();
```

Input:

```text
Md Sakib
```

Only:

```text
Md
```

will be read.

For a full line:

```java
scanner.nextLine();
```

## Parsing an Invalid Number

Wrong input:

```text
twenty
```

Code:

```java
Integer.parseInt("twenty");
```

This causes a runtime error.

The input to a numeric parser must use a valid numeric format.

## Not Normalizing Input

Input:

```text
   Sakib
```

Use:

```java
String name =
        scanner
                .nextLine()
                .strip();
```

## Closing the Scanner Too Early

Wrong:

```java
Scanner scanner =
        new Scanner(System.in);

scanner.close();

String name =
        scanner.nextLine();
```

Close it after all input has been read.

# Important Terms

### User Input

Data provided by the user while the program is running.

### `System.in`

Java's standard input stream.

### `Scanner`

A Java utility class that helps read input.

### Prompt

A message that tells the user what input is expected.

### `nextLine()`

Reads an entire line of input.

### Parsing

Interpreting text and creating a value of another type.

### Validation

Checking whether input is acceptable.

### Normalization

Bringing input into a consistent form.

Examples:

```text
Remove whitespace
Normalize case
```

### `NumberFormatException`

A runtime exception that can occur when invalid numeric text is parsed.

# Practice Exercise 1: Name Input

Read the user's full name.

Input:

```text
Md Samiul Alim Sakib
```

Output:

```text
Welcome, Md Samiul Alim Sakib
```

# Practice Exercise 2: Age Input

Read the user's age.

Expected interaction:

```text
Enter your age: 20
Next year you will be 21
```

# Practice Exercise 3: Numeric Parsing

Read all input using `nextLine()`:

* Name
* Age
* Course price

Convert:

* Age → `int`
* Price → `double`

# Practice Exercise 4: Normalize Input

Input:

```text
   JAVA
```

Produce:

```text
java
```

Use:

* `nextLine()`
* `strip()`
* `toLowerCase()`

# Practice Exercise 5: Yes or No

Prompt:

```text
Do you want to continue? Enter yes or no:
```

Accept the following as positive values:

```text
yes
y
YES
Y
```

Create a `boolean shouldContinue`.

# Practice Exercise 6: Product Order

Read:

* Product name
* Unit price
* Quantity

Calculate:

```text
subtotal = unit price × quantity
```

Then print the product information and subtotal.

# Practice Exercise 7: Student Result

Read from the user:

* Student name
* Mathematics mark
* English mark
* Science mark

Calculate:

* Total
* Decimal average

# Knowledge Check

## Question 1

What is the standard stream for keyboard input?

## Question 2

Which package contains `Scanner`?

## Question 3

What is the import statement for `Scanner`?

## Question 4

How do you create a Scanner for keyboard input?

## Question 5

Which method reads a full line?

## Question 6

What can be used to remove surrounding whitespace from input?

## Question 7

Which method converts String input to an `int`?

## Question 8

Which method converts String input to a `double`?

## Question 9

Why can `nextLine()` appear to be skipped after `nextInt()`?

## Question 10

What is the recommended input strategy for beginner console programs in this course?

## Question 11

What can happen when invalid numeric text is parsed?

## Question 12

Is type-valid input always business-valid?

## Question 13

When should a Scanner be closed?

## Question 14

Should multiple Scanner instances generally be created for the same `System.in`?

# Knowledge Check Answers

## Answer 1

```java
System.in
```

## Answer 2

```text
java.util
```

## Answer 3

```java
import java.util.Scanner;
```

## Answer 4

```java
Scanner scanner =
        new Scanner(System.in);
```

## Answer 5

```java
nextLine()
```

## Answer 6

```java
strip()
```

## Answer 7

```java
Integer.parseInt()
```

## Answer 8

```java
Double.parseDouble()
```

## Answer 9

`nextInt()` reads the numeric token but can leave the newline from pressing Enter in the input stream. The next `nextLine()` may consume that newline and return an empty String.

## Answer 10

Read all input using `nextLine()`, normalize it with `.strip()` when needed, and convert numeric values using parsing methods.

## Answer 11

A `NumberFormatException` can occur.

## Answer 12

No. For example, `500` is a valid integer but may be invalid as an age or exam mark.

## Answer 13

After all input operations are complete.

## Answer 14

Generally, no. It is better to create one Scanner and reuse it.

# Lesson Summary

In this lesson, we learned:

* User input makes a program interactive
* `System.in` is the standard keyboard input stream
* `Scanner` helps read console input
* `java.util.Scanner` must be imported to use `Scanner`
* A Scanner can be created using `new Scanner(System.in)`
* A prompt helps the user understand the expected input
* `nextLine()` reads an entire line
* `.strip()` helps normalize input
* Numeric input can be read as text and then parsed
* `Integer.parseInt()` converts String input to `int`
* `Double.parseDouble()` converts String input to `double`
* Mixing `nextInt()` and `nextLine()` can create a leftover-newline problem
* Reading all input with `nextLine()` is a consistent strategy for beginners
* Parsing invalid numeric text can cause a runtime error
* Type validation and business validation are different
* Reusing one Scanner for the same `System.in` is preferable
* The Scanner should be closed after all input is complete

Reading User Input

## Lesson Overview

A program does not always execute the same instructions.

Often, a program needs to make decisions based on data or conditions.

For example:

* Allow enrollment if age is `18` or above
* Show passed if a mark is `40` or above
* Accept an order if stock is available
* Determine whether a number is positive, negative, or zero
* Allow login if both email and password are valid

In Java, conditional statements are used to control execution flow based on conditions.

In this lesson, we will learn:

* Boolean conditions
* `if`
* `if-else`
* `else-if`
* Multiple independent `if` statements
* Logical operators in conditions
* Range validation
* Nested conditions
* Common conditional mistakes

## Learning Objectives

After completing this lesson, you will be able to:

* Make decisions using boolean expressions
* Write `if`, `if-else`, and `else-if`
* Distinguish between independent and mutually exclusive conditions
* Combine multiple conditions
* Validate numeric ranges
* Understand nested conditions
* Identify common mistakes in conditional logic
* Create simple decision-making programs

# What Is Conditional Execution?

Conditional execution means executing or skipping a block of code depending on the result of a condition.

```java
int age = 20;

if (age >= 18) {
    System.out.println("Adult");
}
```

Condition:

```java
age >= 18
```

Result:

```text
true
```

Therefore, the block executes.

Output:

```text
Adult
```

If:

```java
int age = 15;
```

then the condition is false and the block does not execute.

# A Condition Must Be Boolean

The result of a condition in a Java conditional statement must be:

```text
true
```

or:

```text
false
```

Valid:

```java
age >= 18
```

```java
score == 100
```

```java
isActive
```

```java
!accountBlocked
```

```java
emailValid && passwordValid
```

In Java, a number cannot be used directly as a condition.

Invalid:

```java
int value = 1;

if (value) {
    System.out.println("Valid");
}
```

Correct:

```java
if (value == 1) {
    System.out.println("Value is one");
}
```

# `if` Statement

Syntax:

```java
if (condition) {
    // Executes when condition is true
}
```

Example:

```java
int mark = 75;

if (mark >= 40) {
    System.out.println("Passed");
}
```

Output:

```text
Passed
```

If the condition is false, the block is skipped.

# Multiple Statements Inside an `if` Block

```java
int age = 20;

if (age >= 18) {
    System.out.println("Age requirement met");
    System.out.println("Enrollment allowed");
}
```

If the condition is true, the statements inside the block execute from top to bottom.

# Use Curly Braces

Curly braces can technically be omitted for a single statement:

```java
if (age >= 18)
    System.out.println("Adult");
```

However, using braces is safer and clearer.

Preferred:

```java
if (age >= 18) {
    System.out.println("Adult");
}
```

This reduces the risk of accidentally breaking the logic when another statement is added later.

# `if-else`

Use `if-else` when different branches are needed for both the true and false cases.

```java
int mark = 35;

if (mark >= 40) {
    System.out.println("Passed");
} else {
    System.out.println("Failed");
}
```

Output:

```text
Failed
```

Only one branch executes during a single execution.

# Example: Even or Odd

```java
int number = 17;

if (number % 2 == 0) {
    System.out.println("Even");
} else {
    System.out.println("Odd");
}
```

Output:

```text
Odd
```

# `else-if`

When there are more than two mutually exclusive outcomes, `else-if` can be used.

```java
if (firstCondition) {
    // First branch
} else if (secondCondition) {
    // Second branch
} else {
    // Default branch
}
```

Java checks conditions from top to bottom.

After the first true branch executes, the remaining branches are skipped.

# Positive, Negative, or Zero

```java
int number = -10;

if (number > 0) {
    System.out.println("Positive");
} else if (number < 0) {
    System.out.println("Negative");
} else {
    System.out.println("Zero");
}
```

Output:

```text
Negative
```

# Condition Order Is Important

Look at this code:

```java
int mark = 90;

if (mark >= 40) {
    System.out.println("Passed");
} else if (mark >= 80) {
    System.out.println("Excellent");
}
```

Output:

```text
Passed
```

`mark >= 40` is already true, so the next condition is never checked.

Better:

```java
if (mark >= 80) {
    System.out.println("Excellent");
} else if (mark >= 40) {
    System.out.println("Passed");
} else {
    System.out.println("Failed");
}
```

When conditions overlap, the more specific condition or higher threshold should generally be checked first.

# Grade Example

```java
int mark = 85;
String grade;

if (mark < 0 || mark > 100) {
    grade = "Invalid";
} else if (mark >= 80) {
    grade = "A";
} else if (mark >= 70) {
    grade = "B";
} else if (mark >= 60) {
    grade = "C";
} else if (mark >= 50) {
    grade = "D";
} else if (mark >= 40) {
    grade = "E";
} else {
    grade = "F";
}

System.out.println(
        "Grade: " + grade
);
```

Output:

```text
Grade: A
```

Because `else-if` is used, only one grade is selected for a mark.

# Why Do We Not Repeat the Upper Bound?

Look at this section:

```java
if (mark >= 80) {
    grade = "A";
} else if (mark >= 70) {
    grade = "B";
}
```

The second condition is checked only when:

```text
mark < 80
```

Therefore:

```java
mark >= 70
```

effectively represents:

```text
70 <= mark < 80
```

# Multiple Independent `if` Statements

Not all conditions are mutually exclusive.

```java
int mark = 90;

if (mark >= 40) {
    System.out.println("Passed");
}

if (mark >= 80) {
    System.out.println("Distinction");
}
```

Output:

```text
Passed
Distinction
```

Both conditions are independently true.

# Multiple `if` vs. `else-if`

## Multiple `if`

```java
if (conditionA) {
}

if (conditionB) {
}
```

Multiple blocks may execute.

## `else-if`

```java
if (conditionA) {
} else if (conditionB) {
}
```

Only the first matching branch executes.

## When Should You Use Each?

Independent results:

```java
if (mark >= 40) {
    System.out.println("Passed");
}

if (mark >= 80) {
    System.out.println("Scholarship eligible");
}
```

Mutually exclusive results:

```java
if (mark >= 80) {
    System.out.println("A");
} else if (mark >= 70) {
    System.out.println("B");
} else {
    System.out.println("C or below");
}
```

# Multiple Conditions with `&&`

When every condition must be true:

```java
int age = 20;
boolean emailVerified = true;

if (age >= 18 && emailVerified) {
    System.out.println("Enrollment allowed");
}
```

Here:

* Age must be at least `18`
* Email must be verified

Both must be true.

# Alternative Conditions with `||`

When at least one condition must be true:

```java
boolean isInstructor = false;
boolean isAdmin = true;

if (isInstructor || isAdmin) {
    System.out.println("Access allowed");
}
```

Output:

```text
Access allowed
```

# Reverse a Condition with `!`

```java
boolean accountBlocked = false;

if (!accountBlocked) {
    System.out.println("Account access allowed");
}
```

The result of:

```java
!accountBlocked
```

is:

```text
true
```

# Keep Complex Conditions Readable

```java
int age = 20;
boolean emailVerified = true;
boolean accountBlocked = false;
boolean enrollmentOpen = true;

boolean canEnroll =
        age >= 18
        && emailVerified
        && !accountBlocked
        && enrollmentOpen;

if (canEnroll) {
    System.out.println("Enrollment allowed");
}
```

A meaningful boolean variable can make a complex condition easier to understand.

# Range Validation

Suppose a mark is valid from:

```text
0 to 100
```

Correct:

```java
boolean validMark =
        mark >= 0
        && mark <= 100;
```

Invalid mark:

```java
boolean invalidMark =
        mark < 0
        || mark > 100;
```

# Wrong Range Logic

Wrong:

```java
boolean validMark =
        mark >= 0
        || mark <= 100;
```

Suppose:

```text
mark = 500
```

Then:

```text
500 >= 0   → true
500 <= 100 → false
true || false → true
```

`500` would incorrectly be considered valid.

Correct:

```java
mark >= 0
&& mark <= 100
```

# Mathematical Chained Comparisons Are Not Valid in Java

In mathematics, you may write:

```text
0 <= mark <= 100
```

But this is not valid Java:

```java
if (0 <= mark <= 100) {
}
```

Correct:

```java
if (
        mark >= 0
        && mark <= 100
) {
    System.out.println("Valid mark");
}
```

# Nested `if`

A conditional statement inside another conditional block is called a nested `if`.

```java
int age = 20;
boolean emailVerified = true;

if (age >= 18) {
    if (emailVerified) {
        System.out.println(
                "Enrollment allowed"
        );
    }
}
```

The inner condition is evaluated only if the outer condition is true.

# When Is a Nested Condition Useful?

A nested condition can be useful when the second decision depends on the context established by the first decision.

```java
boolean loggedIn = true;
boolean isAdmin = false;

if (loggedIn) {
    if (isAdmin) {
        System.out.println(
                "Admin dashboard"
        );
    } else {
        System.out.println(
                "User dashboard"
        );
    }
} else {
    System.out.println(
            "Please log in"
    );
}
```

However, avoid unnecessary deep nesting.

# Showing a Specific Failure Reason

Sometimes it is useful to show a specific failure reason instead of combining everything into one success condition.

```java
boolean userExists = true;
boolean passwordCorrect = false;
boolean accountLocked = false;

if (!userExists) {
    System.out.println("User not found");
} else if (!passwordCorrect) {
    System.out.println("Incorrect password");
} else if (accountLocked) {
    System.out.println("Account is locked");
} else {
    System.out.println("Login successful");
}
```

Here, the conditions are ordered according to the user flow.

# String Conditions

To compare String content:

```java
String role = "ADMIN";

if ("ADMIN".equals(role)) {
    System.out.println("Access allowed");
}
```

To ignore case:

```java
if ("ADMIN".equalsIgnoreCase(role)) {
    System.out.println("Access allowed");
}
```

For String content, do not use:

```java
role == "ADMIN"
```

# `null` and String Check

```java
String courseName = null;

if (
        courseName != null
        && !courseName.isBlank()
) {
    System.out.println(
            "Valid course name"
    );
} else {
    System.out.println(
            "Course name is required"
    );
}
```

If `courseName` is null, the first condition is false.

Because of short-circuit evaluation:

```java
courseName.isBlank()
```

will not be called.

# Common Mistakes

## Extra Semicolon After `if`

Wrong:

```java
if (age >= 18); {
    System.out.println("Adult");
}
```

The semicolon has already ended the `if` statement.

Correct:

```java
if (age >= 18) {
    System.out.println("Adult");
}
```

## Assignment Instead of Comparison

Wrong:

```java
boolean active = false;

if (active = true) {
    System.out.println("Active");
}
```

This performs assignment instead of comparison.

Preferred:

```java
if (active) {
    System.out.println("Active");
}
```

## Comparing a Boolean with `== true`

Verbose:

```java
if (isAvailable == true) {
}
```

Preferred:

```java
if (isAvailable) {
}
```

False check:

```java
if (!isAvailable) {
}
```

## Multiple `if` Statements for Exclusive Results

Wrong:

```java
if (mark >= 80) {
    System.out.println("A");
}

if (mark >= 70) {
    System.out.println("B");
}

if (mark >= 60) {
    System.out.println("C");
}
```

If `mark = 85`, all three outputs may appear.

Correct:

```java
if (mark >= 80) {
    System.out.println("A");
} else if (mark >= 70) {
    System.out.println("B");
} else if (mark >= 60) {
    System.out.println("C");
}
```

## Wrong Null Check Order

Wrong:

```java
if (
        !name.isBlank()
        && name != null
) {
}
```

Correct:

```java
if (
        name != null
        && !name.isBlank()
) {
}
```

# Complete Example: Enrollment Decision

```java
public class Main {

    public static void main(String[] args) {
        int learnerAge = 20;
        boolean emailVerified = true;
        boolean enrollmentOpen = true;
        boolean accountBlocked = false;

        if (learnerAge < 0) {
            System.out.println(
                    "Invalid age"
            );
        } else if (learnerAge < 18) {
            System.out.println(
                    "Minimum age requirement not met"
            );
        } else if (!emailVerified) {
            System.out.println(
                    "Email verification required"
            );
        } else if (!enrollmentOpen) {
            System.out.println(
                    "Enrollment is closed"
            );
        } else if (accountBlocked) {
            System.out.println(
                    "Blocked account cannot enroll"
            );
        } else {
            System.out.println(
                    "Enrollment allowed"
            );
        }
    }
}
```

Output:

```text
Enrollment allowed
```

# Interactive Grade Program

```java
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner =
                new Scanner(System.in);

        System.out.print(
                "Enter your mark: "
        );

        int mark =
                Integer.parseInt(
                        scanner
                                .nextLine()
                                .strip()
                );

        if (mark < 0 || mark > 100) {
            System.out.println(
                    "Invalid mark"
            );
        } else if (mark >= 80) {
            System.out.println("Grade: A");
        } else if (mark >= 70) {
            System.out.println("Grade: B");
        } else if (mark >= 60) {
            System.out.println("Grade: C");
        } else if (mark >= 50) {
            System.out.println("Grade: D");
        } else if (mark >= 40) {
            System.out.println("Grade: E");
        } else {
            System.out.println("Grade: F");
        }

        scanner.close();
    }
}
```

# Test Boundary Values

When testing conditional logic, do not test only normal values. Also test values around the boundaries where a condition changes.

If the rule is:

```java
age >= 18
```

Test:

```text
17
18
19
```

For a mark range:

```text
0 to 100
```

Test:

```text
-1
0
1
99
100
101
```

For grade boundaries:

```text
39
40
69
70
79
80
```

This helps identify off-by-one and incorrect condition-order bugs.

# Important Terms

### Conditional Statement

Controls execution flow based on a condition.

### Condition

A boolean expression.

### Branch

A possible execution path selected by a condition.

### `if`

Executes a block when its condition is true.

### `else`

Executes an alternative block when its associated condition is false.

### `else-if`

Checks multiple mutually exclusive conditions.

### Nested Condition

A conditional statement inside another conditional block.

### Range Validation

Checks whether a value is within minimum and maximum boundaries.

### Boundary Value

A test value near the point where a condition changes.

# Practice Exercise 1: Even or Odd

Take an integer and print:

```text
Even
```

or:

```text
Odd
```

# Practice Exercise 2: Positive, Negative, or Zero

For an integer, determine whether it is:

```text
Positive
Negative
Zero
```

# Practice Exercise 3: Valid Mark

A mark is valid from:

```text
0 to 100
```

Write a boolean expression and print the result.

# Practice Exercise 4: Grade Calculator

Rules:

```text
80–100 → A
70–79  → B
60–69  → C
50–59  → D
40–49  → E
0–39   → F
```

Handle invalid marks.

# Practice Exercise 5: Login Decision

```java
boolean userExists = true;
boolean passwordCorrect = false;
boolean accountLocked = false;
```

Show a specific result:

* User not found
* Incorrect password
* Account locked
* Login successful

# Practice Exercise 6: Enrollment Eligibility

Rules:

* Minimum age `18`
* Email verified
* Enrollment open
* Account is not blocked

Use `else-if` to show a specific failure reason.

# Practice Exercise 7: Multiple Independent Conditions

For a mark, independently check:

* Whether the student passed
* Whether the student received distinction

Passing mark:

```text
40
```

Distinction:

```text
80
```

# Practice Exercise 8: Boundary Testing

For the grade calculator, test:

```text
39
40
69
70
79
80
100
101
```

Write the expected result for each input.

# Knowledge Check

## Question 1

What is conditional execution?

## Question 2

What type must the result of an `if` condition be?

## Question 3

When does an `if` block execute?

## Question 4

When does `else` execute?

## Question 5

How many branches can execute in an `else-if` chain?

## Question 6

Can multiple independent `if` blocks execute?

## Question 7

Why is condition order important?

## Question 8

What expression checks whether a mark is within `0–100`?

## Question 9

What expression checks whether a mark is outside the valid range?

## Question 10

What do `&&`, `||`, and `!` do?

## Question 11

What is a nested `if`?

## Question 12

Which method should be used to compare String content?

## Question 13

Why is `name != null && !name.isBlank()` safe?

## Question 14

Why is boundary value testing useful?

# Knowledge Check Answers

## Answer 1

Conditional execution means executing or skipping code depending on the result of a condition.

## Answer 2

```text
boolean
```

## Answer 3

When the condition is `true`.

## Answer 4

When the associated `if` and previous `else-if` conditions are false.

## Answer 5

At most one matching branch executes.

## Answer 6

Yes.

## Answer 7

An `else-if` chain is evaluated from top to bottom, and after the first matching branch executes, the remaining branches are skipped.

## Answer 8

```java
mark >= 0
&& mark <= 100
```

## Answer 9

```java
mark < 0
|| mark > 100
```

## Answer 10

* `&&` — all conditions must be true
* `||` — at least one condition must be true
* `!` — reverses a boolean value

## Answer 11

A conditional statement inside another conditional block.

## Answer 12

```java
equals()
```

For case-insensitive comparison:

```java
equalsIgnoreCase()
```

## Answer 13

If `name` is null, the first condition becomes false and short-circuit evaluation prevents `isBlank()` from being called.

## Answer 14

Boundary value testing helps detect incorrect comparisons and off-by-one errors near the points where conditions change.

# Lesson Summary

In this lesson, we learned:

* Conditional statements control a program's execution path
* Conditions must produce boolean results
* `if` executes a block when its condition is true
* `if-else` handles two alternative paths
* `else-if` handles multiple mutually exclusive outcomes
* After the first matching `else-if` branch, the remaining branches are skipped
* Condition order is important
* Multiple `if` statements can be used for independent conditions
* `&&`, `||`, and `!` combine or reverse conditions
* Numeric ranges can be validated using lower and upper boundaries
* Mathematical chained comparisons are not valid Java
* Nested `if` statements can handle context-dependent decisions
* `.equals()` should be used to compare String content
* A `null` check should happen before calling a method on a possibly null value
* Extra semicolons and incorrect condition ordering are common bugs
* Testing boundary values is important for conditional logic

Conditional Statements

Switch Expressions and Statements

# For Loops

## Lesson Overview

In a program, we often need to perform the same task multiple times.

For example:

* Print numbers from `1` to `10`
* Display a message several times
* Add several values
* Create a multiplication table
* Read every character of a String

Instead of manually writing the same statement repeatedly, Java provides **loops**.

When the number of repetitions is known in advance or iteration is controlled using a counter, a `for` loop is very useful.

In this lesson, we will learn:

* Loops and iterations
* `for` loop syntax
* Initialization, condition, and update
* Forward and backward counting
* Custom step sizes
* Accumulators
* Even and odd numbers
* Multiplication tables
* String traversal
* Nested loops
* Infinite loops
* Off-by-one errors

## Learning Objectives

After completing this lesson, you will be able to:

* Explain loops and iterations
* Write a basic `for` loop
* Understand initialization, condition, and update
* Count forward and backward
* Use custom step sizes
* Calculate sums and counts using loops
* Iterate through String characters
* Understand basic nested loops
* Identify infinite loops and off-by-one errors

# What Is a Loop?

A loop is a control-flow structure that executes a block of code multiple times.

Without a loop:

```java
System.out.println("Java");
System.out.println("Java");
System.out.println("Java");
```

Using a loop:

```java
for (int count = 1; count <= 3; count++) {
    System.out.println("Java");
}
```

Output:

```text
Java
Java
Java
```

# What Is an Iteration?

Each execution of the loop body is called an **iteration**.

```java
for (int count = 1; count <= 3; count++) {
    System.out.println(count);
}
```

There are three iterations:

```text
Iteration 1 → count = 1
Iteration 2 → count = 2
Iteration 3 → count = 3
```

Output:

```text
1
2
3
```

# Basic `for` Loop Syntax

```java
for (initialization; condition; update) {
    // Repeated statements
}
```

Example:

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

A basic `for` loop has three parts:

1. Initialization
2. Condition
3. Update

# Initialization

```java
int number = 1
```

This executes once before the loop begins.

Here, the counter starts at `1`.

# Condition

```java
number <= 5
```

The condition is checked before every iteration.

* If it is `true`, the loop body executes
* If it is `false`, the loop ends

# Update

```java
number++
```

This executes after every iteration.

Here, `number` increases by `1` after each iteration.

# Execution Flow

```java
for (int number = 1; number <= 3; number++) {
    System.out.println(number);
}
```

Execution:

```text
number = 1
1 <= 3 → true
Print 1
number becomes 2

2 <= 3 → true
Print 2
number becomes 3

3 <= 3 → true
Print 3
number becomes 4

4 <= 3 → false
Stop
```

Output:

```text
1
2
3
```

# Loop Counter

A variable used to control a loop is called a counter.

```java
for (int count = 1; count <= 5; count++) {
    System.out.println(count);
}
```

Here:

```text
count
```

is the counter.

For small index-based loops, `i` is conventional:

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

When the meaning is important, use a descriptive name:

```java
for (
        int lessonNumber = 1;
        lessonNumber <= 5;
        lessonNumber++
) {
    System.out.println(
            "Lesson " + lessonNumber
    );
}
```

# Forward Counting

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

Output:

```text
1
2
3
4
5
```

# Counting from Zero

In programming, indexes often start from `0`.

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

Output:

```text
0
1
2
3
4
```

The loop executes five times.

# `<` vs. `<=`

```java
for (int number = 1; number < 5; number++) {
    System.out.println(number);
}
```

Output:

```text
1
2
3
4
```

But:

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

Output:

```text
1
2
3
4
5
```

Difference:

```text
< 5  → 5 excluded
<= 5 → 5 included
```

# Backward Counting

Use `--` to decrease the counter.

```java
for (int number = 5; number >= 1; number--) {
    System.out.println(number);
}
```

Output:

```text
5
4
3
2
1
```

# Countdown

```java
for (int second = 5; second >= 1; second--) {
    System.out.println(second);
}

System.out.println("Start");
```

Output:

```text
5
4
3
2
1
Start
```

# Custom Step Size

The counter does not need to change by exactly `1` on every iteration.

## Increase by Two

```java
for (int number = 0; number <= 10; number += 2) {
    System.out.println(number);
}
```

Output:

```text
0
2
4
6
8
10
```

## Increase by Five

```java
for (int number = 5; number <= 25; number += 5) {
    System.out.println(number);
}
```

Output:

```text
5
10
15
20
25
```

## Decrease by Two

```java
for (int number = 10; number >= 0; number -= 2) {
    System.out.println(number);
}
```

Output:

```text
10
8
6
4
2
0
```

# Printing Even Numbers

You can iterate through every number and check a condition:

```java
for (int number = 1; number <= 10; number++) {
    if (number % 2 == 0) {
        System.out.println(number);
    }
}
```

Output:

```text
2
4
6
8
10
```

But when the pattern is already known:

```java
for (int number = 2; number <= 10; number += 2) {
    System.out.println(number);
}
```

is more direct.

# Printing Odd Numbers

```java
for (int number = 1; number <= 10; number += 2) {
    System.out.println(number);
}
```

Output:

```text
1
3
5
7
9
```

# Accumulator

A variable can be used to collect results across loop iterations.

This is called an accumulator.

```java
int total = 0;

for (int number = 1; number <= 5; number++) {
    total += number;
}

System.out.println(total);
```

Output:

```text
15
```

Calculation:

```text
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
```

# Why Does a Sum Accumulator Start at `0`?

For addition:

```text
0 + number = number
```

Therefore, a sum accumulator generally starts with:

```java
int total = 0;
```

# Counting Matching Values

An accumulator can be used not only for sums but also for counting.

```java
int evenCount = 0;

for (int number = 1; number <= 10; number++) {
    if (number % 2 == 0) {
        evenCount++;
    }
}

System.out.println(
        "Even numbers: " + evenCount
);
```

Output:

```text
Even numbers: 5
```

# Sum of Even Numbers

```java
int total = 0;

for (int number = 2; number <= 10; number += 2) {
    total += number;
}

System.out.println(total);
```

Output:

```text
30
```

# Multiplication Table

```java
int number = 5;

for (
        int multiplier = 1;
        multiplier <= 10;
        multiplier++
) {
    int result =
            number * multiplier;

    System.out.println(
            number
            + " × "
            + multiplier
            + " = "
            + result
    );
}
```

Output:

```text
5 × 1 = 5
5 × 2 = 10
5 × 3 = 15
5 × 4 = 20
5 × 5 = 25
5 × 6 = 30
5 × 7 = 35
5 × 8 = 40
5 × 9 = 45
5 × 10 = 50
```

# Calculating an Average

```java
int total = 0;
int numberCount = 5;

for (
        int number = 1;
        number <= numberCount;
        number++
) {
    total += number;
}

double average =
        total / (double) numberCount;

System.out.println(
        "Average: " + average
);
```

Output:

```text
Average: 3.0
```

# Iterating Through String Characters

String characters can be accessed by index.

```java
String language = "Java";

for (
        int index = 0;
        index < language.length();
        index++
) {
    char character =
            language.charAt(index);

    System.out.println(character);
}
```

Output:

```text
J
a
v
a
```

# Why Use `< length()`?

String:

```text
Java
```

Length:

```text
4
```

Valid indexes:

```text
0
1
2
3
```

Therefore:

```java
index < language.length()
```

is correct.

Wrong:

```java
index <= language.length()
```

because on the last iteration, the index becomes `4`, and:

```java
language.charAt(4)
```

is not valid.

# Printing Index and Character

```java
String word = "Loop";

for (
        int index = 0;
        index < word.length();
        index++
) {
    System.out.println(
            index
            + ": "
            + word.charAt(index)
    );
}
```

Output:

```text
0: L
1: o
2: o
3: p
```

# Counting a Character

```java
String value = "Java Foundation";
int aCount = 0;

for (
        int index = 0;
        index < value.length();
        index++
) {
    char character =
            value.charAt(index);

    if (
            character == 'a'
            || character == 'A'
    ) {
        aCount++;
    }
}

System.out.println(
        "A count: " + aCount
);
```

Output:

```text
A count: 3
```

# Nested `for` Loop

A loop inside another loop is called a nested loop.

```java
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 2; column++) {
        System.out.println(
                "Row "
                + row
                + ", Column "
                + column
        );
    }
}
```

Output:

```text
Row 1, Column 1
Row 1, Column 2
Row 2, Column 1
Row 2, Column 2
Row 3, Column 1
Row 3, Column 2
```

# How Does a Nested Loop Work?

For each iteration of the outer loop, the inner loop runs through its complete cycle.

```text
row = 1
    column = 1
    column = 2

row = 2
    column = 1
    column = 2

row = 3
    column = 1
    column = 2
```

Total inner executions:

```text
3 × 2 = 6
```

# Simple Rectangle Pattern

```java
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 4; column++) {
        System.out.print("*");
    }

    System.out.println();
}
```

Output:

```text
****
****
****
```

Nested loops are commonly useful for understanding grids, tables, or two-dimensional repetition.

# Loop Variable Scope

A counter declared inside the loop header is not accessible outside the loop.

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

Outside this loop:

```java
System.out.println(number);
```

is not valid.

If the counter is needed only for the loop, it is better to declare it inside the loop header.

# Infinite Loop

A loop that does not naturally terminate is called an infinite loop.

Accidental example:

```java
for (int number = 1; number <= 5; number--) {
    System.out.println(number);
}
```

The counter becomes:

```text
1
0
-1
-2
...
```

The condition:

```java
number <= 5
```

does not become false.

Correct:

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

# Wrong Direction in a Backward Loop

Wrong:

```java
for (int number = 5; number >= 1; number++) {
    System.out.println(number);
}
```

The counter keeps increasing.

Correct:

```java
for (int number = 5; number >= 1; number--) {
    System.out.println(number);
}
```

# Off-by-One Error

When a loop executes one time more or one time fewer than expected, it is called an off-by-one error.

Expected:

```text
1
2
3
4
5
```

Wrong:

```java
for (int number = 1; number < 5; number++) {
    System.out.println(number);
}
```

Output:

```text
1
2
3
4
```

Correct:

```java
number <= 5
```

# Off-by-One Error with String Indexes

Wrong:

```java
String word = "Java";

for (
        int index = 0;
        index <= word.length();
        index++
) {
    System.out.println(
            word.charAt(index)
    );
}
```

On the final iteration:

```text
index = 4
```

But the last valid index is:

```text
3
```

Correct:

```java
index < word.length()
```

# Extra Semicolon After `for`

Wrong:

```java
for (int number = 1; number <= 5; number++); {
    System.out.println("Java");
}
```

The semicolon creates an empty loop body.

Correct:

```java
for (int number = 1; number <= 5; number++) {
    System.out.println("Java");
}
```

# Updating the Counter Again Inside the Body

Confusing:

```java
for (int number = 1; number <= 10; number++) {
    System.out.println(number);

    number++;
}
```

The counter increases twice during every iteration.

Output:

```text
1
3
5
7
9
```

If you want to increase by two, make the intent clear in the loop header:

```java
for (
        int number = 1;
        number <= 10;
        number += 2
) {
    System.out.println(number);
}
```

# Tracing a Loop

When understanding or debugging a loop, it can be useful to write down the values for every iteration.

```java
int total = 0;

for (int number = 1; number <= 3; number++) {
    total += number;
}
```

Trace:

| Iteration | `number` | `total` before | `total` after |
| --------: | -------: | -------------: | ------------: |
|         1 |        1 |              0 |             1 |
|         2 |        2 |              1 |             3 |
|         3 |        3 |              3 |             6 |

Final:

```text
total = 6
```

# Complete Example

```java
public class Main {

    public static void main(String[] args) {
        int total = 0;
        int evenCount = 0;

        for (
                int number = 1;
                number <= 10;
                number++
        ) {
            total += number;

            if (number % 2 == 0) {
                evenCount++;
            }
        }

        double average =
                total / 10.0;

        System.out.println(
                "Total: " + total
        );

        System.out.println(
                "Average: " + average
        );

        System.out.println(
                "Even numbers: "
                + evenCount
        );
    }
}
```

Output:

```text
Total: 55
Average: 5.5
Even numbers: 5
```

# When Should You Use a `for` Loop?

A `for` loop is a good choice when:

* The repetition count is known
* The start and end are known
* A counter is needed
* A numeric range needs to be iterated
* String indexes need to be traversed
* A fixed number of repetitions is required

Examples:

```text
Print 1–100
Repeat a message 5 times
Read each String index
Generate a multiplication table
```

# Important Terms

### Loop

Executes a block of code multiple times.

### Iteration

One execution of the loop body.

### Initialization

Creates the initial state before the loop begins.

### Condition

Determines whether the loop should continue.

### Update

Changes the counter after each iteration.

### Counter

A variable used to control a loop.

### Accumulator

Collects results across iterations.

### Nested Loop

A loop inside another loop.

### Infinite Loop

A loop that does not terminate as expected.

### Off-by-One Error

An error where an incorrect boundary causes a loop to execute one time too many or one time too few.

# Practice Exercise 1: Print 1 to 10

Use a `for` loop to print:

```text
1
2
3
4
5
6
7
8
9
10
```

# Practice Exercise 2: Reverse Counting

Print from `10` down to `1`.

# Practice Exercise 3: Even Numbers

Print the even numbers from `1` to `20`.

# Practice Exercise 4: Odd Numbers

Print the odd numbers from `1` to `20`.

# Practice Exercise 5: Sum

Calculate the sum of the numbers from `1` to `100`.

Expected:

```text
5050
```

# Practice Exercise 6: Multiplication Table

Print the multiplication table of a number from `1` to `10`.

# Practice Exercise 7: Character Traversal

```java
String word = "Java";
```

Print each character on a separate line.

# Practice Exercise 8: Count a Character

```java
String text = "Java Foundation";
```

Count how many times `a` or `A` appears.

# Practice Exercise 9: Rectangle

Use a nested loop to create:

```text
****
****
****
```

# Practice Exercise 10: Fix the Loop

```java
for (
        int number = 1;
        number <= 10;
        number--
) {
    System.out.println(number);
}
```

Explain why the loop does not end and fix it.

# Practice Exercise 11: Fix the Index

```java
String text = "Java";

for (
        int index = 0;
        index <= text.length();
        index++
) {
    System.out.println(
            text.charAt(index)
    );
}
```

Fix the error.

# Practice Exercise 12: Trace the Loop

```java
int total = 0;

for (
        int number = 2;
        number <= 8;
        number += 2
) {
    total += number;
}
```

Write the value of:

* `number`
* `total`

for each iteration.

# Knowledge Check

## Question 1

What is a loop?

## Question 2

What is an iteration?

## Question 3

What are the three main parts of a `for` loop?

## Question 4

How many times does initialization execute?

## Question 5

When is the condition checked?

## Question 6

When does the update execute?

## Question 7

What does `number++` do?

## Question 8

What does `number += 2` do?

## Question 9

What is the difference between `<` and `<=`?

## Question 10

What is generally used for backward counting?

## Question 11

What is an accumulator?

## Question 12

What value does a sum accumulator generally start with?

## Question 13

What is the last valid index of a String?

## Question 14

What is a common condition for traversing a String?

## Question 15

What is a nested loop?

## Question 16

If the outer loop executes `3` times and the inner loop executes `2` times for each outer iteration, how many times does the inner body execute in total?

## Question 17

What is an infinite loop?

## Question 18

What is an off-by-one error?

# Knowledge Check Answers

## Answer 1

A loop is a control-flow structure that executes a block of code multiple times.

## Answer 2

Each execution of the loop body is an iteration.

## Answer 3

* Initialization
* Condition
* Update

## Answer 4

Once, before the loop starts.

## Answer 5

Before every iteration.

## Answer 6

After the body of each successful iteration executes.

## Answer 7

It increases the variable's value by `1`.

## Answer 8

It increases the variable's value by `2`.

## Answer 9

`< limit` excludes the limit, while `<= limit` includes the limit.

## Answer 10

Usually decrement:

```java
number--
```

## Answer 11

A variable used to collect or update a result while loop iterations execute.

## Answer 12

```text
0
```

## Answer 13

```java
text.length() - 1
```

## Answer 14

```java
index < text.length()
```

## Answer 15

A loop inside another loop.

## Answer 16

```text
3 × 2 = 6
```

## Answer 17

A loop that does not terminate as expected.

## Answer 18

An error where an incorrect boundary condition causes a loop to execute one time more or one time fewer than expected.

# Lesson Summary

In this lesson, we learned:

* Loops execute repeated code
* Each execution is an iteration
* A `for` loop consists of initialization, condition, and update
* Initialization executes once
* The condition is checked before each iteration
* The update executes after the loop body
* A counter can move forward or backward
* Custom step sizes can be used
* `<` and `<=` change loop boundaries
* An accumulator can collect a sum or count
* Even and odd numbers can be processed using loops
* Multiplication tables can be generated
* String characters can be iterated using indexes
* String traversal commonly uses `index < length()`
* Nested loops handle two levels of repetition
* Incorrect conditions or update directions can create infinite loops
* Boundary mistakes can create off-by-one errors
* A counter should not be modified unnecessarily inside the loop body
* Trace tables help understand and debug loops

For Loops

While and Do-While Loops

# Break and Continue

## Lesson Overview

A loop normally continues until its condition becomes false.

However, sometimes we need to:

* Stop a loop immediately when a target value is found
* Skip an invalid value and move to the next iteration
* Stop a menu when the user selects exit
* Stop unnecessary work after a search result is found
* Control execution inside nested loops

In Java, two main statements are used to change the normal flow of a loop:

* `break`
* `continue`

In this lesson, we will learn:

* `break`
* `continue`
* Early loop termination
* Search loops
* Invalid value filtering
* A common `continue` pitfall with `while` loops
* Nested loop control
* The basic concept of labeled `break` and `continue`

## Learning Objectives

After completing this lesson, you will be able to:

* Terminate a loop early using `break`
* Skip the current iteration using `continue`
* Stop a search loop when a result is found
* Skip invalid values
* Exit a controlled infinite loop
* Understand how `break` and `continue` behave in nested loops
* Identify common loop-control mistakes

# What Is Loop Control?

A loop-control statement changes the normal execution flow of a loop.

Normal loop:

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);
}
```

Output:

```text
1
2
3
4
5
```

Using `break`, the loop can end early:

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        break;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
```

Using `continue`, only one iteration is skipped:

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        continue;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
4
5
```

# `break`

`break` immediately terminates the nearest loop.

Syntax:

```java
break;
```

Example:

```java
for (int number = 1; number <= 10; number++) {
    if (number == 5) {
        break;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
3
4
```

When:

```java
number == 5
```

becomes true, the loop stops.

# `break` Ends Only the Loop

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        break;
    }

    System.out.println(number);
}

System.out.println("Loop finished");
```

Output:

```text
1
2
Loop finished
```

`break` does not terminate the entire program.

It only terminates the current loop.

# The Position of `break` Matters

## `break` Before Printing

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        break;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
```

## `break` After Printing

```java
for (int number = 1; number <= 5; number++) {
    System.out.println(number);

    if (number == 3) {
        break;
    }
}
```

Output:

```text
1
2
3
```

Statement order changes the result.

# `break` in a Search Loop

Suppose we need to find the index of the first `'F'` character in a String.

```java
String text = "Java Foundation";
char target = 'F';

int foundIndex = -1;

for (
        int index = 0;
        index < text.length();
        index++
) {
    if (text.charAt(index) == target) {
        foundIndex = index;

        break;
    }
}

System.out.println(
        "Found index: " + foundIndex
);
```

Output:

```text
Found index: 5
```

Once the target is found, there is no need to check the remaining characters.

Therefore, `break` is very useful in search loops.

# Checking Whether a Target Was Found

```java
String text = "Learn Java";
char target = 'J';

boolean found = false;

for (
        int index = 0;
        index < text.length();
        index++
) {
    if (text.charAt(index) == target) {
        found = true;

        break;
    }
}

System.out.println(
        "Found: " + found
);
```

Output:

```text
Found: true
```

# Using `break` in an Infinite Loop

Intentional infinite loop:

```java
int number = 1;

while (true) {
    System.out.println(number);

    if (number == 5) {
        break;
    }

    number++;
}
```

Output:

```text
1
2
3
4
5
```

`while (true)` does not terminate on its own.

Here, `break` acts as the exit condition.

# Sentinel and `break`

Suppose:

```text
-1
```

is the signal to end an input sequence.

```java
int total = 0;

while (true) {
    System.out.print(
            "Enter a number or -1 to stop: "
    );

    int number =
            Integer.parseInt(
                    scanner
                            .nextLine()
                            .strip()
            );

    if (number == -1) {
        break;
    }

    total += number;
}
```

Important:

```java
if (number == -1) {
    break;
}
```

appears before processing.

Therefore, the sentinel is not added to the total.

# `continue`

`continue` does not terminate the entire loop.

It skips the remaining statements in the current iteration and moves to the next iteration.

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        continue;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
4
5
```

The iteration for `3` is skipped.

# How Does `continue` Work?

In a `for` loop:

```java
for (initialization; condition; update) {
    if (skipCondition) {
        continue;
    }

    // Remaining statements
}
```

When `continue` executes:

1. The remaining body of the current iteration is skipped
2. The update expression executes
3. The condition is checked again
4. The next iteration begins

# Even Numbers with `continue`

```java
for (int number = 1; number <= 10; number++) {
    if (number % 2 != 0) {
        continue;
    }

    System.out.println(number);
}
```

Output:

```text
2
4
6
8
10
```

The odd numbers are skipped.

# Skipping Invalid Values

```java
int total = 0;

for (int number = -3; number <= 5; number++) {
    if (number < 0) {
        continue;
    }

    total += number;
}

System.out.println(total);
```

Processed values:

```text
0
1
2
3
4
5
```

Output:

```text
15
```

# Using `continue` as a Guard

Suppose you want to process only even numbers.

Nested style:

```java
for (int number = 1; number <= 10; number++) {
    if (number % 2 == 0) {
        int square =
                number * number;

        System.out.println(
                number + " -> " + square
        );
    }
}
```

Using `continue`:

```java
for (int number = 1; number <= 10; number++) {
    if (number % 2 != 0) {
        continue;
    }

    int square =
            number * number;

    System.out.println(
            number + " -> " + square
    );
}
```

Output:

```text
2 -> 4
4 -> 16
6 -> 36
8 -> 64
10 -> 100
```

Skipping invalid or irrelevant cases early can often make the main logic flatter and easier to read.

# `continue` in a `while` Loop

When using `continue` in a `while` loop, the counter update must be handled carefully.

Correct:

```java
int number = 0;

while (number < 5) {
    number++;

    if (number == 3) {
        continue;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
4
5
```

The counter is updated before `continue`.

# Infinite Loop Caused by `continue`

Wrong:

```java
int number = 1;

while (number <= 5) {
    if (number == 3) {
        continue;
    }

    System.out.println(number);

    number++;
}
```

When:

```text
number = 3
```

then:

```text
continue
```

executes.

Therefore:

```java
number++;
```

is skipped.

`number` remains `3`, and the loop continues indefinitely.

# Safer `while` Structure

```java
int number = 0;

while (number < 5) {
    number++;

    if (number == 3) {
        continue;
    }

    System.out.println(number);
}
```

Updating first avoids this particular problem.

# `break` vs. `continue`

| Statement  | Effect                           |
| ---------- | -------------------------------- |
| `break`    | Terminates the nearest loop      |
| `continue` | Skips only the current iteration |

## `break`

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        break;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
```

## `continue`

```java
for (int number = 1; number <= 5; number++) {
    if (number == 3) {
        continue;
    }

    System.out.println(number);
}
```

Output:

```text
1
2
4
5
```

# Nested Loops and `break`

A normal `break` terminates only the nearest loop.

```java
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 3; column++) {
        if (column == 2) {
            break;
        }

        System.out.println(
                row + ", " + column
        );
    }
}
```

Output:

```text
1, 1
2, 1
3, 1
```

The inner loop ends at `column == 2` for each row.

The outer loop continues.

# Nested Loops and `continue`

```java
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 3; column++) {
        if (column == 2) {
            continue;
        }

        System.out.println(
                row + ", " + column
        );
    }
}
```

Output:

```text
1, 1
1, 3
2, 1
2, 3
3, 1
3, 3
```

Only the `column == 2` iteration of the inner loop is skipped.

# Labeled `break`

Java supports labels when you need to exit an outer loop from inside a nested loop.

```java
search:
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 3; column++) {
        if (
                row == 2
                && column == 3
        ) {
            break search;
        }

        System.out.println(
                row + ", " + column
        );
    }
}
```

`break search;` terminates the labeled outer loop.

As a beginner, you only need to recognize the concept.

Using labels more than necessary can make control flow difficult to follow.

# Labeled `continue`

Java also supports labeled `continue` to move to the next iteration of an outer loop.

```java
outer:
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 3; column++) {
        if (column == 2) {
            continue outer;
        }

        System.out.println(
                row + ", " + column
        );
    }
}
```

Output:

```text
1, 1
2, 1
3, 1
```

When column `2` is reached, the remaining work for the current row is skipped and the next row begins.

Labeled control flow is uncommon. If the problem can be solved using simpler loop logic, prefer that approach.

# Complete Example: Search First Match

```java
public class Main {

    public static void main(String[] args) {
        String text =
                "Production Java";

        char target = 'J';

        int foundIndex = -1;

        for (
                int index = 0;
                index < text.length();
                index++
        ) {
            if (
                    text.charAt(index)
                    != target
            ) {
                continue;
            }

            foundIndex = index;

            break;
        }

        if (foundIndex >= 0) {
            System.out.println(
                    "Found at index: "
                    + foundIndex
            );
        } else {
            System.out.println(
                    "Character not found"
            );
        }
    }
}
```

Output:

```text
Found at index: 11
```

Here:

* Non-matching character → `continue`
* Match found → store the index
* Remaining search is unnecessary → `break`

# Common Mistakes

## Code After `break`

Wrong:

```java
if (number == 3) {
    break;

    System.out.println("Stopped");
}
```

The statement after `break` cannot execute.

Correct:

```java
if (number == 3) {
    System.out.println("Stopped");

    break;
}
```

## Code After `continue`

Wrong:

```java
if (number == 3) {
    continue;

    System.out.println("Skipped");
}
```

The statement after `continue` does not execute in the current iteration.

## Expecting `break` to End Every Nested Loop

```java
for (int row = 1; row <= 3; row++) {
    for (int column = 1; column <= 3; column++) {
        if (column == 2) {
            break;
        }
    }
}
```

Only the inner loop ends.

## Checking the Sentinel After Processing It

Wrong:

```java
total += number;

if (number == -1) {
    break;
}
```

This adds `-1` to the total.

Correct:

```java
if (number == -1) {
    break;
}

total += number;
```

## Wrong `continue` Condition

Requirement:

> Skip invalid marks.

Wrong:

```java
if (
        mark >= 0
        && mark <= 100
) {
    continue;
}
```

This skips valid marks.

Correct:

```java
if (
        mark < 0
        || mark > 100
) {
    continue;
}
```

## Skipping the `while` Update

Wrong:

```java
int number = 1;

while (number <= 5) {
    if (number == 3) {
        continue;
    }

    number++;
}
```

When `number == 3`, the counter no longer updates.

This can cause an infinite loop.

# When Should You Use `break`?

`break` is useful when:

* A search result has been found
* An exit option is selected
* A sentinel is received
* Remaining iterations are unnecessary
* The exit condition of an intentional infinite loop has been reached

# When Should You Use `continue`?

`continue` is useful when:

* An invalid value should be skipped
* The current item should not be processed
* Filtering is required
* You want to write the main processing block without unnecessary nesting

# Do Not Overuse Them

A loop containing many `break` and `continue` statements can become difficult to follow.

Hard to follow:

```java
for (...) {
    if (...) {
        continue;
    }

    if (...) {
        break;
    }

    if (...) {
        continue;
    }
}
```

Prefer:

* Clear conditions
* Meaningful boolean variables
* Small loop bodies
* Simple control flow

# Important Terms

### Loop Control

Changing the normal execution flow of a loop.

### `break`

Immediately terminates the nearest loop.

### `continue`

Skips the remaining statements of the current iteration.

### Early Termination

Ending a loop before its normal condition becomes false.

### Filtering

Skipping values that should not be processed.

### Labeled `break`

Exits up to a named outer loop.

### Labeled `continue`

Starts the next iteration of a named outer loop.

# Practice Exercise 1: Stop Before Five

Run a loop from `1` to `10`.

Stop the loop when `5` is reached.

Expected:

```text
1
2
3
4
```

# Practice Exercise 2: Include Five

Stop the loop after printing `5`.

Expected:

```text
1
2
3
4
5
```

# Practice Exercise 3: Skip Five

Print from `1` to `10`, but do not print `5`.

# Practice Exercise 4: Even Numbers

Use `continue` to skip odd numbers from `1` to `20` and print only even numbers.

# Practice Exercise 5: Character Search

```java
String text =
        "Java Foundation";
```

Find the index of the first `'a'` character and stop the loop as soon as a match is found.

# Practice Exercise 6: Sentinel Total

The user enters numbers.

When `-1` is entered, stop the loop.

Do not add the sentinel to the total.

# Practice Exercise 7: Fix the Infinite Loop

```java
int number = 1;

while (number <= 5) {
    if (number == 3) {
        continue;
    }

    System.out.println(number);

    number++;
}
```

Explain the problem and fix it.

# Practice Exercise 8: Nested `break`

Create a `3 × 3` nested loop.

For each row, stop the inner loop when column `2` is reached.

Expected:

```text
1, 1
2, 1
3, 1
```

# Practice Exercise 9: Labeled `break`

Inside a nested loop, exit both loops when the coordinate:

```text
2, 3
```

is found.

# Practice Exercise 10: Filtering

Iterate through the numbers from `1` to `20`.

Skip numbers that are not divisible by `3`.

Print only the divisible numbers.

# Knowledge Check

## Question 1

What does `break` do?

## Question 2

What does `continue` do?

## Question 3

Does `break` terminate the entire program?

## Question 4

Does `continue` terminate the entire loop?

## Question 5

Why is `break` useful in a search loop?

## Question 6

What executes after `continue` in a `for` loop?

## Question 7

Why can `continue` cause an infinite loop in a `while` loop?

## Question 8

Which loop does a normal `break` terminate in a nested loop?

## Question 9

What does labeled `break` do?

## Question 10

What does labeled `continue` do?

## Question 11

When should a sentinel be checked?

## Question 12

Which statement is useful for filtering invalid values?

## Question 13

What is the main difference between `break` and `continue`?

## Question 14

What problem can occur if `break` or `continue` is overused?

# Knowledge Check Answers

## Answer 1

It immediately terminates the nearest loop.

## Answer 2

It skips the remaining statements of the current iteration and moves to the next iteration.

## Answer 3

No. It terminates only the nearest loop.

## Answer 4

No.

## Answer 5

Once the target is found, unnecessary remaining iterations can be stopped.

## Answer 6

The `for` loop's update expression executes, then the condition is checked again.

## Answer 7

If the counter update appears after `continue`, that update can be skipped, causing the condition variable to remain stuck at the same value.

## Answer 8

The nearest or innermost loop.

## Answer 9

It can terminate execution up to a named outer loop.

## Answer 10

It can start the next iteration of a named outer loop.

## Answer 11

Before processing the sentinel as normal data.

## Answer 12

```java
continue;
```

## Answer 13

`break` terminates the loop, while `continue` skips only the current iteration.

## Answer 14

Control flow can become harder to read, debug, and maintain.

# Lesson Summary

In this lesson, we learned:

* `break` immediately terminates the nearest loop
* `continue` skips the remaining code of the current iteration
* `break` does not terminate the entire program
* `break` is useful when a search result is found
* A sentinel should be checked before it is processed
* `break` can be used to exit an intentional infinite loop
* `continue` is useful for skipping invalid or irrelevant values
* `continue` can help keep the main loop logic flatter
* In a `for` loop, `continue` moves execution to the update expression
* In a `while` loop, skipping an update with `continue` can create an infinite loop
* In nested loops, a normal `break` terminates only the nearest loop
* Labeled `break` can exit an outer loop
* Labeled `continue` can move to the next iteration of an outer loop
* Labels are uncommon and should be used carefully
* The position of `break` and `continue` changes program behavior
* Excessive loop-control statements can make code harder to understand

Break, Continue, and Loop Control

Project: Build a Console-Based Grade Calculator

Programming and Java Fundamentals

## Lesson Overview

As a program grows, keeping all logic inside the `main()` method becomes difficult.

Writing the same code repeatedly also creates duplication.

For example:

```java
System.out.println("====================");
System.out.println("LiveKlass");
System.out.println("====================");
```

If the same header is needed in different parts of a program, these statements may have to be written repeatedly.

Methods help solve this problem.

A method is:

> A named block of code that performs a specific task.

Using methods, we can:

* Reuse repeated logic
* Divide a large program into smaller tasks
* Clearly express the intent of code
* Reduce duplication
* Make a program easier to read and maintain

In this lesson, we will learn:

* What a method is
* Method declaration
* Method call
* `void` methods
* Basic use of `static`
* Method execution flow
* Method naming
* Method reuse
* Dividing a program into methods
* Common method-related mistakes

We will learn about parameters and return values in the next lesson.

## Learning Objectives

After completing this lesson, you will be able to:

* Explain what a method is
* Declare a simple method
* Call a method
* Distinguish between declaration and invocation
* Understand the basic meaning of `void`
* Trace method execution flow
* Reuse a method multiple times
* Choose meaningful method names
* Extract meaningful behavior from a large block of code

# What Is a Method?

A method is a named block of code that performs a specific task.

Example:

```java
static void greet() {
    System.out.println(
            "Welcome to LiveKlass!"
    );
}
```

Here:

```text
greet
```

is the method name.

The method body:

```java
{
    System.out.println(
            "Welcome to LiveKlass!"
    );
}
```

contains the work performed by the method.

# Method Call

Declaring a method does not execute it.

To run the method's behavior, you must call it:

```java
greet();
```

Complete example:

```java
public class Main {

    public static void main(String[] args) {
        greet();
    }

    static void greet() {
        System.out.println(
                "Welcome to LiveKlass!"
        );
    }
}
```

Output:

```text
Welcome to LiveKlass!
```

# Method Declaration and Method Call

These are two different concepts.

## Declaration

Defines what the method does:

```java
static void greet() {
    System.out.println("Hello!");
}
```

## Call

Tells Java to execute the method:

```java
greet();
```

# Declaring a Method Does Not Run It

```java
public class Main {

    public static void main(String[] args) {
        System.out.println(
                "Program started"
        );
    }

    static void greet() {
        System.out.println("Hello!");
    }
}
```

Output:

```text
Program started
```

`Hello!` is not printed.

Why?

Because:

```java
greet();
```

was never called.

# Method Structure

In this lesson, we will use this simple method pattern:

```java
static void methodName() {
    // Statements
}
```

Example:

```java
static void showMenu() {
    System.out.println("1. Courses");
    System.out.println("2. Exit");
}
```

# `static`

Our `main()` method is:

```java
public static void main(String[] args)
```

In this lesson, we will also write helper methods as `static`:

```java
static void greet() {
}
```

This allows us to call a method in the same class directly from `main()`:

```java
greet();
```

We will understand what `static` means and how it relates to objects in more detail when we learn about classes and objects.

For now, remember it as part of our method declaration pattern.

# `void`

```java
void
```

means that the method does not return a result value to the caller.

Example:

```java
static void printWelcomeMessage() {
    System.out.println("Welcome!");
}
```

This method performs an action:

```text
Print a message
```

but it does not return a value.

Return values will be covered in the next lesson.

# Method Name

A method name should describe its behavior.

Good:

```java
showMenu()
printHeader()
showCourses()
displayResult()
```

Weak:

```java
doIt()
thing()
abc()
x()
```

A meaningful name helps the reader understand what the method is going to do.

# Method Naming Convention

Java method names generally use `lowerCamelCase`.

Good:

```java
showMenu()
printWelcomeMessage()
displayCourseList()
```

Avoid:

```java
ShowMenu()
show_menu()
SHOWMENU()
```

# Verb-Based Names

Methods usually represent actions.

Therefore, a verb or verb phrase is a good default.

Examples:

```java
printHeader()
showCourses()
displayResult()
calculateTotal()
validateInput()
```

In this lesson, we are focusing on action-based methods without parameters or return values.

# Parentheses

A method declaration has parentheses after the method name:

```java
greet()
```

In this lesson, the parentheses are empty:

```java
greet()
```

because the method does not receive any input.

In the next lesson, we will see how calls such as:

```java
greet("Sakib");
```

work.

# Curly Braces

The method body is placed inside curly braces:

```java
static void greet() {
    System.out.println("Hello");
    System.out.println("Welcome");
}
```

Both statements are part of the `greet()` method.

# Calling a Method Multiple Times

One major benefit of methods is reuse.

```java
public class Main {

    public static void main(String[] args) {
        greet();
        greet();
        greet();
    }

    static void greet() {
        System.out.println("Hello!");
    }
}
```

Output:

```text
Hello!
Hello!
Hello!
```

The method is declared once but called three times.

# Methods Reduce Duplication

Without a method:

```java
System.out.println("====================");
System.out.println("LiveKlass");
System.out.println("====================");

System.out.println("1. Java");
System.out.println("2. Backend");

System.out.println("====================");
System.out.println("LiveKlass");
System.out.println("====================");
```

The header is duplicated.

## Refactored Version

```java
public class Main {

    public static void main(String[] args) {
        printHeader();

        System.out.println("1. Java");
        System.out.println("2. Backend");

        printHeader();
    }

    static void printHeader() {
        System.out.println(
                "===================="
        );

        System.out.println(
                "LiveKlass"
        );

        System.out.println(
                "===================="
        );
    }
}
```

Now the header logic exists in one place.

# Methods Make Intent Clearer

Compare these examples.

Without a method:

```java
System.out.println("1. Java");
System.out.println("2. Backend");
System.out.println("3. Exit");
```

With a method:

```java
showMenu();
```

By reading `showMenu()`, you can immediately understand what the program is doing.

If you need the implementation details, you can look at the method body.

# `main()` Is Also a Method

We have been using this code from the beginning:

```java
public static void main(String[] args)
```

This is also a method.

When a standard Java application starts, the JVM begins execution from:

```java
main()
```

High-level breakdown:

```text
public        → access modifier
static        → static method
void          → no returned value
main          → method name
String[] args → parameter
```

We will study some of these pieces in more detail later.

# Method Execution Flow

Example:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("A");

        greet();

        System.out.println("C");
    }

    static void greet() {
        System.out.println("B");
    }
}
```

Output:

```text
A
B
C
```

Execution flow:

```text
main starts
↓
Print A
↓
Call greet()
↓
Print B
↓
greet() finishes
↓
Continue in main
↓
Print C
```

# What Happens When a Method Is Called?

When Java sees:

```java
greet();
```

execution moves to the body of the `greet()` method.

```java
static void greet() {
    System.out.println("B");
}
```

When the method finishes, execution continues in the calling method from the statement after the method call.

# One Method Can Call Another Method

```java
public class Main {

    public static void main(String[] args) {
        startApplication();
    }

    static void startApplication() {
        showLogo();
        showMenu();
    }

    static void showLogo() {
        System.out.println("LiveKlass");
    }

    static void showMenu() {
        System.out.println("1. Courses");
        System.out.println("2. Exit");
    }
}
```

Execution:

```text
main()
↓
startApplication()
↓
showLogo()
↓
showMenu()
```

# A Method Can Be Called Even If Its Declaration Appears Later in the Source File

This code is valid:

```java
public class Main {

    public static void main(String[] args) {
        greet();
    }

    static void greet() {
        System.out.println("Hello!");
    }
}
```

Even though the `greet()` declaration appears after `main()`, Java can resolve the method.

# Dividing a Program into Small Tasks

Suppose a program needs to:

```text
Show welcome message
Show course list
Show enrollment confirmation
```

We can write:

```java
public class Main {

    public static void main(String[] args) {
        showWelcomeMessage();
        showCourses();
        showEnrollmentConfirmation();
    }

    static void showWelcomeMessage() {
        System.out.println(
                "Welcome to LiveKlass!"
        );
    }

    static void showCourses() {
        System.out.println(
                "Available courses:"
        );

        System.out.println(
                "1. Java and OOP Foundation"
        );

        System.out.println(
                "2. Backend Development"
        );
    }

    static void showEnrollmentConfirmation() {
        System.out.println(
                "Enrollment completed."
        );
    }
}
```

Now `main()` shows the high-level program flow:

```text
Welcome
→ Courses
→ Confirmation
```

# One Method, One Clear Purpose

A method should ideally represent one coherent task.

Reasonable:

```java
static void showCourseDetails() {
    System.out.println(
            "Course: Java"
    );

    System.out.println(
            "Level: Beginner"
    );

    System.out.println(
            "Language: Bangla"
    );
}
```

All of these statements represent one concept:

```text
Show course details
```

# Not Every Line Needs a Method

Over-complicated:

```java
static void printA() {
    System.out.println("A");
}

static void printB() {
    System.out.println("B");
}

static void printC() {
    System.out.println("C");
}
```

Simply creating methods does not automatically make code better.

A method is useful when it:

* Represents a meaningful task
* Encapsulates repeated behavior
* Gives a clear name to a complex section
* Divides a large method into understandable parts

# Method Extraction

Moving a meaningful block of existing code into a new method is commonly called **Extract Method**.

Before:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("================");
        System.out.println("LiveKlass");
        System.out.println("================");

        System.out.println("Java Course");
    }
}
```

After:

```java
public class Main {

    public static void main(String[] args) {
        printHeader();

        System.out.println(
                "Java Course"
        );
    }

    static void printHeader() {
        System.out.println("================");
        System.out.println("LiveKlass");
        System.out.println("================");
    }
}
```

Now the intent of `main()` is clearer.

# When Is Method Extraction Useful?

Useful signals include:

* The same logic is repeated
* Several statements together form a clear task
* A code block can be given a meaningful name
* A method performs many unrelated tasks
* The main program flow is getting lost among implementation details

# A Local Variable Is Not Available Outside Its Method

Example:

```java
static void showCourse() {
    String courseName =
            "Java and OOP Foundation";

    System.out.println(
            courseName
    );
}
```

This variable:

```text
courseName
```

is accessible only within the local scope of the method.

Invalid:

```java
public static void main(String[] args) {
    showCourse();

    System.out.println(
            courseName
    );
}
```

We will study variable scope in more detail later.

# Methods Are Declared Inside a Class

Correct:

```java
public class Main {

    static void greet() {
        System.out.println("Hello");
    }
}
```

The method declaration appears inside the class body.

# A Method Cannot Be Declared Inside Another Method

Invalid:

```java
public static void main(String[] args) {

    static void greet() {
        System.out.println("Hello");
    }
}
```

Correct:

```java
public class Main {

    public static void main(String[] args) {
        greet();
    }

    static void greet() {
        System.out.println("Hello");
    }
}
```

# Common Mistakes

## Forgetting `()` in a Method Call

Wrong:

```java
greet;
```

Correct:

```java
greet();
```

## Declaring a Method but Never Calling It

```java
static void greet() {
    System.out.println("Hello");
}
```

This does not execute by itself.

Call it:

```java
greet();
```

## Wrong Method Name

Declared:

```java
static void showMenu() {
}
```

Wrong:

```java
showMenus();
```

The method name must match exactly.

## Declaring a Method Inside Another Method

Wrong:

```java
public static void main(String[] args) {

    static void showMessage() {
    }
}
```

Keep method declarations at the class level.

## Omitting the Return Type

Wrong:

```java
static greet() {
    System.out.println("Hello");
}
```

Correct:

```java
static void greet() {
    System.out.println("Hello");
}
```

## Using a Local Variable Outside Its Method

```java
static void createMessage() {
    String message = "Hello";
}
```

Invalid:

```java
System.out.println(message);
```

if that code appears in another method.

# Complete Example

```java
public class Main {

    public static void main(String[] args) {
        showHeader();
        showCourses();
        showFooter();
    }

    static void showHeader() {
        System.out.println(
                "======================"
        );

        System.out.println(
                "LiveKlass"
        );

        System.out.println(
                "======================"
        );
    }

    static void showCourses() {
        System.out.println(
                "Available Courses"
        );

        System.out.println(
                "1. Java and OOP Foundation"
        );

        System.out.println(
                "2. Backend Development"
        );
    }

    static void showFooter() {
        System.out.println(
                "======================"
        );

        System.out.println(
                "Learn. Live. Grow."
        );
    }
}
```

`main()` now clearly shows the program structure:

```text
showHeader()
showCourses()
showFooter()
```

# Important Terms

### Method

A named block of code that performs a specific task.

### Method Declaration

Defines a method's structure and behavior.

### Method Call

Executes a declared method.

### `void`

Indicates that the method does not return a result value.

### Method Body

The statements inside the method's curly braces.

### Local Variable

A variable declared inside a method.

### Method Extraction

Moving a meaningful block of code into a separate method.

# Practice Exercise 1: Greeting Method

Write a method:

```java
static void greet()
```

that prints:

```text
Welcome to Java!
```

Then call it three times from `main()`.

# Practice Exercise 2: Extract Duplicate Code

Extract this repeated block into a method:

```java
System.out.println("----------------");
System.out.println("Java");
System.out.println("----------------");
```

Method name:

```java
printHeader()
```

# Practice Exercise 3: Predict the Output

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("1");

        first();

        System.out.println("4");
    }

    static void first() {
        System.out.println("2");

        second();
    }

    static void second() {
        System.out.println("3");
    }
}
```

What will the output be?

# Practice Exercise 4: Fix the Program

Identify the problem:

```java
public class Main {

    public static void main(String[] args) {

        static void showMessage() {
            System.out.println("Hello");
        }

        showMessage();
    }
}
```

Write the correct structure.

# Practice Exercise 5: Break into Methods

Divide this program into three methods:

```text
showHeader()
showCourses()
showFooter()
```

Original:

```java
public class Main {

    public static void main(String[] args) {
        System.out.println("LiveKlass");
        System.out.println("----------------");

        System.out.println("1. Java");
        System.out.println("2. Backend");
        System.out.println("3. System Design");

        System.out.println("----------------");
        System.out.println("Learn. Live. Grow.");
    }
}
```

# Knowledge Check

## Question 1

What is a method?

## Question 2

What is the difference between a method declaration and a method call?

## Question 3

What does `void` mean?

## Question 4

Does declaring a method automatically execute it?

## Question 5

Can a method be called multiple times?

## Question 6

Can one method call another method?

## Question 7

Where does execution continue after a called method finishes?

## Question 8

Why are meaningful method names useful?

## Question 9

Where is a normal Java method declared?

## Question 10

Should every statement be placed in a separate method?

## Question 11

When is method extraction useful?

## Question 12

Is `main()` a method?

# Knowledge Check Answers

## Answer 1

A named block of code that performs a specific task or behavior.

## Answer 2

A declaration defines what the method does. A call executes the method's code.

## Answer 3

The method does not return a result value to the caller.

## Answer 4

No. The method must be called.

## Answer 5

Yes.

## Answer 6

Yes.

## Answer 7

Execution continues from the statement after the method call in the calling method.

## Answer 8

They communicate what behavior the method performs without requiring the reader to open the implementation.

## Answer 9

Inside a class and outside other methods.

## Answer 10

No. A method should represent a meaningful responsibility or reusable behavior.

## Answer 11

When logic is repeated, a block has a clear purpose, or large code needs to be divided into meaningful parts.

## Answer 12

Yes.

```java
public static void main(String[] args)
```

is a Java method.

# Lesson Summary

In this lesson, we learned:

* A method is a named block of behavior
* Methods help organize code
* Methods can reuse repeated logic
* Method declaration and method call are different
* A declared method does not execute automatically
* Parentheses are required when calling a method
* `void` means the method does not return a result value
* At this stage, we write helper methods as `static`
* A method can be called multiple times
* One method can call another method
* When a called method finishes, execution returns to the caller
* Meaningful method names communicate program intent
* Methods help divide large programs into smaller tasks
* Not every statement needs to become a method
* Method declarations appear inside a class
* A normal method cannot be declared inside another method
* A local variable is not accessible outside its method scope
* `main()` is itself a method

Introduction to Methods

Parameters, Arguments, and Return Values

Scope, Static Methods, and Method Overloading

Introduction to Arrays

Traversing and Working with Arrays

Two-Dimensional and Multidimensional Arrays

The Arrays Utility Class and Common Array Operations

Introduction to Recursion

Methods, Arrays, and Program Structure

## Lesson Overview

Object-Oriented Programming, or **OOP**, is not simply about creating classes, making fields `private`, or writing getters and setters.

OOP is an approach to organizing and modeling a program through meaningful **objects**.

An object generally has:

* State
* Behavior
* Identity
* A clear responsibility

In a small program, it is possible to keep all data and logic inside the `main()` method.

```java
public class Main {

    public static void main(String[] args) {
        String learnerName =
                "Nur";

        int completedLessons =
                16;

        int totalLessons =
                20;

        double progress =
                completedLessons
                * 100.0
                / totalLessons;

        System.out.println(
                learnerName
                + " completed "
                + progress
                + "% of the course."
        );
    }
}
```

This code is simple and readable.

However, as an application grows, we may need to handle:

```text
Learners
Courses
Lessons
Enrollments
Progress
Payments
Assessments
Certificates
```

If we keep adding more variables and conditions, the code becomes difficult to manage.

OOP helps us organize related state and behavior into meaningful units.

## Learning Objectives

After completing this lesson, you will be able to:

* Explain the purpose of OOP
* Understand the conceptual difference between a class and an object
* Identify state, behavior, and identity
* Understand object responsibility
* Understand the difference between procedural and object-oriented thinking
* Identify possible objects from a simple requirement
* Recognize the basic purpose of encapsulation, abstraction, inheritance, and polymorphism
* Avoid common beginner OOP misconceptions

# Why Do We Need OOP?

Suppose we are building a learning platform.

A learner has enrolled in a course.

We need to track:

```text
Learner name
Course title
Completed lessons
Total lessons
Enrollment status
```

For one learner, keeping separate variables is easy:

```java
String learnerName =
        "Nur";

String courseTitle =
        "Java and OOP Foundation";

int completedLessons =
        16;

int totalLessons =
        20;

boolean enrollmentActive =
        true;
```

However, with multiple learners and courses, this approach quickly becomes messy.

Example:

```java
String firstLearnerName =
        "Nur";

int firstCompletedLessons =
        16;

String secondLearnerName =
        "Sakib";

int secondCompletedLessons =
        18;
```

As an application grows, problems may include:

* Related values becoming separated
* Updating the wrong learner's data
* Duplicating the same rule in multiple places
* Rewriting the same calculation repeatedly
* Difficulty understanding which code is responsible for which business concept

OOP helps us think in terms of separate concepts:

```text
Learner
Course
Enrollment
```

# Procedural Thinking vs. Object-Oriented Thinking

Procedural thinking usually asks:

> What steps need to be executed?

Example:

```text
1. Read completed lessons
2. Read total lessons
3. Calculate progress
4. Print the result
```

Object-oriented thinking asks:

> Which object owns this data, and which object should be responsible for this behavior?

Example:

```text
Enrollment
- Knows completed lessons
- Knows total lessons
- Calculates progress
- Updates progress
```

Neither approach is always better.

For a small calculation, procedural code may be simpler.

But when related state, rules, and behavior grow, object-oriented organization becomes useful.

# What Is an Object?

An object is a specific entity in a program.

Three important characteristics of an object are:

```text
State
Behavior
Identity
```

# State

State is the object's current data.

An enrollment's state might be:

```text
Learner: Nur
Course: Java and OOP Foundation
Completed lessons: 16
Total lessons: 20
Status: Active
```

State can change.

Before:

```text
Completed lessons: 16
```

After completing another lesson:

```text
Completed lessons: 17
```

# Behavior

Behavior represents meaningful actions an object can perform.

Possible enrollment behavior:

```text
Complete a lesson
Calculate progress
Cancel enrollment
Check whether the course is completed
```

In Java, behavior is represented using methods.

Conceptually:

```java
enrollment.completeLesson();

enrollment.calculateProgress();

enrollment.cancel();
```

# Identity

Identity helps distinguish which specific object we are working with.

Two enrollments may have the same state:

```text
Completed lessons: 10
Total lessons: 20
```

but still be different enrollments.

Example:

```text
Nur → Java
Sakib → Java
```

Even if both have the same progress, they are not the same enrollment.

This distinction is identity.

# What Is a Class?

A class is a custom type that defines the structure and behavior of objects.

Conceptually:

```text
Class:
Enrollment

Objects:
Nur's Java enrollment
Sakib's Java enrollment
Jalisa's Backend enrollment
```

A class can define:

* What data an object stores
* What behavior is available
* How state can change

A class is not a specific object.

It is the definition for objects of that type.

# Class vs. Object

| Class                   | Object                       |
| ----------------------- | ---------------------------- |
| Type or definition      | Actual instance              |
| Defines state structure | Holds actual state values    |
| Defines behavior        | Executes behavior            |
| `Course`                | A specific course object     |
| `Enrollment`            | A specific enrollment object |

Conceptual Java:

```java
Course javaCourse =
        new Course();

Enrollment nurEnrollment =
        new Enrollment();
```

Here:

```text
Course
Enrollment
```

are classes.

And:

```text
javaCourse
nurEnrollment
```

are references to objects.

We will study this syntax in detail in the next lesson.

# Responsibility

One of the most useful questions in OOP design is:

> Which object should be responsible for which task?

Suppose we need to calculate progress.

Possible owners:

```text
Learner
Course
Enrollment
Main
```

A learner can have different progress in different courses.

```text
Nur
Java    → 80%
Backend → 40%
```

Therefore, progress is not simply learner data.

A course can also have different progress for different learners.

```text
Java
Nur   → 80%
Sakib → 90%
```

Therefore, progress is not simply course data either.

Progress is part of the relationship between:

```text
Learner
+
Course
```

So `Enrollment` can be a natural owner of progress.

Conceptually:

```java
enrollment.calculateProgress();
```

# Modeling Simple Concepts

Possible objects in a learning platform might include:

```text
Learner
Course
Lesson
Enrollment
Payment
```

Each concept can have a different responsibility.

## Learner

Possible state:

```text
Name
Email
Account status
```

Possible behavior:

```text
Update profile
Deactivate account
```

## Course

Possible state:

```text
Title
Price
Publication status
```

Possible behavior:

```text
Publish
Change price
```

## Enrollment

Possible state:

```text
Learner
Course
Completed lessons
Status
```

Possible behavior:

```text
Complete lesson
Calculate progress
Cancel enrollment
```

# Keeping State and Behavior Together

Suppose:

```java
int completedLessons =
        20;

int totalLessons =
        18;
```

Both values are individually valid `int` values.

But together, the state is suspicious:

```text
Completed lessons > total lessons
```

If an object owns this state, its related behavior can enforce the rule whenever the state changes.

Conceptually:

```java
enrollment.completeLesson();
```

The method can decide whether another lesson is allowed to be completed.

This is stronger design than uncontrolled mutation.

A useful OOP idea is:

> The object that owns state can use its behavior to protect the rules of that state.

# OOP Is Not Only About Grouping Data

This class groups related data:

```java
public class Enrollment {

    String learnerName;
    String courseTitle;
    int completedLessons;
    int totalLessons;
}
```

That is a useful beginning.

But OOP does not end there.

If any code can write:

```java
enrollment.completedLessons =
        -10;
```

then the object is not protecting its own state.

Later, we will use meaningful methods and controlled access.

Example:

```java
enrollment.completeLesson();
```

# Encapsulation — Preview

The basic idea of encapsulation is:

> Keep related state and behavior together, and control how state is accessed or modified.

Example:

```java
course.changePrice(
        4990
);
```

The method can check whether the price is valid.

Encapsulation is not simply:

```text
private fields
+
getter
+
setter
```

Meaningful behavior and protecting valid state are more important.

We will implement encapsulation in a dedicated lesson.

# Abstraction — Preview

Abstraction exposes meaningful operations to the caller while hiding unnecessary internal details.

Example:

```java
course.publish();
```

The caller only needs to know:

```text
Publish the course
```

How the internal implementation works is not the caller's concern.

The goal of abstraction is:

> Clear intent, fewer unnecessary details.

# Inheritance — Preview

Inheritance allows one type to extend the structure or behavior of another type.

Conceptual example:

```text
User
├── Learner
└── Instructor
```

Inheritance can be useful, but it is not the starting point for learning OOP.

We will study inheritance in detail after classes and objects are clear.

# Polymorphism — Preview

Polymorphism allows different implementations of the same common operation.

Conceptually:

```text
EmailNotification
SmsNotification
PushNotification
```

All of them might support an operation such as:

```java
send();
```

but each type can behave differently.

We will study this in more detail later.

# Four Ideas at a Glance

At this stage, remember only the high-level purpose:

```text
Encapsulation
→ protect state and rules

Abstraction
→ hide unnecessary details

Inheritance
→ inherited relationships between related types

Polymorphism
→ same operation, different implementations
```

For now, understanding the foundation of classes and objects is more important than memorizing these terms.

# A First OOP Preview

The following code is only a preview:

```java
public class Enrollment {

    String learnerName;
    int completedLessons;
    int totalLessons;

    void completeLesson() {
        if (
                completedLessons
                >= totalLessons
        ) {
            return;
        }

        completedLessons++;
    }

    double calculateProgress() {
        if (totalLessons == 0) {
            return 0.0;
        }

        return completedLessons
                * 100.0
                / totalLessons;
    }
}
```

Usage:

```java
Enrollment enrollment =
        new Enrollment();

enrollment.learnerName =
        "Nur";

enrollment.completedLessons =
        16;

enrollment.totalLessons =
        20;

enrollment.completeLesson();

System.out.println(
        enrollment.calculateProgress()
);
```

Output:

```text
85.0
```

You do not need to memorize the entire code yet.

For now, observe:

```text
Enrollment object
↓
owns enrollment state
↓
provides enrollment behavior
```

# This Design Is Not Complete Yet

We are still directly writing:

```java
enrollment.completedLessons =
        16;
```

Later, we will see why limiting direct field mutation can be useful.

In upcoming lessons, we will improve this model through:

```text
Classes and objects
Fields and methods
Constructors
Encapsulation
Composition
Immutability
```

# Not Every Problem Needs OOP

A simple calculation:

```java
static int add(
        int first,
        int second
) {
    return first + second;
}
```

does not need a new class hierarchy.

OOP is more useful when a program contains:

* Related state
* Rules
* Multiple entities
* Changing state
* Relationships
* Meaningful responsibilities

The right tool depends on the problem.

# Common Beginner Misconceptions

## OOP Means Many Classes

No.

More classes do not automatically create better design.

A class is meaningful when it represents a coherent concept or responsibility.

## OOP Means Getters and Setters

No.

```java
setPrice(-500);
```

If an invalid price is accepted, a mechanical setter does not improve the design.

The goal of encapsulation is to protect state.

## Every Noun in a Requirement Must Become a Class

No.

Requirement:

```text
Course title
```

Here, `Course` may become a class.

But `title` may simply be a:

```java
String
```

field.

## OOP Replaces Loops and Conditions

No.

Methods inside objects will still contain:

```text
Variables
Conditions
Loops
Calculations
Algorithms
```

OOP does not replace fundamental programming logic.

## Inheritance Is the Main Goal of OOP

No.

Inheritance is one feature of OOP.

But clear responsibilities, encapsulation, and object relationships are more fundamental.

# Identifying Objects from a Requirement

Requirement:

> Nur enrolls in a Java course and completes lessons.

Possible concepts:

```text
Learner
Course
Enrollment
Lesson
```

# Step 1: Identify Important Concepts

Ask:

```text
What meaningful things is the program working with?
```

Possible:

```text
Learner
Course
Enrollment
```

# Step 2: Identify State

Example:

```text
Learner
- name
- email

Course
- title
- lesson count

Enrollment
- learner
- course
- completed lessons
- status
```

# Step 3: Identify Behavior

```text
Course
- publish

Enrollment
- complete lesson
- calculate progress
- cancel
```

# Step 4: Assign Responsibility

Ask:

```text
Who owns this data?

Who should perform this action?

Who should enforce this rule?
```

Examples:

```text
Course title
→ Course

Learner email
→ Learner

Enrollment progress
→ Enrollment
```

# Step 5: Think About Invalid States

Examples:

```text
Blank course title

Negative price

Completed lessons greater than total lessons
```

For now, simply identify invalid states.

Later, we will learn how to prevent them using constructors and methods.

# Practice Exercise 1: State and Behavior

For the `Course` concept, write:

* Four pieces of state
* Three possible behaviors

# Practice Exercise 2: Choose the Owner

Identify the natural owner of the following data:

```text
Learner email
Course title
Enrollment progress
Lesson duration
Payment status
```

Choose from:

```text
Learner
Course
Enrollment
Lesson
Payment
```

# Practice Exercise 3: Model an Enrollment

Do not write code.

Conceptually define:

```text
State
Behavior
Possible invalid states
```

# Practice Exercise 4: Procedural or Object-Oriented?

Explain which approach may be simpler for each problem:

1. Add two numbers
2. Manage course enrollment progress and cancellation
3. Convert Celsius to Fahrenheit
4. Manage account balance and withdrawal rules

# Practice Exercise 5: Responsibility Problem

Consider:

```java
public class Application {

    String learnerName;
    String courseTitle;
    long paymentAmount;
    int completedLessons;

    void publishCourse() {
    }

    void processPayment() {
    }

    void completeLesson() {
    }
}
```

What is the design problem with this class?

Identify possible focused concepts.

# Practice Exercise 6: Invalid States

Enrollment state:

```text
completedLessons
totalLessons
active
```

Identify at least three invalid or suspicious states.

# Knowledge Check

## Question 1

What is the basic purpose of OOP?

## Question 2

What are three important characteristics of an object?

## Question 3

What is state?

## Question 4

What is behavior?

## Question 5

What is identity?

## Question 6

What is the difference between a class and an object?

## Question 7

What does object responsibility mean?

## Question 8

Why might progress be the responsibility of `Enrollment`?

## Question 9

What is the basic purpose of encapsulation?

## Question 10

What does abstraction do?

## Question 11

What is the basic idea of inheritance?

## Question 12

What is the basic idea of polymorphism?

## Question 13

Is OOP the best solution for every problem?

## Question 14

Why is it useful to identify invalid states early?

# Knowledge Check Answers

## Answer 1

To organize related state, behavior, and responsibilities into meaningful objects.

## Answer 2

```text
State
Behavior
Identity
```

## Answer 3

The current data of an object.

## Answer 4

Meaningful actions the object can perform.

## Answer 5

The concept that distinguishes which specific object we are working with.

## Answer 6

A class is a type or definition. An object is an actual instance of that class.

## Answer 7

It describes which object should own particular data, perform particular behavior, and protect particular rules.

## Answer 8

Because progress belongs to the relationship between a specific learner and a specific course.

## Answer 9

To keep state and related behavior together and control how state is accessed or changed.

## Answer 10

It exposes meaningful operations to callers while hiding unnecessary implementation details.

## Answer 11

A type can inherit structure or behavior from another related type.

## Answer 12

Different types can implement the same common operation differently.

## Answer 13

No. A simple calculation or short procedural workflow may often be simpler.

## Answer 14

It helps determine which rules constructors and methods should enforce later.

# Lesson Summary

In this lesson, we learned:

* OOP is not only class syntax
* OOP is an approach to organizing state, behavior, and responsibilities
* Objects have state, behavior, and identity
* A class is the type or definition of an object
* An object is an actual instance of a class
* Procedural thinking focuses on steps
* Object-oriented thinking focuses on ownership and responsibility
* Keeping related state and behavior in the same object can be useful
* An object can protect the rules of its own state
* Encapsulation helps control state access and modification
* Abstraction hides unnecessary details
* Inheritance can model relationships between related types
* Polymorphism supports different implementations of the same operation
* OOP does not mean creating many classes or writing getters and setters
* Not every noun in a requirement needs to become a class
* OOP does not replace loops, conditions, or algorithms
* Good modeling begins by identifying concepts, state, behavior, responsibility, and invalid states

Introduction to Object-Oriented Design

Classes, Objects, Fields, and Methods

Constructors and Valid Object Creation

The `this` Keyword and Method Overloading

Encapsulation, Access Control, and Object Invariants

Static and Instance Members

Object References, `null`, Identity, Equality, and `toString()`

Composition and Object Relationships

Designing Immutable Objects

Packages and Organizing Java Code

Project: Build a Course Enrollment System

Object-Oriented Programming Foundations

Introduction to Inheritance

Parent Construction, `super`, and Inherited Access

Method Overriding and Runtime Polymorphism

Abstract Classes and Interfaces

Polymorphic Methods and Collections

Interfaces and Dependency Design

Inheritance Design Traps and Composition-Based Alternatives

Project: Polymorphic content system

Inheritance, Interfaces, and Polymorphism

Introduction to Generics and Type Safety

Working with `List`

Working with `Set`

Working with `Map`

Queues and FIFO Processing

Deque, Stack, and `ArrayDeque`

Iteration and Collection Operations

Designing Classes That Own Collections

Choosing the Right Collection

Generics, Collections, and Core Data Structures

Understanding Algorithmic Complexity and Big-O

Simple Sorting Algorithms

Merge Sort and Quick Sort

Linear Search and Binary Search

Java's Built-In Sorting and Searching APIs

Using Stacks, Queues, and Deques in Algorithms

Heaps and PriorityQueue

Hashing and Fast Lookup

Trees and Binary Search Tree Fundamentals

Algorithms and Problem Solving with Java

Lambda Expressions

Functional Interfaces and Method References

Introduction to the Stream API

Filtering, Mapping, and Transforming Streams

Collectors, Grouping, and Reduction

Optional and Modern Null Handling

The Modern Date and Time API

Modern Java Language Features

Records and Modern Data Models

Introduction to Concurrency and Thread Safety

Executors, Callable, Future, and CompletableFuture

Virtual Threads and Concurrent Collections

Modern Java

Enums and Domain States

Exceptions and Failure Handling

`try`, `catch`, `finally`, `throw`, and `throws`

Checked vs Unchecked Exceptions

Designing Custom Exceptions

Validation and Error-Handling Strategies

Building Reliable Failure Boundaries

Enums, Exceptions, and Robust Error Handling

Understanding Files, Paths, and Directories

Reading Text Files

Writing and Updating Text Files

Working with Streams and Buffers

Managing Resources with Try-With-Resources

File and Directory Operations

Designing a File-Based Repository

File Handling and I/O

Organizing Java Applications with Packages

Immutability and Defensive Programming

Equality, Hashing, and Object Contracts

Clean Methods and Class Design

Dependency Design and Composition

Refactoring a Small Java Application

Designing Clear APIs and Boundaries

Professional Java Practices

Project Overview

Building the Domain Model

Building Repository Contracts and Application Services

Implementing File-Based Persistence

Implementing File-Based Persistence - Part 2

Building the Console Application

Final Project Review and Hardening

Final Project Assessment and Course Completion

Final Project

Build a strong programming foundation with Java and learn how real software is designed using object-oriented principles.

Java and Object-Oriented Programming Foundation

Checking lesson access...