How Java Works JVM JRE JDK

Java was designed to solve a major software problem: how to write a program once and run it on many operating systems with minimal changes. In many languages, source code is compiled directly into machine code for one specific platform. Java uses a different model. A Java file is first compiled into bytecode, and that bytecode is executed by the JVM, or Java Virtual Machine. This design makes Java highly portable and ideal for enterprise systems that run across Windows, Linux, macOS, servers, containers, and cloud platforms.

The three most important terms beginners must understand are JDK, JRE, and JVM. The JDK (Java Development Kit) is for developers. It includes tools such as the compiler javac, debugger, and runtime components needed to build Java applications. The JRE (Java Runtime Environment) is for running Java programs. It includes the JVM and standard libraries. The JVM is the engine that actually loads, verifies, and runs bytecode. In modern Java distributions, the JDK typically includes everything needed, and separate JRE installations are less common than before.

In real life, this architecture is used in banking systems, e-commerce backends, Spring Boot microservices, large ERP systems, Android toolchains, and distributed server applications. The flow is simple: write source code in a .java file, compile it into a .class file, then execute it with the Java runtime. The JVM also provides memory management, garbage collection, security checks, and just-in-time compilation for better performance.

Step-by-Step Explanation

Here is the execution flow in order:

1. You write Java source code in a file such as Hello.java.
2. The JDK compiler javac converts the source code into bytecode stored in Hello.class.
3. The JVM loads the class file.
4. The JVM verifies bytecode for safety and correctness.
5. The program runs using Java libraries provided by the runtime.
6. Frequently used parts may be optimized by the JIT compiler into native machine code.

Think of it this way:

Source Code - what humans write
Bytecode - portable intermediate format
JVM - executes bytecode on the current machine
JRE - JVM + libraries to run programs
JDK - JRE + development tools to create programs

Comprehensive Code Examples

Basic example:

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

Compile with javac Hello.java and run with java Hello.

Real-world example:

public class EnvironmentInfo {
    public static void main(String[] args) {
        System.out.println("Java Version: " + System.getProperty("java.version"));
        System.out.println("JVM Name: " + System.getProperty("java.vm.name"));
        System.out.println("OS Name: " + System.getProperty("os.name"));
    }
}

This shows how the same Java program can inspect the runtime on any platform.

Advanced usage:

public class MemoryDemo {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        long mb = 1024 * 1024;

        System.out.println("Available processors: " + runtime.availableProcessors());
        System.out.println("Max memory: " + runtime.maxMemory() / mb + " MB");
        System.out.println("Total memory: " + runtime.totalMemory() / mb + " MB");
        System.out.println("Free memory: " + runtime.freeMemory() / mb + " MB");
    }
}

This example highlights that the JVM also manages runtime resources, not just execution.

Common Mistakes

• Confusing JDK with JRE. Fix: remember that developers install the JDK because it contains both runtime support and development tools.

• Trying to run a .java file with java File.java after using older workflows incorrectly. Fix: usually compile with javac first, then run the class name.

• Using the file name and class name differently. Fix: if the class is public class Hello, the file must be named Hello.java.

• Assuming Java runs directly as machine code. Fix: understand the bytecode-to-JVM model.

Best Practices

• Install a modern LTS JDK such as Java 17 or 21 for stable learning and enterprise relevance.

• Always verify your setup with java -version and javac -version.

• Learn the compile-and-run cycle early; it builds strong platform understanding.

• Use descriptive class names and keep one public class per file.

• Understand that the JVM adds portability, garbage collection, and runtime optimization.

Practice Exercises

• Create a file named TestSetup.java that prints a message confirming Java is installed correctly. Compile and run it.

• Write a program that prints the Java version, JVM name, and operating system name using system properties.

• Write a program that displays total memory and free memory using the Runtime class.

Mini Project / Task

Build a small “Java Environment Inspector” program that prints the Java version, vendor, JVM name, OS name, user directory, and available processors in a readable format.

Challenge (Optional)

Create a program that compares multiple system properties and explains, through printed output, which values come from the operating system and which come from the Java runtime.

Installation and Setup

Welcome to the foundational module of your Java development journey! Before we can write our first line of Java code, we need to set up our development environment. This involves installing the Java Development Kit (JDK) and configuring an Integrated Development Environment (IDE). The JDK is the core component that allows you to compile, run, and debug Java applications. It includes the Java Runtime Environment (JRE), which is necessary to run Java applications, and a set of development tools. An IDE, such as IntelliJ IDEA or Eclipse, provides a comprehensive environment for software development, offering features like code editing, debugging, build automation, and intelligent code completion, significantly boosting productivity. Properly setting up your environment is crucial for a smooth and efficient learning experience and professional development workflow.

The Java ecosystem is vast, and various versions of the JDK are available. For modern enterprise development, we typically use long-term support (LTS) versions like Java 11 or Java 17, or the latest stable release. These versions offer stability, performance improvements, and new language features. Understanding the difference between the JDK (Development Kit), JRE (Runtime Environment), and JVM (Virtual Machine) is fundamental. The JVM is the abstract computing machine that enables a computer to run a Java program. The JRE is an implementation of the JVM and provides the necessary libraries and components to run Java applications. The JDK includes the JRE plus development tools like the Java compiler (javac) and debugger (jdb).

Step-by-Step Explanation

Step 1: Download the Java Development Kit (JDK)
1. Go to Oracle's official JDK download page or OpenJDK distributions like Adoptium (formerly AdoptOpenJDK). For this guide, we'll use Adoptium as it provides free, open-source JDK builds.
2. Navigate to adoptium.net.
3. Select the latest LTS version (e.g., Java 17 or Java 21) for your operating system (Windows, macOS, Linux).
4. Download the appropriate installer (e.g., .msi for Windows, .dmg for macOS, .tar.gz or .deb/.rpm for Linux).

Step 2: Install the JDK

Windows:
1. Run the downloaded .msi installer.
2. Follow the on-screen instructions. Typically, you can accept the default installation path (e.g., C:\Program Files\Eclipse Adoptium\jdk-XX.X.X.YY).
3. Ensure that 'Set JAVA_HOME variable' and 'Add to PATH' options are selected if prompted, or you'll configure them manually later.

macOS:
1. Open the downloaded .dmg file.
2. Double-click the .pkg installer and follow the instructions.
3. The JDK is usually installed in /Library/Java/JavaVirtualMachines/.

Linux:
1. For .deb/.rpm packages, use your package manager (e.g., sudo apt install ).
2. For .tar.gz, extract it to a desired location (e.g., /opt/jdk-XX). Then, set up environment variables manually.

Step 3: Verify JDK Installation
1. Open your terminal or command prompt.
2. Type java -version and press Enter. You should see the Java version you just installed.
3. Type javac -version and press Enter. This verifies the Java compiler is available.

Step 4: Set JAVA_HOME (if not set automatically)

Windows:
1. Search for 'Environment Variables' and open 'Edit the system environment variables'.
2. Click 'Environment Variables...' button.
3. Under 'System variables', click 'New...'.
4. Variable name: JAVA_HOME
5. Variable value: Path to your JDK installation directory (e.g., C:\Program Files\Eclipse Adoptium\jdk-XX.X.X.YY). Click 'OK'.
6. Find the 'Path' variable under 'System variables', select it, and click 'Edit...'.
7. Click 'New' and add %JAVA_HOME%\bin. Move it up if necessary. Click 'OK' on all windows to close.

macOS/Linux:
1. Open your shell configuration file (e.g., ~/.bash_profile, ~/.zshrc, ~/.bashrc).
2. Add these lines (adjust path to your JDK):
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-XX.jdk/Contents/Home (macOS)
export PATH=$JAVA_HOME/bin:$PATH
3. Save the file and run source ~/.bash_profile (or your relevant file) to apply changes.

Step 5: Install an Integrated Development Environment (IDE)

IntelliJ IDEA (Recommended for enterprise development):
1. Go to jetbrains.com/idea/download/.
2. Download the Community Edition (free and open-source).
3. Run the installer and follow the on-screen instructions.

Eclipse:
1. Go to eclipse.org/downloads/.
2. Download the 'Eclipse IDE for Enterprise Java and Web Developers'.
3. Run the installer and follow the instructions.

Comprehensive Code Examples

Basic Example: Hello World in Java
This example demonstrates how to compile and run a simple Java program using the command line, verifying your JDK setup.
1. Create a file named HelloWorld.java in a new directory (e.g., C:\JavaProjects\HelloWorld or ~/JavaProjects/HelloWorld).

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

Real-world Example: Project Setup in IntelliJ IDEA
This shows how to create a basic Java project within an IDE.
1. Open IntelliJ IDEA.
2. Click 'New Project'.
3. In the New Project wizard:
- Select 'Java' on the left.
- For 'Project SDK', ensure your installed JDK (e.g., 17) is selected. If not, click 'Add SDK' and point to your JDK installation directory.
- Check 'Create project from template' and select 'Command Line App'.
- Click 'Next'.
- Enter 'Project name': MyFirstJavaApp
- Enter 'Base package': com.example.myapp
- Click 'Finish'.
4. IntelliJ will create a project structure including a src folder and a Main.java file.

package com.example.myapp;

public class Main {
    public static void main(String[] args) {
        System.out.println("Welcome to my first IntelliJ Java app!");
    }
}

Advanced Usage: Managing Multiple JDKs with SDKMAN! (Linux/macOS)
For developers working on multiple projects requiring different Java versions, a version manager like SDKMAN! is invaluable.
1. Install SDKMAN! (if not already installed):

   curl -s "https://get.sdkman.io" | bash
   source "$HOME/.sdkman/bin/sdkman-init.sh"
   

   sdk list java
   

   sdk install java 11.0.12-tem
   

   sdk default java 11.0.12-tem
   

   sdk use java 17.0.8-tem
   

Common Mistakes

• Mistake 1: Incorrect JAVA_HOME or PATH configuration.
      Symptom: 'java' is not recognized as an internal or external command or 'javac' is not recognized.
      Fix: Double-check your JAVA_HOME variable points to the JDK installation directory (e.g., C:\Program Files\Java\jdk-XX, NOT C:\Program Files\Java\jdk-XX\bin). Ensure that %JAVA_HOME%\bin (Windows) or $JAVA_HOME/bin (Linux/macOS) is correctly added to your system's PATH variable. Remember to restart your terminal or IDE after making changes to environment variables.


• Mistake 2: Installing JRE instead of JDK.
      Symptom: javac command not found, but java command works.
      Fix: The JRE only allows running Java programs, not compiling them. You need the JDK (Java Development Kit) for development. Uninstall the JRE if you accidentally installed it, and then install the full JDK.


• Mistake 3: Conflicting Java versions.
      Symptom: java -version shows an old version, or IDE uses a different JDK than expected.
      Fix: Ensure only one JDK is prioritized in your PATH. On Windows, the order of entries in PATH matters. On Linux/macOS, check your shell configuration file (.bashrc, .zshrc, etc.) for multiple JAVA_HOME exports. Use a version manager like SDKMAN! (Linux/macOS) or manually manage installations for clarity. In your IDE, always explicitly set the Project SDK.

Best Practices

• Use an LTS (Long-Term Support) JDK version: For stability and long-term project support, prefer LTS versions like Java 11 or Java 17. They receive extended maintenance and are widely adopted in enterprise environments.


• Utilize an IDE: While command-line compilation is good for understanding, an IDE (IntelliJ IDEA, Eclipse) is indispensable for professional development. It offers code completion, refactoring, debugging, and integration with build tools.


• Understand the Project SDK/Module SDK settings in your IDE: Always ensure your IDE is configured to use the correct JDK for your specific project. This is crucial when working on multiple projects with different Java versions.


• Keep your JDK updated (within LTS): Periodically update to the latest patch release of your chosen LTS JDK to benefit from security fixes and performance improvements.


• Set JAVA_HOME consistently: Ensure JAVA_HOME is correctly set as a system-wide environment variable, as many build tools (like Maven or Gradle) rely on it.

Practice Exercises

• Beginner-friendly: Write a Java program that prints your name and your favorite programming language to the console. Compile and run it using the command line.


• Based ONLY on this topic: After setting up your environment, create a new Java project in your chosen IDE. Modify the default Main.java file to calculate and print the sum of two numbers (e.g., 15 + 27). Run it from the IDE.


• Clear instructions: If you're on Linux/macOS, install a second JDK version using SDKMAN! (e.g., if you have Java 17, install Java 11). Then, switch your active Java version to the newly installed one and verify with java -version.

Mini Project / Task

Set up a complete Java development environment from scratch. This includes downloading and installing the latest LTS JDK, configuring JAVA_HOME and PATH variables, and installing a professional IDE (e.g., IntelliJ IDEA Community Edition). Once set up, create a new Java project in your IDE named 'SimpleCalculator'. Inside this project, write a Main class that has a main method which prints 'Calculator is ready!' to the console. Ensure you can compile and run this project successfully from within the IDE.

Challenge (Optional)

Research and understand the difference between OpenJDK and Oracle JDK. Explain in your own words when you might choose one over the other for an enterprise project. Additionally, explore how to configure your IDE to use a specific Maven or Gradle version that might be bundled with a project, and how that relates to your installed JDK.

Your First Java Program

Your first Java program is the starting point for understanding how Java code is written, organized, compiled, and executed. In real life, Java is used in enterprise backends, banking systems, e-commerce platforms, cloud services, Android-related tooling, and large internal business applications. Before building complex applications, every developer begins by learning how a basic Java file works. This first step matters because it introduces the standard structure of a Java class, the main method, and the output statement used to display information in the console.

A Java program exists because the language is designed to be explicit and structured. Unlike scripting languages that may run line by line, Java source code is compiled into bytecode and then executed by the Java Virtual Machine. That design gives Java portability, reliability, and strong tooling support. Your first program is usually a “Hello, World!” example, but the real purpose is not just printing text. It teaches the minimum valid structure of a Java application: a class, a method entry point, and a statement.

The main ideas here are simple. A class is a container for code. The main method is the entry point the JVM looks for when starting a program. System.out.println() prints output and moves the cursor to the next line. You will also notice Java is case-sensitive, so String and string are not the same. File naming is important too: if your class is named HelloWorld, the file should be named HelloWorld.java.

Step-by-Step Explanation

Start with a file named HelloWorld.java.
Write a class using the class keyword.
Inside the class, define the method public static void main(String[] args).
This exact signature tells Java where execution begins.
Inside main, add statements ending with semicolons.
Use System.out.println() to print text.
Compile with javac HelloWorld.java.
Run with java HelloWorld.

Syntax breakdown:
public means accessible from anywhere.
static means the method belongs to the class itself.
void means it returns no value.
String[] args stores command-line arguments.

Comprehensive Code Examples

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

public class GreetingApp {
    public static void main(String[] args) {
        System.out.println("Welcome to the company portal");
        System.out.println("System status: Online");
    }
}

public class StartupInfo {
    public static void main(String[] args) {
        System.out.println("Application starting...");
        System.out.println("Java version: " + System.getProperty("java.version"));
        System.out.println("OS: " + System.getProperty("os.name"));
    }
}

Common Mistakes

• Wrong file name: If the class is HelloWorld, the file must be HelloWorld.java.
• Incorrect capitalization: Writing string instead of String causes errors.
• Missing semicolon: Most Java statements must end with ;.
• Misspelling main: The JVM requires the exact method signature.
• Running the .java file directly: Compile with javac first, then run the class name with java.

Best Practices

• Use clear class names in PascalCase, such as HelloWorld or GreetingApp.
• Keep your first programs small and focused on one idea at a time.
• Read compiler errors carefully; they often point to the exact line and issue.
• Use an IDE like IntelliJ IDEA or VS Code, but also learn command-line compilation.
• Format braces and indentation consistently for readability.

Practice Exercises

• Create a Java program named MyIntro that prints your name and favorite hobby on separate lines.
• Write a program called SchoolMessage that prints a welcome message for new students.
• Create a program named ThreeLines that prints three different sentences using three System.out.println() statements.

Mini Project / Task

Build a small console program called CompanyBanner that prints a company name, a short slogan, and a startup status message when the application runs.

Challenge (Optional)

Create a Java program that prints a formatted startup report including the app name, Java version, and operating system using multiple output statements and string concatenation.

Project Structure and Packages

Project structure in Java is the organized layout of folders, source files, resources, and configuration files that make an application easy to build, navigate, test, and maintain. Packages are Java’s way of grouping related classes and interfaces into namespaces so names do not clash and code stays logically separated. In real life, teams use packages to divide features such as users, billing, orders, and security, while project structure helps tools like Maven, Gradle, IDEs, and CI pipelines understand where source code and tests belong. A clear structure matters because enterprise applications grow quickly. Without organization, developers waste time searching for files, duplicate logic, and accidentally create dependencies between unrelated parts of the system.

In Java, packages are declared at the top of a file using package. Common styles include domain-based naming such as com.company.app, feature-based grouping such as com.company.app.orders, and layered grouping such as controller, service, and repository. A typical project also contains source folders like src/main/java for application code and src/test/java for tests. Resources such as configuration files often live in src/main/resources. The package name should match the folder path. For example, a class in package com.example.billing should be stored in com/example/billing. This convention allows the compiler and build tools to work correctly.

Step-by-Step Explanation

Start by creating a root project folder. Inside it, create a standard source layout. Under src/main/java, create package folders based on your application name, usually in reverse domain format. Then create classes inside those folders. Each file begins with the package declaration, followed by imports, then the class definition. If one class needs another from a different package, add an import statement. Keep related classes together and avoid dumping everything into one package. For example, place entry-point classes in app, business logic in service, and data models in model. Tests should mirror the same package structure under src/test/java so they are easy to find.

Comprehensive Code Examples

Basic example

package com.example.hello;

public class Greeting {
    public String sayHello() {
        return "Hello, Java!";
    }
}

package com.example.app;

import com.example.hello.Greeting;

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting();
        System.out.println(greeting.sayHello());
    }
}

Real-world example

package com.company.store.model;

public class Product {
    private String name;

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

    public String getName() {
        return name;
    }
}

package com.company.store.service;

import com.company.store.model.Product;

public class ProductService {
    public void printProduct(Product product) {
        System.out.println("Product: " + product.getName());
    }
}

Advanced usage

package com.company.store;

import com.company.store.model.Product;
import com.company.store.service.ProductService;

public class StoreApplication {
    public static void main(String[] args) {
        Product product = new Product("Laptop");
        ProductService service = new ProductService();
        service.printProduct(product);
    }
}

This structure separates the application entry point, data model, and business logic. That makes future changes safer and easier for teams.

Common Mistakes

• Package name does not match folder path: fix by ensuring package com.example.util; is stored inside com/example/util.
• Putting all classes in one package: fix by splitting classes by feature or responsibility.
• Using uppercase or random package names: fix by using lowercase reverse-domain naming like com.company.project.
• Forgetting imports: fix by importing classes from other packages explicitly.

Best Practices

• Use standard project layout such as src/main/java and src/test/java.
• Name packages by organization and application, then by feature.
• Keep package names lowercase and meaningful.
• Avoid circular dependencies between packages.
• Mirror test packages to production packages for clarity.

Practice Exercises

• Create a project with package com.example.school and add a class named Student.
• Create two packages, model and service, then make one class in service use a class from model.
• Build a small source tree with src/main/java and src/test/java, and describe what belongs in each folder.

Mini Project / Task

Create a simple library management project with packages for model, service, and app. Add a Book class, a LibraryService class, and a Main class that prints book information.

Challenge (Optional)

Reorganize a messy Java project where all classes are in one folder into a clean feature-based package structure, and explain why your package design improves maintainability.

Variables and Constants

Variables and constants are the foundation of every Java program because they allow you to store data in memory and work with it later. A variable holds a value that can change while the program runs, such as a user name, price, counter, or temperature. A constant holds a value that should not change after it is assigned, such as tax rate, application name, or the number of days in a week. In real-life software, variables are used in forms, calculations, reports, APIs, games, banking systems, and inventory tools. Constants are used to prevent accidental changes to important fixed values and to make code easier to understand.

In Java, every variable has a data type, a name, and usually a value. Common primitive types include int for whole numbers, double for decimals, char for a single character, and boolean for true/false values. Java also supports reference types such as String. A variable may be declared first and assigned later, or both can happen in one statement. Constants are created using the final keyword. By convention, constant names are written in uppercase with underscores, such as MAX_USERS.

Step-by-Step Explanation

To create a variable, write the type first, then the variable name, then optionally assign a value using =. Example: int age = 25;. This means Java should reserve space for an integer called age and store the value 25. You can later change it using age = 26;. To create a constant, add final before the type: final double TAX_RATE = 0.18;. After that, Java will not allow reassignment. Variable names should be meaningful and follow camelCase, like studentCount or monthlySalary. Constants should be descriptive and stable.

Comprehensive Code Examples

public class Main {
    public static void main(String[] args) {
        int age = 22;
        double height = 5.9;
        char grade = 'A';
        boolean isEnrolled = true;
        String name = "Maya";

        System.out.println(name);
        System.out.println(age);
    }
}

public class StoreApp {
    public static void main(String[] args) {
        String productName = "Laptop";
        int quantity = 3;
        double pricePerUnit = 799.99;
        double totalCost = quantity * pricePerUnit;

        System.out.println("Product: " + productName);
        System.out.println("Total Cost: " + totalCost);
    }
}

public class CompanySettings {
    public static void main(String[] args) {
        final String COMPANY_NAME = "TechNova";
        final double TAX_RATE = 0.15;

        double orderAmount = 2000.0;
        double taxAmount = orderAmount * TAX_RATE;

        System.out.println(COMPANY_NAME);
        System.out.println("Tax: " + taxAmount);
    }
}

Common Mistakes

• Using a variable before assigning a value. Fix: always initialize local variables before reading them.

• Choosing the wrong data type, such as using int for decimal values. Fix: use double when fractions are needed.

• Trying to change a final constant. Fix: use constants only for values that must remain unchanged.

• Poor naming like x or a1. Fix: use clear names such as employeeSalary.

Best Practices

• Use meaningful variable names that explain purpose clearly.

• Initialize variables close to where they are used.

• Use final for values that should never change.

• Prefer constants for repeated fixed values instead of hardcoding numbers in many places.

• Follow Java naming conventions: camelCase for variables, uppercase with underscores for constants.

Practice Exercises

• Create variables to store a student's name, age, and exam score, then print them.

• Declare a constant for PI and a variable for radius, then calculate the area of a circle.

• Build a small program with product name, quantity, and unit price variables, then print the final total.

Mini Project / Task

Create a simple billing calculator that stores a customer name, item price, quantity, and a constant tax rate, then prints a formatted bill summary.

Challenge (Optional)

Write a program that stores employee details in variables and uses constants for bonus rate and working days, then calculates final monthly pay.

Data Types Primitive vs Reference

• byte: 8-bit signed two's complement integer. Range: -128 to 127.
• short: 16-bit signed two's complement integer. Range: -32,768 to 32,767.
• int: 32-bit signed two's complement integer. Range: -2^31 to 2^31-1. This is the default integer type.
• long: 64-bit signed two's complement integer. Range: -2^63 to 2^63-1. Used for very large integer values.
• float: 32-bit single-precision floating-point. Used for fractional numbers with monetary or scientific calculations where precision is less critical than `double`.
• double: 64-bit double-precision floating-point. This is the default floating-point type and offers higher precision.
• boolean: Represents one bit of information, but its size is not precisely defined. Can only be `true` or `false`.
• char: 16-bit Unicode character. Range: '' to '￿'.

Step-by-Step Explanation

Comprehensive Code Examples

public class PrimitiveTypesDemo {
    public static void main(String[] args) {
        int age = 25;
        double salary = 50000.75;
        boolean isActive = true;
        char initial = 'J';

        System.out.println("Age: " + age);
        System.out.println("Salary: " + salary);
        System.out.println("Active: " + isActive);
        System.out.println("Initial: " + initial);

        // Arithmetic operation
        int newAge = age + 5;
        System.out.println("New Age: " + newAge);
    }
}

public class ReferenceTypesDemo {
    public static void main(String[] args) {
        String greeting = "Hello, Java!";
        String anotherGreeting = new String("Hello, Java!");

        // Comparing content (for String, use .equals())
        System.out.println("Greetings are equal (content): " + greeting.equals(anotherGreeting));
        // Comparing references (memory addresses)
        System.out.println("Greetings are same object (reference): " + (greeting == anotherGreeting));

        // Custom object example
        Person person1 = new Person("Alice", 30);
        Person person2 = person1; // person2 now refers to the same object as person1

        System.out.println("Person 1 Name: " + person1.getName());
        System.out.println("Person 2 Name: " + person2.getName());

        person2.setName("Alicia"); // Modifying via person2 affects person1
        System.out.println("Person 1 Name after change: " + person1.getName());
    }
}

class Person {
    private String name;
    private int age;

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

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
}

public class ParameterPassingDemo {

    // Primitives are passed by value (a copy is made)
    public static void incrementPrimitive(int num) {
        num = num + 1; // This change is local to the method
        System.out.println("Inside method (primitive): " + num);
    }

    // Reference types are passed by value (a copy of the reference is made)
    // The copied reference still points to the original object.
    public static void changeObject(Person p) {
        p.setName("Bob"); // Changes the original object's state
        System.out.println("Inside method (object name): " + p.getName());
        p = new Person("Charlie", 40); // This reassigns the local reference 'p', not the original
        System.out.println("Inside method (new object name): " + p.getName());
    }

    public static void main(String[] args) {
        int myNumber = 10;
        System.out.println("Before method call (primitive): " + myNumber);
        incrementPrimitive(myNumber);
        System.out.println("After method call (primitive): " + myNumber); // Still 10

        Person originalPerson = new Person("David", 25);
        System.out.println("Before method call (object name): " + originalPerson.getName());
        changeObject(originalPerson);
        System.out.println("After method call (object name): " + originalPerson.getName()); // Will be Bob, not Charlie
    }
}

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

public class WrapperClassesDemo {
    public static void main(String[] args) {
        // Auto-boxing: primitive int to Integer object
        Integer numObject = 100;
        int numPrimitive = numObject; // Auto-unboxing: Integer object to primitive int

        System.out.println("Integer object: " + numObject);
        System.out.println("Primitive int: " + numPrimitive);

        // Using wrapper classes in collections
        List numbers = new ArrayList<>();
        numbers.add(1); // Auto-boxes 1 to new Integer(1)
        numbers.add(2);
        numbers.add(3);

        int sum = 0;
        for (Integer n : numbers) {
            sum += n; // Auto-unboxes n to int for addition
        }
        System.out.println("Sum of numbers: " + sum);

        // Demonstrating null for Integer (not possible for int)
        Integer nullableInt = null;
        System.out.println("Nullable Integer: " + nullableInt);

        // int cannot be null
        // int cannotBeNull = null; // Compile-time error
    }
}

Common Mistakes

Best Practices

• Choose appropriate types: Use the smallest primitive type that can hold your data to optimize memory, e.g., `byte` for small numbers, `int` for general integers, `double` for general floating-point.
• Prefer primitives for performance: When you only need to store a simple value and don't require object-oriented features, use primitive types. They are generally faster and consume less memory than their wrapper class counterparts.
• Use wrapper classes when necessary: Employ wrapper classes when working with Java Collections Framework (like `ArrayList`, `HashMap`), generics, or when you need to represent the absence of a value (`null`).
• Be mindful of immutability: Understand that `String` objects are immutable. Any operation that appears to modify a `String` actually creates a new `String` object. Custom reference types can be made immutable by careful design.
• Defensive programming with references: Always perform null checks before dereferencing objects that might be `null` to avoid `NullPointerException`s.

Practice Exercises

Mini Project / Task

Challenge (Optional)

String Manipulation

String manipulation in Java is the process of creating, reading, comparing, searching, splitting, joining, and transforming text. In real applications, strings are everywhere: usernames, email addresses, URLs, file paths, log messages, report content, API payloads, and user input from forms. Because text processing is so common, Java provides rich support through the String class and related tools such as StringBuilder and String.format().

A Java String is an immutable object, which means once it is created, its value cannot be changed. This design improves safety and predictability, but it also means repeated modifications can create many temporary objects. For simple text work, String methods such as length(), charAt(), substring(), contains(), replace(), split(), toLowerCase(), and toUpperCase() are enough. For heavy concatenation inside loops, StringBuilder is usually better because it is mutable and more efficient.

Java string manipulation is widely used in validation, parsing CSV data, cleaning user input, generating dynamic messages, formatting invoices, and preparing data before storing it in databases or sending it across services. Understanding the difference between comparing text content and comparing object references is also essential. For example, equals() checks actual content, while == checks whether two variables point to the same object.

Main tools you should know:

• String: for fixed text values and common operations.
• StringBuilder: for efficient repeated modifications.
• String methods: for searching, trimming, replacing, and slicing text.
• Formatting utilities: for building readable output.

Step-by-Step Explanation

Start by declaring a string: String name = "Java";. Use length() to count characters. Use charAt(index) to access one character. Use substring(start, end) to extract part of the text. Use concat() or + to combine strings. Use equals() to compare content safely.

To search inside text, use contains(), indexOf(), or startsWith(). To clean input, use trim() to remove leading and trailing spaces. To standardize text, use toLowerCase() or toUpperCase(). To replace content, use replace() for exact characters or text and replaceAll() when using regular expressions.

If you need to build long text in steps, create a StringBuilder, call append() repeatedly, then convert it back with toString().

Comprehensive Code Examples

public class BasicStringExample {
    public static void main(String[] args) {
        String text = "Hello Java";
        System.out.println(text.length());
        System.out.println(text.charAt(0));
        System.out.println(text.substring(6));
        System.out.println(text.toUpperCase());
        System.out.println(text.contains("Java"));
    }
}

public class RealWorldStringExample {
    public static void main(String[] args) {
        String email = "  [email protected]  ";
        String cleaned = email.trim().toLowerCase();

        if (cleaned.endsWith("@example.com")) {
            System.out.println("Corporate email accepted: " + cleaned);
        } else {
            System.out.println("Invalid domain");
        }
    }
}

public class AdvancedStringExample {
    public static void main(String[] args) {
        String[] items = {"Laptop", "Mouse", "Keyboard"};
        StringBuilder invoice = new StringBuilder();

        invoice.append("Order Summary:\n");
        for (int i = 0; i < items.length; i++) {
            invoice.append(i + 1).append(". ").append(items[i]).append("\n");
        }

        System.out.println(invoice.toString());
    }
}

Common Mistakes

• Using == for content comparison: use equals() or equalsIgnoreCase() instead.
• Forgetting that strings are immutable: methods like replace() return a new string, so store the result.
• Using + repeatedly in loops: prefer StringBuilder for better performance.
• Ignoring spaces in user input: call trim() before validation.

Best Practices

• Use equals() for exact comparison and equalsIgnoreCase() when case should not matter.
• Normalize input with trim() and case conversion before checking rules.
• Choose StringBuilder for repeated concatenation.
• Write clear variable names like fullName, filePath, and formattedMessage.
• Keep parsing logic simple and test edge cases such as empty strings.

Practice Exercises

• Create a program that stores a sentence and prints its length, first character, and last character.
• Ask the user for a name, remove extra spaces, and print it in uppercase.
• Store a comma-separated list of skills in a string and split it into an array, then print each skill.

Mini Project / Task

Build a small input-cleaning utility that takes a full name and email address, trims extra spaces, standardizes the email to lowercase, and prints a formatted registration summary.

Challenge (Optional)

Create a program that counts how many vowels, consonants, digits, and spaces exist in a sentence using string methods and character checks.

String Methods and StringBuilder

In Java, text is usually handled with the String class. A String stores characters such as names, emails, messages, file paths, and API responses. Java applications rely heavily on strings because almost every system reads, formats, validates, or displays text. Common real-life uses include checking user input, formatting invoices, building URLs, processing log messages, and generating reports.

A key idea is that String objects are immutable, which means once a string is created, its value cannot be changed. Methods like toUpperCase() or replace() do not modify the original string; they return a new one. This makes strings safe and predictable, but repeated modifications can reduce performance. That is why Java provides StringBuilder, a mutable class designed for efficient text construction when content changes often, such as inside loops or report generation.

Important string methods include length(), charAt(), substring(), equals(), equalsIgnoreCase(), contains(), indexOf(), replace(), trim(), toLowerCase(), toUpperCase(), and split(). For StringBuilder, common methods include append(), insert(), delete(), reverse(), and toString().

Step-by-Step Explanation

To create a string, write String name = "Java";. To read its size, use name.length(). To compare string content, use equals() instead of ==. Example: name.equals("Java"). To extract part of a string, use substring(start, end), where the end index is excluded. To search text, use contains() or indexOf(). To clean spaces, use trim().

Use StringBuilder when combining many pieces of text. Create one with StringBuilder sb = new StringBuilder();. Add text using sb.append("Hello"). When finished, convert it into a regular string using sb.toString(). This is especially useful in loops because it avoids creating many temporary string objects.

Comprehensive Code Examples

public class BasicStringExample {
    public static void main(String[] args) {
        String text = "Java Programming";
        System.out.println(text.length());
        System.out.println(text.charAt(0));
        System.out.println(text.substring(5, 16));
        System.out.println(text.toUpperCase());
        System.out.println(text.contains("Program"));
    }
}

public class RealWorldStringExample {
    public static void main(String[] args) {
        String email = "  [email protected]  ";
        email = email.trim().toLowerCase();
        if (email.contains("@") && email.endsWith(".com")) {
            System.out.println("Valid email format: " + email);
        } else {
            System.out.println("Invalid email format");
        }
    }
}

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder report = new StringBuilder();
        report.append("Daily Report\n");
        report.append("Users: ").append(120).append("\n");
        report.append("Sales: $").append(4500.75).append("\n");
        report.insert(13, "- Generated - ");
        System.out.println(report.toString());
    }
}

Common Mistakes

• Using == for content comparison: Use equals() because == compares references.
• Assuming methods change the original string: Store the returned result, such as text = text.trim();.
• Using String in heavy concatenation loops: Prefer StringBuilder for better performance.
• Wrong substring indexes: Remember the end index is not included.

Best Practices

• Use String for fixed text and StringBuilder for frequently changing text.
• Normalize user input with trim() and case conversion before validation.
• Use meaningful variable names like fullName, emailAddress, and messageBuilder.
• Check for empty values before calling methods on user input when needed.

Practice Exercises

• Create a program that stores your full name and prints its length, first character, and uppercase version.
• Write a program that reads a sentence and prints whether it contains the word Java.
• Use StringBuilder to build a three-line address block with name, city, and country.

Mini Project / Task

Build a simple username formatter that removes extra spaces, converts text to lowercase, replaces spaces with underscores, and prints the final username.

Challenge (Optional)

Create a program that takes a sentence, splits it into words, reverses the word order using string methods and StringBuilder, and prints the new sentence.

Arithmetic and Comparison Operators

Arithmetic and comparison operators are some of the most frequently used tools in Java. Arithmetic operators let you perform calculations such as addition, subtraction, multiplication, division, and remainder. Comparison operators let you compare two values and produce a boolean result: either true or false. Together, they form the foundation of application logic. In real-world software, arithmetic operators are used in billing systems, tax calculations, stock counts, score tracking, and analytics. Comparison operators are used in validation, access control, filtering, rule engines, and conditional execution such as checking whether a user is old enough, whether stock is low, or whether a payment is greater than a minimum amount.

In Java, common arithmetic operators are +, -, *, /, and %. The + operator also joins strings. Java also supports unary arithmetic shortcuts like ++ and -- for incrementing and decrementing values. Common comparison operators are ==, !=, >, <, >=, and <=. These operators are especially useful inside if statements, loops, and validation rules. One important detail is that Java follows operator precedence. For example, multiplication happens before addition unless parentheses change the order. Understanding this prevents incorrect results and makes your code more predictable.

Step-by-Step Explanation

To use arithmetic operators, start with variables that store numeric values such as int, double, or long. Then apply an operator between values. For example, int total = price + tax; adds two numbers. Division deserves extra attention: if both values are integers, Java returns integer division, which drops the decimal part. For example, 5 / 2 becomes 2, not 2.5. To keep decimals, use at least one double, such as 5.0 / 2. The remainder operator % returns what is left after division and is useful for checking even and odd numbers.

Comparison operators check relationships between values. For example, age >= 18 returns true if the age is 18 or more. These expressions often drive program decisions. Be careful with ==. For primitive values like int, it compares actual values. For objects such as String, professionals typically use methods like equals() instead of ==.

Comprehensive Code Examples

public class BasicOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);

        System.out.println(a > b);
        System.out.println(a == b);
        System.out.println(a != b);
    }
}

public class ShoppingCart {
    public static void main(String[] args) {
        double itemPrice = 49.99;
        int quantity = 2;
        double subtotal = itemPrice * quantity;
        double discount = 10.00;
        double finalTotal = subtotal - discount;

        System.out.println("Final total: " + finalTotal);
        System.out.println("Eligible for free shipping: " + (finalTotal >= 50));
    }
}

public class AdvancedUsage {
    public static void main(String[] args) {
        int completedTasks = 17;

        System.out.println("Even task count: " + (completedTasks % 2 == 0));

        int x = 5;
        int y = ++x * 2;

        System.out.println("x: " + x);
        System.out.println("y: " + y);
        System.out.println("Performance target met: " + (completedTasks > 10));
    }
}

Common Mistakes

• Using integer division accidentally: 7 / 2 gives 3. Use 7.0 / 2 or cast to double.
• Confusing = with ==: = assigns a value, while == compares values.
• Misreading precedence: 2 + 3 * 4 equals 14, not 20. Use parentheses when needed.
• Using == for strings: compare string content with equals().

Best Practices

• Use parentheses to make complex expressions easier to read.
• Choose the correct numeric type, especially double for decimal calculations.
• Keep comparison expressions simple and descriptive.
• Test edge cases such as zero, negative values, and exact boundary values.

Practice Exercises

• Create a program that stores two integers and prints their sum, difference, product, quotient, and remainder.
• Write a program that checks whether a number is even or odd using the remainder operator.
• Create variables for exam score and passing mark, then print whether the student passed using a comparison operator.

Mini Project / Task

Build a simple invoice calculator that stores item price, quantity, and discount, then calculates the final payable amount and prints whether the customer qualifies for free shipping based on a minimum order value.

Challenge (Optional)

Create a program that takes a total number of seconds and calculates hours, minutes, and remaining seconds using arithmetic operators, then compare whether the total duration is greater than one hour.

Logical Operators

Logical operators in Java are used to combine or invert boolean expressions. They exist because real programs rarely make decisions based on a single condition. In enterprise applications, you often need to check multiple rules at once, such as whether a user is logged in and has permission, whether an order is paid or approved, or whether a value is valid before processing it. Logical operators help express this kind of decision-making clearly. The main logical operators in Java are && (AND), || (OR), and ! (NOT). The AND operator returns true only when both conditions are true. The OR operator returns true when at least one condition is true. The NOT operator reverses a boolean value, turning true into false and false into true. Java also uses short-circuit evaluation for && and ||. This means Java may skip evaluating the second condition if the result is already known. For example, with AND, if the first condition is false, the whole expression must be false, so Java does not check the second part. This is very important when the second condition could cause an error, such as accessing an object that may be null. Logical operators are commonly used inside if, while, ternary expressions, validation code, authentication rules, and business workflows. Understanding them well is essential because many bugs come from poorly combined conditions, wrong operator choice, or missing parentheses. When used correctly, logical operators make code safer, more expressive, and easier to maintain in professional systems.

Step-by-Step Explanation

Start with boolean expressions. A boolean expression is any statement that produces either true or false, such as age >= 18 or isAdmin.
Use && when both conditions must be true.
Example: age >= 18 && hasId.
Use || when at least one condition can be true.
Example: isAdmin || isManager.
Use ! to reverse a condition.
Example: !isLoggedIn means the user is not logged in.
Parentheses improve readability and control evaluation order, especially in combined expressions like (age >= 18 && hasId) || isStaff.
Short-circuit behavior matters. In user != null && user.isActive(), Java checks user != null first. If false, it skips user.isActive(), preventing a null error.

Comprehensive Code Examples

public class LogicalBasic {
    public static void main(String[] args) {
        int age = 20;
        boolean hasId = true;

        if (age >= 18 && hasId) {
            System.out.println("Entry allowed");
        }

        boolean isWeekend = false;
        boolean isHoliday = true;

        if (isWeekend || isHoliday) {
            System.out.println("Office closed");
        }

        boolean subscribed = false;
        if (!subscribed) {
            System.out.println("Please subscribe");
        }
    }
}

public class LoginAccess {
    public static void main(String[] args) {
        boolean isLoggedIn = true;
        boolean isAdmin = false;
        boolean hasSupportRole = true;

        if (isLoggedIn && (isAdmin || hasSupportRole)) {
            System.out.println("Access granted to dashboard");
        } else {
            System.out.println("Access denied");
        }
    }
}

public class ShortCircuitDemo {
    public static void main(String[] args) {
        String email = null;

        if (email != null && email.contains("@")) {
            System.out.println("Valid email format");
        } else {
            System.out.println("Email is missing or invalid");
        }

        int score = 85;
        boolean passedExam = score >= 50;
        boolean earnedCertificate = passedExam && score >= 80;

        System.out.println("Certificate earned: " + earnedCertificate);
    }
}

Common Mistakes

• Using & or | instead of && or ||: single operators do not short-circuit and may evaluate unnecessary expressions.
• Forgetting parentheses in complex conditions: this can make the logic unclear or incorrect. Add parentheses to show intent.
• Calling methods on possibly null objects: write null checks first, such as obj != null && obj.isReady().
• Misusing NOT: expressions like !a == b are confusing. Prefer clear boolean comparisons or parentheses.

Best Practices

• Keep conditions readable by splitting long expressions into named boolean variables.
• Use parentheses even when operator precedence would work, because clarity matters in team codebases.
• Take advantage of short-circuiting for safe null checks and efficient evaluation.
• Name boolean variables clearly, such as isActive, hasPermission, and isEligible.
• Prefer positive conditions when possible, since too many negations reduce readability.

Practice Exercises

• Write a program that checks whether a student passes only if attendance is at least 75 and marks are at least 50.
• Create a condition that allows system access if the user is an admin or a moderator.
• Write a program that prints a message if a string is not null and its length is greater than 5.

Mini Project / Task

Build a simple account eligibility checker that approves a bank account application only if the applicant is at least 18, has valid identification, and is not blacklisted. Print whether the application is approved or rejected.

Challenge (Optional)

Create a discount eligibility program where a customer gets a discount if they are a premium member and spent more than 1000, or if they have a special coupon and are not blocked from promotions. Use well-named boolean variables and parentheses for clarity.

Conditional Statements If Else

Conditional statements in Java allow a program to make decisions. Instead of running every line in the same way every time, the program can check a condition and choose different paths. This is important because real applications constantly evaluate situations such as whether a user is logged in, whether a payment was approved, or whether an input value is valid. The if, else if, and else statements are the main tools for decision-making. An if statement runs code only when a condition is true. An else if checks another condition when the previous one was false. An else provides a default path when no earlier condition matched. In enterprise development, these statements are used for business rules, validation, permissions, workflow branching, and status handling. For example, an e-commerce system may check whether stock is available, whether the user has enough balance, and whether delivery is possible before completing an order.

Java conditions must evaluate to a boolean value: either true or false. Conditions often use comparison operators such as ==, !=, >, <, >=, and <=, along with logical operators like && and ||. This makes conditional logic flexible enough for both simple checks and more advanced business scenarios.

Step-by-Step Explanation

The simplest form is if (condition) { ... }. If the condition is true, the block runs. If false, it is skipped. To add an alternative path, use else. To test multiple possibilities, chain else if blocks between if and else.

Syntax flow:
1. Java evaluates the condition inside parentheses.
2. If true, it executes that block and ignores the rest of the chain.
3. If false, it moves to the next else if or else.
4. Only one matching branch runs in a single chain.

Comprehensive Code Examples

Basic example

int age = 20;
if (age >= 18) {
    System.out.println("You are an adult.");
} else {
    System.out.println("You are a minor.");
}

Real-world example

double accountBalance = 2500.00;
double withdrawalAmount = 3000.00;

if (withdrawalAmount <= accountBalance) {
    System.out.println("Withdrawal approved.");
} else {
    System.out.println("Insufficient funds.");
}

Advanced usage

int score = 87;

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

Common Mistakes

• Using = instead of comparison operators: Remember that = assigns a value, while comparisons use operators like == or >=.
• Forgetting braces: Without braces, only the next statement belongs to the condition. Use braces even for one line to avoid bugs.
• Writing overlapping conditions poorly: Place more specific checks before broader ones, otherwise later branches may never run.

Best Practices

• Keep conditions readable and not overly long.
• Use meaningful variable names such as isLoggedIn or hasPermission.
• Order conditions from most specific to most general.
• Avoid deeply nested if blocks when simpler logic can be used.
• Test edge cases such as zero, empty values, and boundary numbers.

Practice Exercises

• Write a program that checks whether a number is positive or negative using if and else.
• Create a program that prints whether a student passed or failed based on a score of 50 or more.
• Build a grade classifier using if, else if, and else for ranges A, B, C, D, and F.

Mini Project / Task

Build a simple loan eligibility checker that takes age and monthly income values, then prints whether the applicant is eligible, under review, or not eligible based on conditions you define.

Challenge (Optional)

Create a billing discount program that applies different discount percentages depending on purchase amount and membership status, using a well-structured if-else if-else chain.

Switch Case Logic

Switch case logic in Java is a decision-making structure used when one expression can match several known values. Instead of writing many if-else if checks, a switch statement makes code more readable when comparing a variable such as a number, character, string, or enum against fixed options. In real applications, it is often used for menu systems, command processing, status handling, role-based actions, and mapping user input to program behavior.

The main idea is simple: Java evaluates one expression, then jumps to the matching case. A break usually stops execution so other cases do not run accidentally. A default block handles unexpected values. In modern Java, you may also see switch expressions, which return a value and support cleaner syntax with arrows. Traditional switch statements are still common and are important for understanding code in existing enterprise systems.

Common forms include the classic switch statement, grouped cases where multiple values share one action, and newer switch expressions. Traditional syntax is useful for procedural control flow. Grouped cases reduce repetition. Switch expressions are cleaner when assigning a result directly to a variable.

Step-by-Step Explanation

The basic syntax starts with switch(expression). The expression is evaluated once. Each case value: represents one possible match. If matched, that block runs. Add break; to prevent fall-through. The default: block runs when no case matches.

Structure:
switch(day) { case 1: ... break; case 2: ... break; default: ... }

Use switch when comparing one variable to fixed exact values. If your logic depends on ranges like less than or greater than, if-else is usually better.

Comprehensive Code Examples

Basic example

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

Real-world example

String role = "ADMIN";
switch (role) {
    case "ADMIN":
        System.out.println("Full access granted");
        break;
    case "EDITOR":
        System.out.println("Content editing allowed");
        break;
    case "VIEWER":
        System.out.println("Read-only access");
        break;
    default:
        System.out.println("Unknown role");
}

Advanced usage

String grade = "B";
String message = switch (grade) {
    case "A" -> "Excellent";
    case "B", "C" -> "Good effort";
    case "D" -> "Needs improvement";
    default -> "Invalid grade";
};
System.out.println(message);

The advanced version shows a switch expression. It directly returns a value, avoids accidental fall-through, and is often easier to maintain.

Common Mistakes

• Forgetting break: This causes fall-through, where the next case runs too. Fix it by adding break; in classic switch blocks unless fall-through is intentional.
• Using switch for ranges: Beginners sometimes try to check values like 90–100 in one case. Traditional switch matches exact values, so use if-else for ranges.
• Missing default: Without it, unexpected input may be ignored. Add a default branch for safer behavior.
• Case value type mismatch: The case values must be compatible with the expression type. For example, do not compare an int switch expression with string cases.

Best Practices

• Use switch when checking one variable against a known list of exact values.
• Prefer meaningful constants or enums instead of unexplained numbers.
• Always include a default branch for defensive coding.
• Use modern switch expressions when assigning a result.
• Keep each case short; move complex logic into methods.

Practice Exercises

• Create a program that stores a number from 1 to 7 and prints the corresponding weekday using switch.
• Write a menu-based switch that prints different messages for choices 1, 2, and 3, and prints Invalid choice for anything else.
• Create a switch expression that converts traffic light colors Red, Yellow, and Green into driving instructions.

Mini Project / Task

Build a simple console-based calculator menu where the user selects an operation such as add, subtract, multiply, or divide, and the program uses switch to choose which calculation to perform.

Challenge (Optional)

Create a command handler that accepts a string such as start, stop, restart, or status and uses a switch expression to return a message for each command while safely handling unknown inputs.

While and Do While Loops

While and do while loops are repetition structures in Java used when you want a block of code to run multiple times based on a condition. They exist because many programming tasks require repeated execution, such as reading user input until it is valid, processing records one by one, retrying a connection, or running a menu until the user chooses to exit. In real applications, these loops are common in console programs, backend processing, validation flows, game logic, and automation scripts.

A while loop checks its condition first, then runs the body only if the condition is true. This means it may execute zero times. A do while loop runs the body first and checks the condition afterward, so it always executes at least once. This difference is important in real-life scenarios like showing a menu at least one time before asking whether the user wants to continue.

The basic idea is simple: Java evaluates a boolean expression. If the result allows continuation, the loop keeps running. Inside the loop, you usually update a variable so the loop can eventually stop. Without that update, the loop can become infinite. These loops are especially useful when the number of repetitions is not known in advance, unlike many for loop cases where a fixed range is known.

Step-by-Step Explanation

While loop syntax:
while (condition) { ... }

Step 1: Java checks the condition.
Step 2: If true, the code inside the loop runs.
Step 3: Control returns to the condition.
Step 4: The loop ends when the condition becomes false.

Do while syntax:
do { ... } while (condition);

Step 1: The loop body runs once immediately.
Step 2: Java checks the condition.
Step 3: If true, the body runs again.
Step 4: The loop ends when the condition becomes false.

Notice the semicolon after the while(condition) in a do while loop. That semicolon is required.

Comprehensive Code Examples

public class BasicWhileExample {
    public static void main(String[] args) {
        int count = 1;

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

import java.util.Scanner;

public class RealWorldDoWhileExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int choice;

        do {
            System.out.println("1. View Profile");
            System.out.println("2. Edit Profile");
            System.out.println("3. Exit");
            System.out.print("Enter choice: ");
            choice = scanner.nextInt();

            System.out.println("You selected option " + choice);
        } while (choice != 3);

        System.out.println("Application closed.");
    }
}

public class AdvancedWhileExample {
    public static void main(String[] args) {
        int[] orders = {120, 250, 90, 310, 150};
        int index = 0;
        int totalHighValue = 0;

        while (index < orders.length) {
            if (orders[index] >= 150) {
                totalHighValue += orders[index];
            }
            index++;
        }

        System.out.println("Total high-value orders: " + totalHighValue);
    }
}

Common Mistakes

• Forgetting to update the loop variable: This causes an infinite loop. Fix it by changing the control variable inside the loop, such as count++.
• Using do while when zero executions are possible: A do while always runs once. Use while if the code should maybe not run at all.
• Missing the semicolon in do while: The closing line must be while (condition);.
• Writing conditions that never become false: Test boundary values carefully, especially with <, <=, and counters.

Best Practices

• Use while when the condition should be checked before execution.
• Use do while for menus, input prompts, and workflows that must run at least once.
• Keep loop conditions simple and readable.
• Update loop variables in a clear, predictable place.
• Add safeguards when processing external input to avoid endless repetition.

Practice Exercises

• Write a while loop that prints numbers from 10 down to 1.
• Create a do while loop that displays a message at least once and stops when a variable reaches 5.
• Use a while loop to calculate the sum of numbers from 1 to 20.

Mini Project / Task

Build a simple console menu using a do while loop that keeps showing options until the user chooses Exit.

Challenge (Optional)

Create a program that uses a while loop to reverse an integer digit by digit without converting it to a string.

For Loops and Nested Loops

Step-by-Step Explanation

for (initialization; termination; increment/decrement) {
    // code to be executed repeatedly
}

• Initialization: This statement is executed once at the beginning of the loop. It typically declares and initializes a loop control variable. For example, int i = 0;


• Termination (Condition): This boolean expression is evaluated before each iteration. If it evaluates to true, the loop body executes. If it evaluates to false, the loop terminates. For example, i < 10;


• Increment/Decrement: This statement is executed after each iteration of the loop body. It usually updates the loop control variable. For example, i++ or i--.

for (initialization_outer; termination_outer; increment_outer) {
    for (initialization_inner; termination_inner; increment_inner) {
        // code to be executed for each inner loop iteration
    }
    // code to be executed after inner loop completes, before next outer loop iteration
}

Comprehensive Code Examples

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Number: " + i);
        }
    }
}

public class ArraySum {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int sum = 0;
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        System.out.println("Sum of array elements: " + sum);
    }
}

public class MultiplicationTable {
    public static void main(String[] args) {
        System.out.println("--- Multiplication Table (1-10) ---");
        for (int i = 1; i <= 10; i++) { // Outer loop for rows
            for (int j = 1; j <= 10; j++) { // Inner loop for columns
                System.out.printf("%4d", (i * j)); // Print product, formatted to 4 spaces
            }
            System.out.println(); // Move to the next line after each row
        }
    }
}

Common Mistakes

• Off-by-one errors: Using < instead of <= (or vice-versa) in the termination condition can lead to loops running one time too many or too few. Always double-check your conditions, especially when dealing with array indices (0 to length-1).
  Fix: Carefully review the loop boundary conditions. For arrays, i < array.length is common for 0-indexed iteration.


• Infinite loops: If the termination condition never becomes false, the loop will run indefinitely, consuming resources and crashing your program. This often happens if the increment/decrement statement is missing or incorrect.
  Fix: Ensure the loop control variable is updated correctly within the loop body or the increment/decrement section, and that it eventually causes the termination condition to be false.


• Incorrectly using loop control variables in nested loops: Modifying the outer loop's control variable within the inner loop can lead to unpredictable behavior.
  Fix: Keep the control variables of outer and inner loops distinct and only modify the inner loop's variable within the inner loop's scope.

Best Practices

• Meaningful variable names: Use descriptive names for loop control variables (e.g., rowIndex, colIndex, itemCount) instead of generic i, j, k, especially in complex or nested loops, to improve readability.


• Keep loop bodies concise: If the code inside a loop becomes too long or complex, consider extracting parts of it into separate methods. This improves modularity and makes the loop easier to understand.


• Consider enhanced 'for' loop (for-each): For iterating over arrays or collections when you don't need the index, the enhanced 'for' loop (for (Type item : collection)) is more concise and less error-prone.
  Example: for (int num : numbers) { System.out.println(num); }


• Optimize nested loops: Nested loops can have a significant performance impact (e.g., O(n^2)). If possible, try to reduce the number of nested loops or optimize the operations within them.

Practice Exercises

• Write a program using a 'for' loop to print all even numbers between 1 and 20 (inclusive).


• Create a program that takes an integer N as input and prints the factorial of N using a 'for' loop. (Factorial of 5 is 5*4*3*2*1 = 120).


• Use nested 'for' loops to print a 5x5 square of asterisks (*). Each row should have 5 asterisks.

Mini Project / Task

Challenge (Optional)

*
**
***
****
*****

*****
****
***
**
*

Break and Continue

In Java, break and continue are control flow statements used inside loops to change the normal path of execution. They exist because not every loop should always run from start to finish in a straight line. Sometimes you want to stop a loop completely as soon as a required result is found, and other times you want to skip one specific iteration and move to the next. That is exactly where these statements become useful. In real applications, developers use break when searching for a matching record, stopping input processing after a special value, or exiting a menu loop after a user chooses to quit. They use continue when filtering invalid input, ignoring unwanted data, or skipping values that do not meet processing rules.

The break statement immediately terminates the nearest enclosing loop or switch. After it runs, execution continues with the first statement after that loop. The continue statement does not end the loop. Instead, it skips the rest of the current iteration and jumps to the next loop cycle. In a for loop, this means Java moves to the update expression and then checks the condition again. In while and do-while loops, the condition is checked again before continuing. Java also supports labeled break and labeled continue, which are advanced forms used with nested loops. A labeled break exits an outer loop, while a labeled continue skips to the next iteration of a named outer loop. These should be used carefully because they can reduce readability if overused.

Step-by-Step Explanation

The syntax is simple. Use break; when a condition means the loop should stop entirely. Use continue; when a condition means the current iteration should be ignored.

Basic pattern with break: place it inside an if block within a loop. When the condition becomes true, the loop ends immediately.

Basic pattern with continue: place it inside an if block within a loop. When the condition becomes true, the remaining code in that iteration is skipped.

For beginners, the key difference is this: break exits the loop, but continue stays in the loop and only skips one cycle.

Comprehensive Code Examples

Basic example

for (int i = 1; i <= 10; i++) {
    if (i == 6) {
        break;
    }
    System.out.println(i);
}

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

Real-world example

String[] usernames = {"Asha", "", "Ravi", "admin", "Meera"};

for (String name : usernames) {
    if (name.isEmpty()) {
        continue;
    }
    if (name.equals("admin")) {
        System.out.println("Reserved username found. Stopping check.");
        break;
    }
    System.out.println("Valid username: " + name);
}

Advanced usage

outerLoop:
for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 3; col++) {
        if (row == 2 && col == 2) {
            continue outerLoop;
        }
        if (row == 3 && col == 1) {
            break outerLoop;
        }
        System.out.println("Row: " + row + ", Col: " + col);
    }
}

Common Mistakes

• Using break when you only want to skip one value. Fix: use continue if the loop should keep running.

• Placing important code after continue inside the same iteration. Fix: remember that code after continue in that loop cycle will not execute.

• Creating infinite loops in while loops by skipping updates before continue. Fix: make sure loop-control variables are still updated correctly.

• Overusing labeled statements. Fix: prefer clearer logic unless nested-loop control truly requires labels.

Best Practices

• Use break to exit early when the result has already been found.

• Use continue to keep filtering logic clean and reduce deep nesting.

• Keep loop conditions readable so the reason for stopping or skipping is obvious.

• Comment labeled break or continue statements when their purpose may not be immediately clear.

• Prefer simple loop structure over clever control flow in professional codebases.

Practice Exercises

• Write a for loop from 1 to 20 that stops completely when it reaches 13.

• Write a loop from 1 to 10 that skips all even numbers using continue.

• Create an array of words and print each word, but skip empty strings and stop if the word exit appears.

Mini Project / Task

Build a simple number scanner that processes values from an integer array, skips negative numbers, prints valid positive numbers, and stops immediately when it finds the value 0.

Challenge (Optional)

Use nested loops to search a 2D integer array for the first occurrence of a target value. Stop all looping as soon as the value is found, and print its row and column position.

Introduction to Methods

In Java, a method is a named block of code that performs a specific task. Methods exist to help developers organize programs into small, reusable, and understandable units. Instead of writing the same logic again and again, you can place that logic inside a method and call it whenever needed. In real applications, methods are everywhere: validating a user login, calculating tax, formatting a report, saving data to a database, or sending an email notification. Without methods, programs quickly become long, repetitive, and difficult to maintain.

Methods improve readability, reuse, testing, and debugging. A well-named method tells you what a piece of code does without forcing you to read every line. In Java, methods can return a value or perform an action without returning anything. The common sub-types beginners should know are void methods, which perform an action and return nothing, and value-returning methods, which send back a result such as an int, double, or String. Methods may also have parameters, which are inputs passed into the method, or no parameters if no input is needed. Another important distinction is between calling a method and defining a method: definition creates the logic, while calling executes it.

Step-by-Step Explanation

The basic method structure in Java is: access modifier, optional keyword like static, return type, method name, parameter list, and method body.

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

Here, public means the method is accessible, static means it belongs to the class rather than an object, int is the return type, add is the method name, and int a, int b are parameters. The return statement sends a value back to the caller. If a method does not return anything, use void. To use a method, write its name followed by parentheses and required arguments.

Comprehensive Code Examples

Basic example

public class Main {
    public static void greet() {
        System.out.println("Hello, Java!");
    }

    public static void main(String[] args) {
        greet();
    }
}

Real-world example

public class InvoiceApp {
    public static double calculateTotal(double price, int quantity) {
        return price * quantity;
    }

    public static void main(String[] args) {
        double total = calculateTotal(49.99, 3);
        System.out.println("Invoice total: " + total);
    }
}

Advanced usage

public class AccountUtils {
    public static boolean isValidPassword(String password) {
        return password.length() >= 8;
    }

    public static String buildWelcomeMessage(String name) {
        return "Welcome, " + name + "!";
    }

    public static void main(String[] args) {
        String message = buildWelcomeMessage("Aisha");
        boolean valid = isValidPassword("secure123");

        System.out.println(message);
        System.out.println("Password valid: " + valid);
    }
}

Common Mistakes

• Forgetting the return type: Every method must declare a return type such as void, int, or String.
• Missing a return statement: If the method return type is not void, it must return a matching value.
• Passing the wrong arguments: The number and type of arguments in the method call must match the parameters.
• Confusing printing with returning: System.out.println() displays output, but return sends a value back to the caller.

Best Practices

• Use clear verb-based names like calculateTax, printReport, or validateEmail.
• Keep methods focused on one job only.
• Prefer small methods for readability and easier testing.
• Use parameters instead of hardcoding values.
• Choose return types carefully so the method communicates useful results.

Practice Exercises

• Create a method named sayGoodbye that prints a farewell message.
• Create a method named squareNumber that takes an int and returns its square.
• Create a method named isAdult that takes an age and returns true if the age is 18 or above.

Mini Project / Task

Build a simple student utility program with methods to display a student name, calculate the average of three marks, and check whether the student passed based on the average.

Challenge (Optional)

Create a method-based calculator that has separate methods for addition, subtraction, multiplication, and division, then call them from main using different inputs.

Method Parameters and Return Types

Methods are reusable blocks of code that perform a task. Parameters allow a method to receive data from the caller, while return types allow it to send a result back. In real applications, this is how Java programs calculate totals, validate user input, transform data, and organize business rules into small, testable units. For example, an e-commerce system may pass a product price and quantity into a method, then return the final subtotal. A banking application may pass an account balance and withdrawal amount, then return an updated balance or a status value. Parameters exist so methods can be flexible instead of hard-coded. Return types exist so methods can provide useful output instead of only printing to the screen. In Java, a method may take zero, one, or many parameters, and it must declare exactly what type of value it returns. If it returns nothing, the return type is void.

The core ideas are simple. A parameter is a variable listed in a method declaration. An argument is the actual value passed when the method is called. Parameters can be primitive types such as int, double, and boolean, or reference types such as String and arrays. Return types can also be primitive, reference, or void. A method signature includes the method name and parameter list, which helps Java decide which method to call. This is especially important in method overloading, where multiple methods share the same name but use different parameter types or counts.

Step-by-Step Explanation

A basic method declaration follows this structure: access modifier, optional keywords, return type, method name, parameter list, and method body. Example syntax: public int add(int a, int b). Here, public controls visibility, int is the return type, add is the method name, and int a, int b are parameters. Inside the method body, use return to send back a value of the declared type. If the method is void, you do not return a value. When calling a method, provide arguments that match the declared parameter types and order. Java checks type compatibility at compile time, which prevents many common errors early.

Comprehensive Code Examples

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

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println(result);
    }
}

public class InvoiceCalculator {
    public static double calculateTotal(double price, int quantity, double taxRate) {
        double subtotal = price * quantity;
        return subtotal + (subtotal * taxRate);
    }

    public static void main(String[] args) {
        double total = calculateTotal(19.99, 3, 0.08);
        System.out.println("Total: " + total);
    }
}

public class OverloadExample {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    public static double max(double a, double b) {
        return a > b ? a : b;
    }

    public static boolean isValidUsername(String username, int minLength) {
        return username != null && username.length() >= minLength;
    }
}

Common Mistakes

• Forgetting to return a value: If a method declares int or another non-void type, every valid path must return a matching value.
• Using the wrong parameter order: calculateTotal(3, 19.99, 0.08) may not match the intended types or meaning. Follow the declared order exactly.
• Confusing printing with returning: System.out.println() displays a value, but does not send it back to the caller.
• Returning the wrong type: A method declared as boolean must return true or false, not text like "yes".

Best Practices

• Choose parameter names that clearly describe purpose, such as price, quantity, and taxRate.
• Keep methods focused on one job so parameters and return values stay simple and readable.
• Prefer returning values over printing inside utility methods, because returned values are easier to test and reuse.
• Validate important input parameters when needed, especially for strings, null values, and numeric ranges.
• Use method overloading carefully to improve usability without creating confusing signatures.

Practice Exercises

• Create a method named square that accepts one int parameter and returns its square.
• Write a method named isEven that accepts an integer and returns a boolean.
• Create a method named formatFullName that accepts two String parameters and returns a combined full name.

Mini Project / Task

Build a simple grade calculator with methods that accept assignment score, exam score, and attendance percentage as parameters, then return the final numeric grade and a pass/fail result.

Challenge (Optional)

Design an overloaded method named convertTemperature where one version converts Celsius to Fahrenheit and another version converts Fahrenheit to Celsius using different parameter patterns.

Method Overloading

Method overloading is a feature in Java that allows multiple methods in the same class to share the same name while using different parameter lists. Java uses this feature so developers can perform similar actions with different kinds or amounts of input without inventing many unrelated method names. In real applications, overloading appears in utility libraries, mathematical helpers, logging systems, constructors, and service classes where the same operation should feel natural for callers. For example, a payment class may process a payment by amount only, by amount and currency, or by amount, currency, and discount code. All of these can use the same method name if the parameters differ.

The key idea is that Java distinguishes overloaded methods by their method signature, which includes the method name and parameter list. The parameter list can differ by number of parameters, parameter types, or parameter order. Return type alone does not create a valid overload. This matters because Java must know which method to call at compile time. Overloading improves readability, supports flexibility, and helps create beginner-friendly APIs, but poor overload design can also confuse users if parameter combinations are too similar.

Common forms of overloading include methods with different counts of parameters, methods with different data types such as int and double, and methods where the order of distinct parameter types changes. Java also overloads constructors, which is widely used to create objects with different initialization levels. In enterprise code, overloading is often used in service layers, DTO builders, and helper classes to provide convenient entry points while still directing logic toward one central implementation.

Step-by-Step Explanation

To create overloaded methods, first write a method with a meaningful name. Then create another method with the same name in the same class, but change the parameter list. You may add more parameters, use different types, or rearrange different parameter types. When calling the method, Java selects the best matching version based on the arguments passed.

Syntax pattern:
methodName(int a)
methodName(int a, int b)
methodName(double a)

Important rules:
1. The method name must stay the same.
2. Parameters must be different in type, count, or order.
3. Changing only the return type is invalid.
4. Overloading happens in the same class, though inherited methods can also participate when signatures differ.

Comprehensive Code Examples

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

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

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

class NotificationService {
    void send(String email) {
        System.out.println("Sending basic email to: " + email);
    }

    void send(String email, String subject) {
        System.out.println("Sending email to: " + email + " with subject: " + subject);
    }

    void send(String email, String subject, boolean urgent) {
        System.out.println("Sending urgent=" + urgent + " email to: " + email);
    }
}

class PriceCalculator {
    double calculate(double price) {
        return price;
    }

    double calculate(double price, double taxRate) {
        return price + (price * taxRate);
    }

    double calculate(double price, double taxRate, double discount) {
        double taxed = price + (price * taxRate);
        return taxed - discount;
    }
}

Common Mistakes

• Changing only the return type: int print() and double print() is invalid. Fix it by changing parameters, not just the return type.
• Creating ambiguous calls: similar overloads such as show(int, double) and show(double, int) can confuse callers. Fix by making method purposes clearer or using different names.
• Overloading too many versions: excessive overloads reduce readability. Fix by keeping only useful combinations and delegating to a central method.

Best Practices

• Use overloading only when methods represent the same logical action.
• Delegate simpler overloads to the most complete version to avoid duplicated logic.
• Keep parameter meaning obvious and avoid overloads that differ in confusing ways.
• Document expected inputs, especially when types are similar.

Practice Exercises

• Create a printDetails method overloaded for one name, name with age, and name with age and city.
• Write a multiply method for two integers, three integers, and two doubles.
• Create overloaded constructors for a Book class with title only, title and author, and title, author, and price.

Mini Project / Task

Build a small invoice utility with overloaded generateInvoice methods that accept just an amount, amount with tax, and amount with tax and discount, then print the final result.

Challenge (Optional)

Design a UserRegistrar class with overloaded register methods for email only, email with phone number, and full profile details, while making sure all overloads reuse one central validation method.

Variable Scope

Local Scope

Instance Scope

Class Scope

Step-by-Step Explanation

• Local Variables: Declare them directly inside a method, constructor, or any code block. They are only visible from their declaration point to the end of that block. For example, void myMethod() { int count = 0; }. Here, count is local to myMethod.


• Instance Variables: Declare them directly inside the class definition, but outside any method. For example, class MyClass { String name; }. name belongs to each MyClass object.


• Class (Static) Variables: Declare them inside the class definition, outside any method, and use the static keyword. For example, class MyClass { static int counter; }. counter is shared by all MyClass objects and can be accessed via MyClass.counter.
  

Comprehensive Code Examples

Basic Example

class ScopeDemo {
    // Instance variable
    String instanceMessage = "Hello from instance!";

    // Class (static) variable
    static String staticMessage = "Hello from static!";

    public void demonstrateScope() {
        // Local variable
        int localNumber = 10;

        System.out.println("Inside demonstrateScope method:");
        System.out.println("Local variable: " + localNumber);
        System.out.println("Instance variable: " + instanceMessage);
        System.out.println("Static variable: " + staticMessage);

        if (localNumber > 5) {
            // Another local variable, scoped to this if block
            String blockMessage = "Local to if block";
            System.out.println("Block variable: " + blockMessage);
        }
        // System.out.println(blockMessage); // ERROR: blockMessage cannot be resolved
    }

    public void anotherMethod() {
        // System.out.println(localNumber); // ERROR: localNumber cannot be resolved
        System.out.println("Inside anotherMethod:");
        System.out.println("Instance variable: " + instanceMessage);
        System.out.println("Static variable: " + staticMessage);
    }

    public static void main(String[] args) {
        ScopeDemo obj1 = new ScopeDemo();
        ScopeDemo obj2 = new ScopeDemo();

        obj1.demonstrateScope();
        System.out.println("--- After obj1.demonstrateScope() ---");

        obj1.instanceMessage = "Updated by obj1";
        ScopeDemo.staticMessage = "Updated by class"; // Access static via class name

        System.out.println("obj1's instance message: " + obj1.instanceMessage);
        System.out.println("obj2's instance message (unchanged): " + obj2.instanceMessage);
        System.out.println("Static message (shared): " + ScopeDemo.staticMessage);

        obj2.anotherMethod();
    }
}

Real-world Example: User Authentication System

class UserSession {
    // Instance variable: unique to each logged-in user session
    private String username;
    private String sessionId;
    private long lastActivityTime;

    // Class variable: shared across all user sessions (e.g., maximum session timeout)
    private static final int MAX_SESSION_DURATION_MINUTES = 30;

    public UserSession(String username, String sessionId) {
        this.username = username;
        this.sessionId = sessionId;
        this.lastActivityTime = System.currentTimeMillis();
    }

    public void recordActivity() {
        // Local variable: only exists within this method call
        long currentTime = System.currentTimeMillis();
        this.lastActivityTime = currentTime;
        System.out.println("Activity recorded for user: " + username + " at " + currentTime);
    }

    public boolean isValidSession() {
        long currentTime = System.currentTimeMillis(); // Local variable
        long elapsedMinutes = (currentTime - lastActivityTime) / (1000 * 60);
        return elapsedMinutes < MAX_SESSION_DURATION_MINUTES;
    }

    public String getUsername() {
        return username;
    }

    public static void printMaxSessionDuration() {
        System.out.println("Maximum session duration: " + MAX_SESSION_DURATION_MINUTES + " minutes.");
        // System.out.println(username); // ERROR: Cannot access instance variable from static method
    }

    public static void main(String[] args) throws InterruptedException {
        UserSession.printMaxSessionDuration();

        UserSession user1 = new UserSession("alice", "abc123xyz");
        UserSession user2 = new UserSession("bob", "def456uvw");

        System.out.println("User 1: " + user1.getUsername() + ", Valid? " + user1.isValidSession());
        System.out.println("User 2: " + user2.getUsername() + ", Valid? " + user2.isValidSession());

        Thread.sleep(2 * 60 * 1000); // Simulate 2 minutes passing
        user1.recordActivity();

        System.out.println("User 1: " + user1.getUsername() + ", Valid? " + user1.isValidSession());
        // If MAX_SESSION_DURATION_MINUTES was 1, user2 would now be invalid.
        System.out.println("User 2: " + user2.getUsername() + ", Valid? " + user2.isValidSession());
    }
}

Advanced Usage: Shadowing and Block Scope

class ShadowingDemo {
    int x = 10; // Instance variable

    public void methodWithShadowing(int x) { // Parameter x shadows instance x
        System.out.println("Parameter x: " + x); // Refers to the parameter
        System.out.println("Instance x: " + this.x); // 'this.x' refers to the instance variable

        for (int i = 0; i < 2; i++) {
            int y = 20; // Local variable, scoped to the loop
            System.out.println("Inside loop, y: " + y);
            int x_loop = 30; // Another local variable, shadows parameter x within this loop
            System.out.println("Inside loop, x_loop: " + x_loop);
        }
        // System.out.println(y); // ERROR: y cannot be resolved
        // System.out.println(x_loop); // ERROR: x_loop cannot be resolved

        { // Anonymous block
            String message = "Hello from anonymous block"; // Local to this block
            System.out.println(message);
        }
        // System.out.println(message); // ERROR: message cannot be resolved
    }

    public static void main(String[] args) {
        ShadowingDemo demo = new ShadowingDemo();
        demo.methodWithShadowing(100);
    }
}

Common Mistakes

• Accessing Local Variables Out of Scope: Trying to use a local variable outside the method or block where it was declared. Java's compiler will catch this as an error.
  Fix: If a variable needs to be accessible across different methods or blocks, declare it as an instance or class variable.


• Forgetting this for Shadowed Instance Variables: When a method parameter or local variable has the same name as an instance variable, the local one takes precedence (shadows the instance variable). Forgetting this. will lead to using the local variable instead of the instance one.
  Fix: Use this.variableName to explicitly refer to the instance variable.


• Modifying Static Variables Unintentionally: Since static variables are shared, changing them through one object or method affects all other parts of the program that use that static variable. This can lead to unexpected side effects.
  Fix: Understand that static variables are global to the class. Use them sparingly for mutable state, or declare them final to make them constants. Always access static variables via the class name (e.g., ClassName.staticVariable) for clarity, even though it's possible via an object.

Best Practices

• Minimize Scope: Declare variables with the narrowest possible scope. This reduces the chance of unintended modifications, improves code readability, and makes debugging easier. If a variable is only needed within a loop, declare it inside the loop.


• Use final for Constants: For static variables that should not change, declare them as public static final. This clearly communicates their intent and prevents accidental reassignment.


• Avoid Shadowing Where Possible: While Java allows shadowing, it can make code harder to read and debug. Try to use distinct names for parameters/local variables if they would shadow instance variables, unless the intent is clearly to set the instance variable (e.g., in constructors or setters using this.).


• Encapsulate Instance Variables: Declare instance variables as private and provide public getter/setter methods. This controls access to the variable and prevents direct external modification, adhering to the principles of object-oriented programming.

Practice Exercises

1. Local Scope Challenge: Write a method that calculates the factorial of a number. Declare all necessary loop counters and temporary variables within the method, ensuring they are not accessible outside.


2. Instance Variable Management: Create a Book class with instance variables for title, author, and isbn. Add a constructor to initialize these variables and a method displayBookInfo() that prints them. Create two different Book objects and demonstrate that each has its own unique data.


3. Static Variable Usage: Modify the Book class to include a static variable numberOfBooksCreated. Increment this variable in the constructor each time a new Book object is created. Add a static method getTotalBooks() to return this count. Confirm that it correctly tracks the total number of books across all instances.

Mini Project / Task

Challenge (Optional)

Arrays Introduction

Arrays in Java are fixed-size data structures used to store multiple values of the same type in a single variable. Instead of creating separate variables like score1, score2, and score3, you can group related values into one array. Arrays exist because programs often need to manage collections of data efficiently, such as student marks, product prices, monthly sales, sensor readings, or employee IDs. In real-world software, arrays are commonly used when the number of elements is known in advance or when fast indexed access is needed. Each value in an array is stored in a numbered position called an index, starting at 0. Java supports arrays of primitive types like int, double, and char, as well as arrays of objects like String or custom classes. You can also create multidimensional arrays, which are arrays containing other arrays, often used for grids, tables, and matrix-like data.

An array has a length property that tells you how many elements it can hold. Its size is fixed after creation, which means you cannot add or remove elements the way you can with dynamic collections such as ArrayList. That fixed nature makes arrays simple and memory-efficient for many tasks. A single-dimensional array stores values in a straight list, while a multidimensional array stores values in rows and columns. Understanding arrays is foundational because many advanced Java topics build on this idea of indexed data storage.

Step-by-Step Explanation

To declare an array, write the data type followed by square brackets and a variable name, such as int[] numbers;. This creates a reference variable, but not the actual array. To create the array, use new with a size, like numbers = new int[5];. This creates space for 5 integers, indexed from 0 to 4. You can also declare and create it in one line: int[] numbers = new int[5];. Another common syntax is direct initialization: int[] numbers = {10, 20, 30, 40, 50};.

Access elements using indexes, for example numbers[0] for the first item. Assign values with the same syntax: numbers[2] = 99;. Read the size using numbers.length. To process all elements, use a for loop or enhanced for loop. Be careful: using an invalid index causes ArrayIndexOutOfBoundsException.

Comprehensive Code Examples

public class BasicArrayExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println(numbers[0]);
        numbers[1] = 25;
        System.out.println(numbers.length);
    }
}

public class RealWorldArrayExample {
    public static void main(String[] args) {
        double[] temperatures = {36.5, 37.0, 38.2, 36.8, 37.4};
        double total = 0;
        for (int i = 0; i < temperatures.length; i++) {
            total += temperatures[i];
        }
        double average = total / temperatures.length;
        System.out.println("Average: " + average);
    }
}

public class AdvancedArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        for (int row = 0; row < matrix.length; row++) {
            for (int col = 0; col < matrix[row].length; col++) {
                System.out.print(matrix[row][col] + " ");
            }
            System.out.println();
        }
    }
}

Common Mistakes

• Using index 1 for the first element: Java arrays start at 0, so the first element is array[0].
• Going past the last index: Use i < array.length, not i <= array.length.
• Forgetting arrays have fixed size: Plan the size in advance or use ArrayList when growth is needed.
• Confusing declaration with creation: int[] a; does not allocate memory until new is used.

Best Practices

• Use meaningful names like scores, prices, or employeeIds.
• Always use the length property instead of hardcoding loop limits.
• Validate indexes when values come from user input.
• Prefer enhanced for loops when you only need to read values.
• Keep element types consistent and choose the right data type for memory and clarity.

Practice Exercises

• Create an integer array with 5 values and print each value using a for loop.
• Store 7 daily temperatures in an array and calculate the average.
• Create a string array of 4 city names and print the first and last city.

Mini Project / Task

Build a program that stores 6 monthly sales values in an array, calculates the total sales, finds the highest sales month, and prints a short report.

Challenge (Optional)

Create a program that stores 10 numbers in an array and prints only the duplicate values without using collections.

Multidimensional Arrays

Multidimensional arrays in Java are arrays that store other arrays as their elements. The most common form is a two-dimensional array, often visualized like a table with rows and columns. They exist because many real-life data problems are naturally grid-shaped, such as seating charts, game boards, spreadsheets, matrices, and monthly sales reports. In enterprise applications, multidimensional arrays can be used for tabular calculations, scoring systems, scheduling layouts, and intermediate data processing where a lightweight structured container is enough.

In Java, a multidimensional array is actually an array of arrays. That means rows can have equal lengths, which creates a regular matrix, or different lengths, which creates a jagged array. A regular 2D array is useful when every row has the same number of columns, such as a 3x3 board. A jagged array is useful when rows vary, such as monthly weekly data where one row may contain more entries than another. Java also supports higher dimensions, such as 3D arrays, though beginners usually start with 2D arrays.

Step-by-Step Explanation

To declare a 2D array, write the data type followed by two pairs of brackets, like int[][]. To create it with fixed size, use new int[rows][cols]. Example: int[][] marks = new int[3][4]; creates 3 rows and 4 columns. You access values using two indexes: marks[1][2] means row 1, column 2. Indexes start at 0.

You can also initialize a multidimensional array directly with values using nested braces. Example: int[][] grid = {{1, 2}, {3, 4}};. To process all elements, use nested loops. The outer loop moves through rows, and the inner loop moves through columns. For jagged arrays, always use array[row].length for the inner loop so each row is handled safely. This is important because different rows may have different sizes.

Comprehensive Code Examples

public class Basic2DArray {
    public static void main(String[] args) {
        int[][] numbers = {
            {1, 2, 3},
            {4, 5, 6}
        };

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

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

public class SalesReport {
    public static void main(String[] args) {
        int[][] sales = {
            {120, 140, 100},
            {90, 110, 130},
            {150, 160, 170}
        };

        for (int i = 0; i < sales.length; i++) {
            int total = 0;
            for (int j = 0; j < sales[i].length; j++) {
                total += sales[i][j];
            }
            System.out.println("Department " + (i + 1) + " total: " + total);
        }
    }
}

public class JaggedArrayExample {
    public static void main(String[] args) {
        int[][] data = new int[3][];
        data[0] = new int[]{1, 2};
        data[1] = new int[]{3, 4, 5};
        data[2] = new int[]{6};

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

Common Mistakes

• Using wrong indexes: Accessing array[3][0] in a 3-row array causes an out-of-bounds error. Fix: remember indexes start at 0.
• Assuming all rows have same length: This breaks jagged arrays. Fix: use array[i].length inside the inner loop.
• Forgetting initialization: Declaring int[][] arr; without creating rows leads to errors when accessed. Fix: initialize with new or direct values.

Best Practices

• Use meaningful names like matrix, scores, or schedule.
• Prefer nested loops for full traversal and enhanced for-loops when only reading values.
• Check dimensions carefully before accessing elements.
• Use jagged arrays only when variable row sizes are intentional.

Practice Exercises

• Create a 2D array of 2 rows and 3 columns, store integers, and print them in table form.
• Build a student marks table with 3 students and 4 subjects, then print each student total.
• Create a jagged array where rows have different lengths and print every element using nested loops.

Mini Project / Task

Build a simple seat map for a cinema using a 2D array where 0 means available and 1 means booked. Print the full seating layout.

Challenge (Optional)

Create a program that stores a 3x3 matrix and prints both diagonals along with their sums.

ArrayList and Collections Basics

In Java, when you need to store a dynamic collection of objects, arrays, while fundamental, have a significant limitation: their size is fixed once declared. This is where the Java Collections Framework comes in, providing a unified architecture for representing and manipulating collections. Among its most frequently used classes is ArrayList. An ArrayList is a resizable array implementation of the List interface. It allows you to add or remove elements after the ArrayList has been created, automatically resizing itself as needed. This flexibility makes it an indispensable tool for managing sequences of objects where the number of elements isn't known beforehand or changes frequently during program execution.

The Java Collections Framework itself is a set of interfaces and classes that represent groups of objects. It provides powerful and flexible ways to manage data. Key interfaces include List (ordered collection, allows duplicates), Set (unordered collection, no duplicates), and Map (stores key-value pairs). ArrayList implements the List interface, meaning it maintains insertion order and allows duplicate elements. It's used everywhere from storing user inputs in an application to managing items in a shopping cart, or even processing data retrieved from a database before displaying it.

Step-by-Step Explanation

To use an ArrayList, you first need to import it from the java.util package. Here's the basic syntax for declaration and common operations:

• Declaration: To declare an ArrayList, you specify the type of elements it will hold using generics. For example, ArrayList names = new ArrayList(); creates an ArrayList that can only store String objects.


• Adding Elements: Use the add() method. names.add("Alice"); adds "Alice" to the end. You can also add at a specific index: names.add(0, "Bob");.


• Accessing Elements: Use the get(index) method. String first = names.get(0); retrieves the element at index 0.


• Updating Elements: Use the set(index, element) method. names.set(1, "Charlie"); replaces the element at index 1 with "Charlie".


• Removing Elements: Use remove(index) or remove(Object). names.remove(0); removes the element at index 0. names.remove("Alice"); removes the first occurrence of "Alice".


• Size: Use size() to get the number of elements. int count = names.size();.


• Iterating: You can iterate using a traditional for loop, an enhanced for-each loop, or an Iterator.

Comprehensive Code Examples

Basic example

import java.util.ArrayList;

public class BasicArrayListExample {
    public static void main(String[] args) {
        // Declare and initialize an ArrayList of Strings
        ArrayList fruits = new ArrayList();

        // Add elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        System.out.println("Fruits: " + fruits); // Output: [Apple, Banana, Cherry]

        // Get an element
        String firstFruit = fruits.get(0);
        System.out.println("First fruit: " + firstFruit); // Output: First fruit: Apple

        // Update an element
        fruits.set(1, "Blueberry");
        System.out.println("Updated fruits: " + fruits); // Output: [Apple, Blueberry, Cherry]

        // Remove an element by index
        fruits.remove(2); // Removes Cherry
        System.out.println("Fruits after removing by index: " + fruits); // Output: [Apple, Blueberry]

        // Add another fruit
        fruits.add("Date");
        System.out.println("Fruits with Date: " + fruits); // Output: [Apple, Blueberry, Date]

        // Remove an element by value
        fruits.remove("Apple");
        System.out.println("Fruits after removing by value: " + fruits); // Output: [Blueberry, Date]

        // Get size
        System.out.println("Number of fruits: " + fruits.size()); // Output: Number of fruits: 2

        // Check if empty
        System.out.println("Is fruits list empty? " + fruits.isEmpty()); // Output: Is fruits list empty? false
    }
}

Real-world example: Managing a To-Do List

import java.util.ArrayList;

public class TodoListManager {
    private ArrayList todoList = new ArrayList();

    public void addTask(String task) {
        todoList.add(task);
        System.out.println("Added: " + task);
    }

    public void removeTask(String task) {
        if (todoList.remove(task)) {
            System.out.println("Removed: " + task);
        } else {
            System.out.println("Task not found: " + task);
        }
    }

    public void viewTasks() {
        System.out.println("--- To-Do List ---");
        if (todoList.isEmpty()) {
            System.out.println("No tasks to display.");
            return;
        }
        for (int i = 0; i < todoList.size(); i++) {
            System.out.println((i + 1) + ". " + todoList.get(i));
        }
        System.out.println("------------------");
    }

    public static void main(String[] args) {
        TodoListManager manager = new TodoListManager();
        manager.addTask("Buy groceries");
        manager.addTask("Finish Java assignment");
        manager.addTask("Call mom");
        manager.viewTasks();

        manager.removeTask("Finish Java assignment");
        manager.viewTasks();

        manager.removeTask("Go for a walk");
        manager.viewTasks();

        manager.addTask("Read a book");
        manager.viewTasks();
    }
}

Advanced usage: Storing custom objects and iterating with Streams

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

class Product {
    String name;
    double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product{" + "name='" + name + '\'' + ", price=" + price + '}';
    }

    public double getPrice() {
        return price;
    }
}

public class AdvancedArrayListUsage {
    public static void main(String[] args) {
        List shoppingCart = new ArrayList<>(); // Using List interface for declaration is good practice

        shoppingCart.add(new Product("Laptop", 1200.00));
        shoppingCart.add(new Product("Mouse", 25.50));
        shoppingCart.add(new Product("Keyboard", 75.00));
        shoppingCart.add(new Product("Monitor", 300.00));
        shoppingCart.add(new Product("Mouse", 30.00)); // Duplicate product name, different price

        System.out.println("Shopping Cart Items:");
        shoppingCart.forEach(System.out::println);

        // Filter products with price > 100 using Java Streams
        List expensiveItems = shoppingCart.stream()
.filter(p -> p.getPrice() > 100)
.collect(Collectors.toList());

        System.out.println("\nExpensive Items (> $100):");
        expensiveItems.forEach(System.out::println);

        // Calculate total price of all items
        double totalPrice = shoppingCart.stream()
                                        .mapToDouble(Product::getPrice)
                                        .sum();
        System.out.println("\nTotal cart price: $" + String.format("%.2f", totalPrice));
    }
}

Common Mistakes

• IndexOutOfBoundsException: Attempting to access an element at an index that doesn't exist (e.g., get(size()) or remove(size())). Fix: Always check the list's size before accessing or removing elements by index, ensuring the index is between 0 and size() - 1.


• Modifying while iterating: Adding or removing elements from an ArrayList while iterating over it using a for-each loop can lead to ConcurrentModificationException or unexpected behavior. Fix: Use an Iterator and its remove() method, or iterate using a traditional for loop and adjust indices carefully, or create a new list for modifications.


• Not specifying generic type (Raw Types): Declaring ArrayList list = new ArrayList(); without specifying the type (e.g., ) allows any object to be added, losing type safety and potentially leading to ClassCastException at runtime. Fix: Always use generics, e.g., ArrayList, to ensure type safety.

Best Practices

• Use the Interface Type: Declare ArrayList using its interface type, e.g., List myList = new ArrayList<>();. This promotes flexibility, allowing you to easily switch to other List implementations (like LinkedList) later without changing much of your code.


• Initial Capacity: If you know the approximate number of elements your ArrayList will hold, initialize it with that capacity (e.g., new ArrayList<>(100)). This avoids frequent reallocations and copying of the internal array, improving performance.


• Choose the Right Collection: Understand the differences between ArrayList, LinkedList, HashSet, HashMap, etc. ArrayList is good for fast random access (get(index)) but slower for insertions/deletions in the middle.


• Avoid Null Elements: While ArrayList allows null, storing null can lead to NullPointerException later. If null has meaning, handle it explicitly; otherwise, try to avoid it.

Practice Exercises

• Exercise 1 (Beginner): Create an ArrayList of integers. Add the numbers 10, 20, 30, 40, 50. Then, print each number on a new line using a for-each loop.


• Exercise 2: Create an ArrayList of your favorite movies. Add at least 5 movies. Then, remove the third movie from the list and print the updated list.


• Exercise 3: Write a program that takes 5 names as input from the user and stores them in an ArrayList. After all names are entered, print the total number of names and then print each name in reverse order of entry.

Mini Project / Task

Develop a simple 'Shopping Cart' application. Allow users to add items (represented by their names, e.g., "Laptop", "Mouse") to the cart. Implement functions to:

• Add an item to the cart.


• Remove an item from the cart (by name).


• View all items currently in the cart.


• Clear the entire cart.

Challenge (Optional)

Extend the 'Shopping Cart' application. Instead of just item names, create a Product class with fields like name (String), price (double), and quantity (int). Modify your ArrayList to store Product objects. Implement the following:

• When adding an item, if it already exists, increment its quantity instead of adding a new entry.


• When removing an item, if quantity > 1, decrement quantity; otherwise, remove the product.


• Calculate and display the total bill of all items in the cart (sum of price * quantity for each product).

Introduction to OOP

Step-by-Step Explanation

Comprehensive Code Examples

Basic Example: Class and Object

class Dog {
    String name;
    String breed;

    void bark() {
        System.out.println(name + " says Woof!");
    }

    public static void main(String[] args) {
        // Create a Dog object
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.breed = "Golden Retriever";
        myDog.bark(); // Output: Buddy says Woof!

        Dog anotherDog = new Dog();
        anotherDog.name = "Lucy";
        anotherDog.breed = "Labrador";
        anotherDog.bark(); // Output: Lucy says Woof!
    }
}

Real-world Example: Encapsulation and Inheritance

class Vehicle {
    private String make;
    private String model;
    private int year;

    public Vehicle(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public String getMake() { return make; }
    public String getModel() { return model; }
    public int getYear() { return year; }

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

    public void stop() {
        System.out.println("Vehicle is stopping.");
    }
}

class Car extends Vehicle { // Car inherits from Vehicle
    private int numberOfDoors;

    public Car(String make, String model, int year, int numberOfDoors) {
        super(make, model, year); // Call parent class constructor
        this.numberOfDoors = numberOfDoors;
    }

    public int getNumberOfDoors() { return numberOfDoors; }

    @Override // Method overriding (Polymorphism)
    public void start() {
        System.out.println(getMake() + " " + getModel() + " car is starting with a key.");
    }

    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Camry", 2020, 4);
        System.out.println("My car: " + myCar.getMake() + " " + myCar.getModel() + " (" + myCar.getYear() + ")");
        System.out.println("Doors: " + myCar.getNumberOfDoors());
        myCar.start();
        myCar.stop();

        Vehicle genericVehicle = new Vehicle("Generic", "ModelX", 2022);
        genericVehicle.start(); // Output: Vehicle is starting.
    }
}

Advanced Usage: Polymorphism with Interfaces

interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;

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

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

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

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

    @Override
    public double getArea() {
        return width * height;
    }
}

public class ShapeCalculator {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);

        // Polymorphism: treating Circle and Rectangle as Shape objects
        System.out.println("Area of Circle: " + circle.getArea());
        System.out.println("Area of Rectangle: " + rectangle.getArea());
    }
}

Common Mistakes

Best Practices

Practice Exercises

Mini Project / Task

Challenge (Optional)

Classes and Objects

Step-by-Step Explanation

Comprehensive Code Examples

class Car {
    String make;
    String model;
    int year;

    void start() {
        System.out.println(make + " " + model + " is starting.");
    }

    void stop() {
        System.out.println(make + " " + model + " is stopping.");
    }
}

public class CarDemo {
    public static void main(String[] args) {
        // Create an object (instance) of the Car class
        Car myCar = new Car();

        // Set attributes of the object
        myCar.make = "Toyota";
        myCar.model = "Camry";
        myCar.year = 2020;

        // Call methods on the object
        myCar.start();
        myCar.stop();

        Car anotherCar = new Car();
        anotherCar.make = "Honda";
        anotherCar.model = "Civic";
        anotherCar.year = 2022;
        anotherCar.start();
    }
}

class BankAccount {
    String accountNumber;
    double balance;

    // Constructor to initialize account details
    public BankAccount(String accNum, double initialBalance) {
        this.accountNumber = accNum;
        this.balance = initialBalance;
        System.out.println("Account " + accNum + " created with balance: $" + initialBalance);
    }

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited $" + amount + ". New balance: $" + balance);
        } else {
            System.out.println("Deposit amount must be positive.");
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            System.out.println("Withdrew $" + amount + ". New balance: $" + balance);
        } else if (amount <= 0) {
            System.out.println("Withdrawal amount must be positive.");
        } else {
            System.out.println("Insufficient funds. Current balance: $" + balance);
        }
    }

    double getBalance() {
        return balance;
    }
}

public class BankingApp {
    public static void main(String[] args) {
        BankAccount savings = new BankAccount("12345", 1000.00);
        BankAccount checking = new BankAccount("67890", 500.00);

        savings.deposit(200.00);
        checking.withdraw(150.00);
        savings.withdraw(1500.00); // Should show insufficient funds

        System.out.println("Savings account balance: $" + savings.getBalance());
        System.out.println("Checking account balance: $" + checking.getBalance());
    }
}

class Book {
    String title;
    String author;
    int yearPublished;

    // Default constructor
    public Book() {
        this("Unknown Title", "Unknown Author", 0); // Calls the three-argument constructor
        System.out.println("Default Book created.");
    }

    // Constructor with title and author
    public Book(String title, String author) {
        this(title, author, 0); // Calls the three-argument constructor
        System.out.println("Book with title and author created.");
    }

    // Full constructor
    public Book(String title, String author, int yearPublished) {
        this.title = title;
        this.author = author;
        this.yearPublished = yearPublished;
        System.out.println("Book fully initialized: " + title);
    }

    void displayBookInfo() {
        System.out.println("Title: " + title + ", Author: " + author + ", Year: " + (yearPublished == 0 ? "N/A" : yearPublished));
    }
}

public class Library {
    public static void main(String[] args) {
        Book book1 = new Book("The Hobbit", "J.R.R. Tolkien", 1937);
        Book book2 = new Book("1984", "George Orwell");
        Book book3 = new Book();

        book1.displayBookInfo();
        book2.displayBookInfo();
        book3.displayBookInfo();
    }
}

Common Mistakes

• Forgetting new keyword for object creation: Beginners often declare a class variable but forget to instantiate an object using new, leading to a NullPointerException when trying to access its members.
  Fix: Always use MyClass obj = new MyClass(); to create an object.


• Confusing class with object: Understanding that a class is a blueprint and an object is an actual instance can be tricky. Trying to call non-static methods directly on a class name (e.g., Car.start() instead of myCar.start()) is a common error.
  Fix: Remember that methods that operate on an object's state must be called on an object, not the class itself.


• Incorrect constructor usage: Not providing the correct arguments for a constructor, or not defining a no-argument constructor when one is implicitly called (e.g., when extending another class without explicitly calling a superclass constructor).
  Fix: Ensure you match the constructor's signature (number and type of arguments) when creating an object. If no explicit constructor is defined, Java provides a default no-argument constructor. If you define any constructor, the default one is not provided automatically.

Best Practices

• Encapsulation: Use access modifiers (private, public, protected) to control access to class members. Typically, make fields private and provide public getter and setter methods to access them. This protects data integrity and allows for controlled modification.


• Meaningful Names: Give classes, objects, attributes, and methods clear, descriptive names that reflect their purpose. Class names should be nouns (e.g., BankAccount), and method names should be verbs or verb phrases (e.g., depositMoney).


• Constructors for Initialization: Use constructors to ensure objects are created in a valid and consistent state. Avoid having objects with uninitialized or invalid states immediately after creation.


• Single Responsibility Principle (SRP): Design classes to have only one reason to change. Each class should have a single, well-defined responsibility. This makes classes easier to understand, test, and maintain.

Practice Exercises

• Create a class called Dog with attributes name and breed. Add a method bark() that prints "Woof! My name is [name]." Create two Dog objects and make them bark.


• Define a class Rectangle with attributes length and width. Include methods to calculate the area() and perimeter(). Instantiate a Rectangle object and print its area and perimeter.


• Design a class Student with attributes name, studentId, and grade. Create a constructor that initializes these attributes. Add a method displayStudentInfo() that prints all the student's details. Create a few Student objects and display their information.

Mini Project / Task

• A constructor to initialize all fields.


• increaseStock(int amount): Adds the specified amount to quantityInStock.


• decreaseStock(int amount): Subtracts the specified amount from quantityInStock, ensuring quantity doesn't go below zero.


• displayProductDetails(): Prints all product information.

Challenge (Optional)

Constructors and Initialization

Step-by-Step Explanation

• Declaration: public ClassName(parameter1Type parameter1Name, ...) { ... }


• No Return Type: Unlike methods, constructors do not specify a return type.


• Name Matches Class: The constructor's name must be identical to the class name, including case.


• Initialization Logic: Inside the constructor's body, you write the code to initialize the object's instance variables, typically using the `this` keyword to distinguish between instance variables and constructor parameters when they have the same name.


• Overloading: You can have multiple constructors in a single class, as long as each has a unique signature (different number or types of parameters). This is known as constructor overloading.


• `this()` and `super()`: Within a constructor, `this()` can be used to call another constructor in the same class (constructor chaining), and `super()` can be used to call a constructor of the parent class. Both `this()` and `super()` must be the very first statement in a constructor.

Comprehensive Code Examples

Basic Example: No-argument and Parameterized Constructors

class Dog {
    String name;
    String breed;

    // No-argument constructor
    public Dog() {
        this.name = "Buddy";
        this.breed = "Golden Retriever";
        System.out.println("Dog created with default name and breed.");
    }

    // Parameterized constructor
    public Dog(String name, String breed) {
        this.name = name;
        this.breed = breed;
        System.out.println("Dog created with custom name and breed.");
    }

    public void displayInfo() {
        System.out.println("Name: " + name + ", Breed: " + breed);
    }

    public static void main(String[] args) {
        Dog dog1 = new Dog(); // Calls no-arg constructor
        dog1.displayInfo();

        Dog dog2 = new Dog("Max", "German Shepherd"); // Calls parameterized constructor
        dog2.displayInfo();
    }
}

Real-world Example: User Account Initialization

class UserAccount {
    private String username;
    private String email;
    private boolean isActive;
    private long registrationDate;

    // Constructor for new user registration
    public UserAccount(String username, String email) {
        // Basic validation
        if (username == null || username.trim().isEmpty() || email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Invalid username or email provided.");
        }
        this.username = username;
        this.email = email;
        this.isActive = true; // New accounts are active by default
        this.registrationDate = System.currentTimeMillis(); // Set current time in milliseconds
        System.out.println("New user account created for: " + username);
    }

    // Constructor for loading existing user from database (e.g., deserialization)
    public UserAccount(String username, String email, boolean isActive, long registrationDate) {
        this.username = username;
        this.email = email;
        this.isActive = isActive;
        this.registrationDate = registrationDate;
        System.out.println("Existing user account loaded for: " + username);
    }

    public void displayAccountInfo() {
        System.out.println("Username: " + username + ", Email: " + email +
                           ", Active: " + isActive + ", Registered: " + new java.util.Date(registrationDate));
    }

    public static void main(String[] args) {
        UserAccount newUser = new UserAccount("john.doe", "[email protected]");
        newUser.displayAccountInfo();

        UserAccount loadedUser = new UserAccount("jane.smith", "[email protected]", false, 1678886400000L);
        loadedUser.displayAccountInfo();
    }
}

Advanced Usage: Constructor Chaining with `this()`

class Product {
    String id;
    String name;
    double price;
    int quantity;

    // Default product constructor
    public Product() {
        this("GEN001", "Generic Product", 0.0, 0); // Calls the 4-arg constructor
        System.out.println("Default product created.");
    }

    // Constructor for product with ID, name, price
    public Product(String id, String name, double price) {
        this(id, name, price, 1); // Calls the 4-arg constructor, default quantity to 1
        System.out.println("Product with ID, name, price created.");
    }

    // Full constructor for product with all details
    public Product(String id, String name, double price, int quantity) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.quantity = quantity;
        System.out.println("Full product details set.");
    }

    public void displayProduct() {
        System.out.println("ID: " + id + ", Name: " + name + ", Price: $" + price + ", Quantity: " + quantity);
    }

    public static void main(String[] args) {
        Product p1 = new Product();
        p1.displayProduct();

        Product p2 = new Product("LAP101", "Laptop", 1200.50);
        p2.displayProduct();

        Product p3 = new Product("MOU202", "Wireless Mouse", 25.99, 10);
        p3.displayProduct();
    }
}

Common Mistakes

• Forgetting `this` keyword: When constructor parameters have the same name as instance variables, failing to use `this.variableName` will assign the parameter to itself, leaving the instance variable uninitialized (or with its default value).
  

  class Wrong {
          String name;
          public Wrong(String name) {
              name = name; // Incorrect: assigns parameter to itself
          }
      }

  
  Fix: Use `this.name = name;` to correctly assign the parameter value to the instance variable.


• Adding a return type: Accidentally adding `void` or any other return type to a constructor makes it a regular method, not a constructor. It will no longer be invoked automatically upon object creation.
  

  class BadConstructor {
          public void BadConstructor() { // This is a method, not a constructor
              System.out.println("Oops!");
          }
      }

  
  Fix: Remove the return type: `public BadConstructor() { ... }`.


• Incorrect `this()` or `super()` usage: Using `this()` or `super()` anywhere other than the very first statement in a constructor, or trying to use both in the same constructor, will result in a compile-time error.
  

  class ErrorExample {
          public ErrorExample() {
              System.out.println("First line.");
              this(10); // Compile-time error: call to this must be first statement
          }
          public ErrorExample(int x) { /*...*/ }
      }

  
  Fix: Ensure `this()` or `super()` is the absolute first line of code in the constructor's body.

Best Practices

• Provide essential initialization: Constructors should only initialize the object to a valid, consistent state. Avoid complex business logic or operations that could fail (like network calls) inside constructors. If complex setup is needed, use a separate `init()` method.


• Use constructor overloading wisely: Offer a variety of constructors to provide flexibility in object creation, but avoid an excessive number. Use constructor chaining (`this()`) to reduce code duplication between constructors.


• Validate input: If constructor parameters are critical for the object's validity, perform basic validation. Throw `IllegalArgumentException` for invalid inputs to prevent creating malformed objects.


• Be mindful of inheritance: If a subclass constructor doesn't explicitly call `super()`, the Java compiler automatically inserts a call to the no-argument `super()` constructor. Ensure your superclass has an accessible no-argument constructor if you don't explicitly call another `super()` constructor.


• Immutable objects: For immutable classes, constructors are the only place to set instance variables. Make sure all fields are `final` and initialized in the constructor to ensure immutability.

Practice Exercises

• Book Class: Create a class `Book` with instance variables `title` (String), `author` (String), and `isbn` (String). Implement a parameterized constructor that takes all three values and initializes them. Also, create a no-argument constructor that sets default values like "Unknown Title", "Anonymous", and "N/A".


• Rectangle Class: Design a `Rectangle` class with `width` (double) and `height` (double). Provide two constructors: one that takes `width` and `height`, and another that takes only one `side` parameter to create a square (where `width` equals `height`). Include a method `getArea()` that calculates the area.


• Student Class with ID Generation: Create a `Student` class with `name` (String) and `studentId` (int). Implement a constructor that takes only the `name`. Inside this constructor, automatically generate a unique `studentId` (e.g., using a static counter that increments with each new student).

Mini Project / Task

Challenge (Optional)

The this Keyword

In Java, this is a special reference variable that points to the current object—the object whose method or constructor is currently running. It exists so Java can clearly distinguish between an object’s own fields and local variables or parameters with the same names. This is especially useful in constructors, setters, fluent APIs, and event-driven or enterprise code where many objects hold state. In real applications, this helps keep object initialization readable, supports constructor chaining, and makes method chaining possible in builder-style designs. The most common uses are: referring to the current object’s instance variables, calling another constructor in the same class using this(...), passing the current object to another method, and returning the current object from a method. Unlike super, which refers to a parent class, this always refers to the current class instance. It cannot be used inside a static context because static members belong to the class, not to any specific object. Understanding this is important because it improves code clarity and avoids ambiguity in object-oriented programming.

Step-by-Step Explanation

When you create an object from a class, Java stores data for that object in instance variables. Inside a method or constructor, if a parameter has the same name as an instance variable, Java gives priority to the local parameter. To access the instance variable, write this.variableName. For example, in a constructor Employee(String name), the statement this.name = name; means “assign the parameter name to the current object’s field name.”

You can also call one constructor from another constructor in the same class using this(...). This must be the first statement inside that constructor. This technique reduces duplication. Another use is passing the current object as an argument, such as manager.register(this). Finally, a method can return this so calls can be chained together, such as config.setHost("localhost").setPort(8080).

Comprehensive Code Examples

Basic example

class Student {
    String name;
    int age;

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

    void display() {
        System.out.println(name + " - " + age);
    }
}

Real-world example

class BankAccount {
    private String accountHolder;
    private double balance;

    BankAccount(String accountHolder) {
        this(accountHolder, 0.0);
    }

    BankAccount(String accountHolder, double balance) {
        this.accountHolder = accountHolder;
        this.balance = balance;
    }

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

    void printSummary() {
        System.out.println(this.accountHolder + ": " + this.balance);
    }
}

Advanced usage

class QueryBuilder {
    private String table;
    private String condition;

    QueryBuilder setTable(String table) {
        this.table = table;
        return this;
    }

    QueryBuilder setCondition(String condition) {
        this.condition = condition;
        return this;
    }

    String build() {
        return "SELECT * FROM " + this.table + " WHERE " + this.condition;
    }
}

Usage: new QueryBuilder().setTable("employees").setCondition("salary > 50000").build();

Common Mistakes

• Forgetting this when parameter names match field names, causing no real field assignment. Fix: use this.field = field;.

• Using this inside a static method. Fix: access instance members only through an object, or remove static if object state is required.

• Placing this(...) after another statement in a constructor. Fix: constructor chaining must be the first statement.

• Confusing this with super. Fix: use this for the current object and super for parent-class members.

Best Practices

• Use this when it improves readability, especially in constructors and setters.

• Use constructor chaining with this(...) to avoid repeating initialization logic.

• Return this only when designing fluent APIs intentionally.

• Avoid unnecessary overuse such as prefixing every field access unless your team style requires it.

• Keep field names meaningful so this adds clarity rather than confusion.

Practice Exercises

• Create a Book class with fields title and price. Use this in the constructor to initialize both fields.

• Create a User class with two constructors: one that accepts only a username and another that accepts username and email. Use this(...) for constructor chaining.

• Create a Settings class with methods like setTheme() and setLanguage() that return this for method chaining.

Mini Project / Task

Build a small EmployeeProfile class with multiple constructors, setter methods, and a summary method. Use this for field assignment, constructor chaining, and optionally method chaining.

Challenge (Optional)

Design a simple ReportBuilder class where each configuration method returns this, and one constructor calls another using this(...). Then generate a final report description string.

Static Members and Methods

In Java, static members belong to the class itself rather than to individual objects. This means a static variable is shared by all instances of a class, and a static method can be called without creating an object first. Java provides static members so developers can model data and behavior that should exist once per class, such as counters, utility functions, configuration values, or factory helpers. In real-world applications, static members are commonly used for application constants, logging helpers, object tracking, validation utilities, and launching programs through the main method. The two main forms are static variables and static methods. A static variable stores one shared value for the whole class. A static method performs work related to the class and can directly access only other static members unless it receives an object reference. Static blocks also exist and are used for one-time class initialization, though they are less common for beginners. Understanding the difference between instance and static behavior is critical because it affects memory usage, access style, and design decisions.

Step-by-Step Explanation

To declare a static member, place the static keyword before the variable or method. Access it using the class name, such as ClassName.member. For example, count can track how many objects have been created. Every time the constructor runs, the same shared variable is updated. Static methods are declared similarly and are called with the class name, such as Math.max(). A static method cannot directly use instance variables like name because those belong to specific objects, not the class itself. If a static method needs object data, pass an object as a parameter. Constants are usually written as public static final, combining shared access with immutability.

Comprehensive Code Examples

Basic example

class Counter {
    static int total = 0;

    Counter() {
        total++;
    }
}

public class Main {
    public static void main(String[] args) {
        new Counter();
        new Counter();
        System.out.println(Counter.total);
    }
}

Real-world example

class AppConfig {
    public static final String APP_NAME = "InventorySystem";

    public static void printWelcome() {
        System.out.println("Welcome to " + APP_NAME);
    }
}

public class Main {
    public static void main(String[] args) {
        AppConfig.printWelcome();
    }
}

Advanced usage

class Employee {
    private String name;
    private static int nextId = 1000;
    private int id;

    public Employee(String name) {
        this.name = name;
        this.id = generateId();
    }

    private static int generateId() {
        return nextId++;
    }

    public void display() {
        System.out.println(id + " - " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee("Asha");
        Employee e2 = new Employee("Rahul");
        e1.display();
        e2.display();
    }
}

Common Mistakes

• Using instance variables inside a static method: Fix by passing an object reference or making the data static only if it should be shared.
• Accessing static members through objects: It works, but use the class name like Counter.total for clarity.
• Making data static by accident: Shared values can cause bugs when each object should have its own state.
• Modifying constants: Use final with static values that must never change.

Best Practices

• Use static variables only for truly shared class-level data.
• Prefer static methods for utility behavior that does not depend on object state.
• Access static members with the class name for readability.
• Use public static final for constants and name them in uppercase.
• Avoid overusing static state in large applications because it can make testing and maintenance harder.

Practice Exercises

• Create a class Book with a static variable that counts how many book objects were created.
• Write a utility class TemperatureConverter with static methods to convert Celsius to Fahrenheit and Fahrenheit to Celsius.
• Create a class BankAccount with a static interest rate shared by all accounts.

Mini Project / Task

Build a simple visitor tracking system where each new Visitor object increases a shared static counter, and add a static method to display the total number of visitors.

Challenge (Optional)

Create a class with a static block that initializes a shared starting value, then use static methods to manage unique IDs for newly created objects.

Enums in Java

Enums, short for enumerations, are a special type of class in Java that represent a fixed set of constants. They were introduced in Java 5 to provide a more type-safe and robust way to handle collections of related constants compared to traditional integer or string constants. Before enums, developers often used public static final integer fields to represent a fixed set of values, which could lead to issues like invalid values being assigned or comparisons between unrelated constants. Enums solve these problems by creating a distinct type, ensuring that only the predefined values can be used. They are widely used in real-world applications for scenarios like representing days of the week, months of the year, cardinal directions, status codes (e.g., SUCCESS, FAILED, PENDING), different types of operations, or user roles (ADMIN, GUEST, USER). Their primary purpose is to improve code readability, maintainability, and prevent common programming errors associated with misusing arbitrary constant values.

Java enums are more powerful than simple constant collections; they can have constructors, methods, and even implement interfaces, just like regular classes. Each enum constant is an instance of the enum type. This means that you can associate data and behavior with each constant. For example, an enum representing different types of coffee could have a price field and a method to calculate the total cost based on quantity. This object-oriented nature makes enums highly flexible and suitable for complex constant management. The core concept revolves around defining a fixed set of named values, where each value is an object of the enum type itself. There are no sub-types of enums in the traditional sense, but their capabilities extend far beyond simple lists of names.

Step-by-Step Explanation

Defining an enum is straightforward. You use the enum keyword, followed by the enum's name, and then list the constants separated by commas inside curly braces. Optionally, you can add fields, constructors, and methods.

• Basic Enum Declaration:
  public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
  Each constant (e.g., SUNDAY) is implicitly public static final.


• Enum with Fields and Constructor:
  You can add instance variables to an enum and initialize them using a constructor. The constructor must be private or package-private; it cannot be public or protected because enums are instantiated internally by the Java compiler.


• Enum with Methods:
  Enums can have methods, including abstract methods that each constant can implement differently (constant-specific method implementations).


• Using Enums in switch Statements:
  Enums are excellent for use in switch statements, providing type safety and ensuring that all possible enum values are handled (or a default case is provided).

Comprehensive Code Examples

Basic example

public class BasicEnumExample {
    enum TrafficLight {
        RED, YELLOW, GREEN
    }

    public static void main(String[] args) {
        TrafficLight currentLight = TrafficLight.RED;

        System.out.println("Current Light: " + currentLight);

        for (TrafficLight light : TrafficLight.values()) {
            System.out.println("Traffic Light: " + light + " at ordinal " + light.ordinal());
        }
    }
}

Real-world example

public class OrderProcessor {
    public enum OrderStatus {
        PENDING("Order is awaiting processing."),
        PROCESSING("Order is being prepared."),
        SHIPPED("Order has left the warehouse."),
        DELIVERED("Order has been delivered."),
        CANCELLED("Order has been cancelled.");

        private final String description;

        OrderStatus(String description) {
            this.description = description;
        }

        public String getDescription() {
            return description;
        }
    }

    public void processOrder(OrderStatus status) {
        switch (status) {
            case PENDING:
                System.out.println("New order received: " + status.getDescription());
                break;
            case PROCESSING:
                System.out.println("Working on order: " + status.getDescription());
                break;
            case SHIPPED:
                System.out.println("Order dispatched: " + status.getDescription());
                break;
            case DELIVERED:
                System.out.println("Order completed: " + status.getDescription());
                break;
            case CANCELLED:
                System.out.println("Order halt: " + status.getDescription());
                break;
        }
    }

    public static void main(String[] args) {
        OrderProcessor processor = new OrderProcessor();
        processor.processOrder(OrderStatus.PENDING);
        processor.processOrder(OrderStatus.SHIPPED);
        processor.processOrder(OrderStatus.DELIVERED);
        System.out.println(OrderStatus.CANCELLED.getDescription());
    }
}

Advanced usage

public class AdvancedEnumExample {
    public enum Operation {
        ADD {
            @Override
            public double apply(double x, double y) { return x + y; }
        },
        SUBTRACT {
            @Override
            public double apply(double x, double y) { return x - y; }
        },
        MULTIPLY {
            @Override
            public double apply(double x, double y) { return x * y; }
        },
        DIVIDE {
            @Override
            public double apply(double x, double y) { 
                if (y == 0) throw new IllegalArgumentException("Cannot divide by zero");
                return x / y; 
            }
        };

        public abstract double apply(double x, double y);

        public static Operation fromString(String op) {
            for (Operation operation : values()) {
                if (operation.name().equalsIgnoreCase(op)) {
                    return operation;
                }
            }
            throw new IllegalArgumentException("Unknown operation: " + op);
        }
    }

    public static void main(String[] args) {
        double resultAdd = Operation.ADD.apply(10, 5);
        System.out.println("10 + 5 = " + resultAdd);

        double resultDivide = Operation.DIVIDE.apply(20, 4);
        System.out.println("20 / 4 = " + resultDivide);

        try {
            Operation.DIVIDE.apply(10, 0);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }

        Operation op = Operation.fromString("multiply");
        System.out.println("Using fromString: 7 * 3 = " + op.apply(7, 3));
    }
}

Common Mistakes

• Treating Enums as Strings/Integers: While enums can be converted to strings (name() or toString()) and have an ordinal value (ordinal()), they are full-fledged objects. Comparing them using == is usually preferred over equals() for identity, but comparing their string representation can lead to subtle bugs if not handled carefully. Fix: Always use the enum constant directly, e.g., if (status == OrderStatus.PENDING).


• Forgetting to Handle All Enum Cases in switch: When adding new constants to an enum, it's easy to forget to update all switch statements that use it. This won't cause a compile-time error unless you omit a default case in modern Java versions for exhaustive checking. Fix: Use a default case or rely on IDE warnings for non-exhaustive switches. Better yet, leverage constant-specific method implementations to avoid large switch blocks.


• Using Enums for Open-Ended Sets of Values: Enums are best for fixed, known sets of constants. If the set of values can change frequently or is determined at runtime, enums might not be the best fit. Fix: Consider using a class hierarchy or a database-driven approach for dynamic sets of values.

Best Practices

• Use Enums for Fixed Collections: Reserve enums for values that are logically grouped and finite, like days of the week, error codes, or states in a state machine.


• Add Meaningful Fields and Methods: Don't just declare bare enum constants. If each constant has associated data or behavior, embed it within the enum itself using fields, constructors, and methods. This makes the enum more powerful and encapsulated.


• Implement Interfaces: Enums can implement interfaces, allowing them to participate in polymorphism. This is a powerful way to organize related behaviors without resorting to large switch statements.


• Override toString(): By default, toString() returns the constant's name. Override it if you need a more user-friendly representation, especially for logging or UI display.


• Prefer EnumSet and EnumMap: For collections of enums, use EnumSet and EnumMap. They are highly optimized, efficient, and type-safe implementations of Set and Map specifically designed for enums.

Practice Exercises

1. Simple Enum Creation: Create an enum called Season with constants for SPRING, SUMMER, AUTUMN, and WINTER. Write a small program that iterates through all seasons and prints their names.


2. Enum with Data: Modify the Season enum to include a field for the average temperature (e.g., SPRING(15), SUMMER(30)). Add a method to get this temperature. Print each season and its average temperature.


3. Enum in a Method: Write a method describeSeason(Season season) that takes a Season enum as input and uses a switch statement to print a short description for each season.

Mini Project / Task

Design a simple coffee order system. Create an enum called CoffeeSize with constants like SMALL, MEDIUM, LARGE. Each size should have an associated price (e.g., Small: $2.50, Medium: $3.00, Large: $3.50). Implement a method in the enum that returns its price. Then, in your main method, calculate and print the total cost for two medium coffees and one large coffee.

Challenge (Optional)

Expand the CoffeeSize enum from the mini-project to include an abstract method getPreparationTime(). Implement this method for each enum constant, providing different preparation times (e.g., Small: 2 mins, Medium: 3 mins, Large: 4 mins). Additionally, add another enum called CoffeeType (e.g., ESPRESSO, LATTE, CAPPUCCINO) with an abstract method getBrewingMethod(). Show how you can combine these two enums (perhaps in a class representing a complete coffee order) to calculate total price and estimated total preparation time.

Inheritance Basics

Inheritance is one of the core ideas of object-oriented programming in Java. It allows one class to acquire fields and methods from another class so that common behavior can be written once and reused. The class being inherited from is often called the parent, superclass, or base class, while the class that inherits is called the child, subclass, or derived class. This exists to reduce duplication, make programs easier to maintain, and model real-world relationships such as Vehicle → Car, Employee → Manager, or Account → SavingsAccount. In enterprise applications, inheritance is used when multiple classes share common properties and behaviors, such as common audit fields, shared validation logic, or reusable business actions. Java supports single inheritance for classes, meaning one class can extend only one other class, which helps keep designs simpler and avoids ambiguity. A subclass inherits accessible members from its superclass and can also add new features or redefine inherited behavior through method overriding. This makes inheritance both a reuse tool and a specialization tool.

Types and key ideas

The most common form is single inheritance, where one child extends one parent. Java also supports multilevel inheritance, such as Animal → Mammal → Dog. Hierarchical inheritance is also common, where multiple subclasses extend the same superclass, such as Employee, Contractor, and Intern extending Person. Java does not allow multiple inheritance of classes, but similar flexibility is achieved with interfaces. Two important keywords are extends, used to inherit from a class, and super, used to refer to the parent class constructor or methods. Another important idea is method overriding, where a child class provides its own version of an inherited method.

Step-by-Step Explanation

To create inheritance, first define a general parent class with shared fields and methods. Then create a child class using extends. The child can use inherited public and protected members directly. If the parent has a constructor, the child can call it with super(...). When a child defines a method with the same signature as the parent, Java uses the child version at runtime. This is overriding. Use the @Override annotation to make your intent clear and catch mistakes. Private members are not directly accessible in the child, so expose needed behavior through protected or public methods. Think carefully about whether the relationship is truly “is-a.” A Car is a Vehicle, so inheritance fits. A Car has an Engine, so that should usually be composition, not inheritance.

Comprehensive Code Examples

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.bark();
    }
}

class Employee {
    String name;

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

    void work() {
        System.out.println(name + " is working");
    }
}

class Manager extends Employee {
    Manager(String name) {
        super(name);
    }

    @Override
    void work() {
        System.out.println(name + " is managing a team");
    }
}

class Account {
    protected double balance;

    Account(double balance) {
        this.balance = balance;
    }

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

    void showBalance() {
        System.out.println("Balance: " + balance);
    }
}

class SavingsAccount extends Account {
    private double interestRate;

    SavingsAccount(double balance, double interestRate) {
        super(balance);
        this.interestRate = interestRate;
    }

    void addInterest() {
        balance += balance * interestRate;
    }
}

Common Mistakes

• Using inheritance for a “has-a” relationship. Fix: use composition when one object contains another instead of being a specialized version of it.

• Forgetting to call the correct parent constructor. Fix: use super(...) when the superclass requires arguments.

• Trying to access private parent fields directly. Fix: use protected members carefully or create getter and setter methods.

• Accidentally overloading instead of overriding. Fix: keep the exact same method signature and add @Override.

Best Practices

• Use inheritance only when the child truly is a type of the parent.

• Keep parent classes focused on shared behavior, not unrelated features.

• Prefer composition when reuse does not represent a true hierarchy.

• Use @Override for all overridden methods.

• Avoid deep inheritance chains because they become hard to understand and maintain.

Practice Exercises

• Create a class Vehicle with a method start(), then create a class Car that extends it and adds a method openTrunk().

• Create a class Person with fields for name and age, then create a class Student that adds a grade field and prints all details.

• Create a class Shape with a method draw(), then override it in subclasses Circle and Rectangle.

Mini Project / Task

Build a small employee management model with a parent class Employee and child classes such as Developer and Manager. Each subclass should override a method like work() to display role-specific behavior.

Challenge (Optional)

Design a multilevel inheritance example for a banking system, such as Account → InterestAccount → FixedDepositAccount, and decide which methods should be inherited and which should be overridden.

Method Overriding and Super

Method overriding is a core feature of inheritance in Java that allows a child class to provide its own version of a method already defined in a parent class. This exists so developers can reuse a general structure from a base class while customizing behavior for specific subclasses. In real applications, overriding is used in payment systems, notification services, employee management, UI frameworks, and API integrations where different object types share a common contract but behave differently. The super keyword works closely with overriding. It is used to access parent class members, especially when a child class wants to extend rather than completely replace inherited behavior. For example, a logging service may override a method to add extra details but still call the parent implementation first using super. In Java, overriding supports runtime polymorphism, meaning the method that runs depends on the actual object type, not just the reference type. This makes programs flexible and easier to extend.

Overriding follows important rules. The method name, parameter list, and compatible return type must match the parent method. The access level cannot be more restrictive than the parent version. Static methods are hidden, not overridden, and private methods cannot be overridden because they are not inherited normally. The @Override annotation is strongly recommended because it helps the compiler catch mistakes early.

Step-by-Step Explanation

To override a method, first create a parent class with a method. Next, create a child class using extends. Then write a method in the child class with the same signature. If needed, use super.methodName() to call the parent version. You can also use super(...) inside a child constructor to call the parent constructor. This is useful when the parent class initializes shared fields.

Basic syntax: child class extends parent class, same method signature, optional @Override, then custom logic. Use super when you want inherited behavior plus additional child behavior.

Comprehensive Code Examples

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

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

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
    }
}

class Employee {
    void calculateBonus() {
        System.out.println("Standard company bonus");
    }
}

class Manager extends Employee {
    @Override
    void calculateBonus() {
        super.calculateBonus();
        System.out.println("Additional manager performance bonus");
    }
}

class Vehicle {
    String brand;

    Vehicle(String brand) {
        this.brand = brand;
    }

    void start() {
        System.out.println(brand + " vehicle starting");
    }
}

class ElectricCar extends Vehicle {
    int batteryLevel;

    ElectricCar(String brand, int batteryLevel) {
        super(brand);
        this.batteryLevel = batteryLevel;
    }

    @Override
    void start() {
        super.start();
        System.out.println("Battery level: " + batteryLevel + "%");
        System.out.println("Electric systems ready");
    }
}

Common Mistakes

• Wrong method signature: Changing parameters creates a new method instead of overriding. Fix it by matching the parent signature exactly.
• Forgetting @Override: This can hide errors. Fix it by always adding the annotation.
• Using super incorrectly: Calling super outside a child context or after other constructor statements causes errors. Fix it by using super(...) as the first constructor statement.
• Trying to override private or static methods: These do not behave like normal overridden methods. Fix it by understanding inheritance rules.

Best Practices

• Use @Override on every overridden method.
• Call super only when parent behavior is still meaningful.
• Keep overridden methods focused and easy to read.
• Preserve expected behavior so subclasses remain reliable replacements for parent types.
• Use descriptive class hierarchies instead of forcing inheritance where composition is better.

Practice Exercises

• Create a Shape class with an area() method, then override it in Circle.
• Create a User class with a displayRole() method, then override it in Admin and Customer.
• Create a parent constructor that sets a name field and call it from a child class using super.

Mini Project / Task

Build a small notification system with a parent Notification class and child classes like EmailNotification and SMSNotification. Override a send() method and use super to print common delivery information.

Challenge (Optional)

Create a multi-level inheritance example with three classes where each level overrides the same method and selectively calls super to show the full execution chain.

Abstraction and Abstract Classes

Abstraction in Java is the process of hiding implementation details and exposing only the essential behavior of an object. It exists to reduce complexity, improve code organization, and let developers work with general contracts instead of low-level logic. In real applications, abstraction appears everywhere: payment systems expose a common payment operation while each provider processes transactions differently, vehicle systems define shared driving behavior while cars and bikes implement it in their own way, and employee management systems define common payroll rules while full-time and contract employees calculate salaries differently.

An abstract class is a class that cannot be instantiated directly. It is designed to act as a blueprint for subclasses. It can contain abstract methods, which have no body and must be implemented by child classes, and concrete methods, which already contain reusable logic. This makes abstract classes useful when related classes share state and behavior but still require specialized implementations. In Java, abstraction is commonly used in framework design, layered architectures, and domain modeling where multiple related types need a shared base.

There are two main parts to understand here: abstraction as a design idea, and abstract classes as one way to implement that idea. An abstract class may include fields, constructors, normal methods, static methods, and abstract methods. A subclass uses the extends keyword and must implement all inherited abstract methods unless the subclass is also abstract.

Step-by-Step Explanation

To declare an abstract class, use the abstract keyword before class. To declare an abstract method, use abstract before the return type and end the method with a semicolon instead of a body.

Basic syntax: an abstract parent defines common fields and methods, then child classes provide the missing behavior. If the parent has an abstract method like calculateSalary(), every concrete child must implement it. You cannot create an object with new Employee() if Employee is abstract, but you can write Employee emp = new FullTimeEmployee(...) to use abstraction through a parent reference.

Comprehensive Code Examples

abstract class Animal {
    abstract void makeSound();

    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.makeSound();
        a.sleep();
    }
}

abstract class Employee {
    String name;

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

    abstract double calculateSalary();

    void showDetails() {
        System.out.println(name + " earns " + calculateSalary());
    }
}

class FullTimeEmployee extends Employee {
    double monthlySalary;

    FullTimeEmployee(String name, double monthlySalary) {
        super(name);
        this.monthlySalary = monthlySalary;
    }

    double calculateSalary() {
        return monthlySalary;
    }
}

class ContractEmployee extends Employee {
    int hours;
    double rate;

    ContractEmployee(String name, int hours, double rate) {
        super(name);
        this.hours = hours;
        this.rate = rate;
    }

    double calculateSalary() {
        return hours * rate;
    }
}

abstract class PaymentProcessor {
    abstract void pay(double amount);

    void validate(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Invalid amount");
        }
    }
}

class CardPayment extends PaymentProcessor {
    void pay(double amount) {
        validate(amount);
        System.out.println("Paid by card: " + amount);
    }
}

Common Mistakes

• Trying to create an object of an abstract class. Fix: instantiate a concrete subclass instead.

• Forgetting to implement all abstract methods in a child class. Fix: implement every required method or declare the child class abstract.

• Using an abstract class when there is no shared state or behavior. Fix: use abstraction only when a meaningful common base exists.

Best Practices

• Place common fields and reusable methods in the abstract class to avoid duplication.

• Keep abstract methods focused on behaviors that genuinely vary between subclasses.

• Use meaningful parent names such as Employee, Vehicle, or PaymentProcessor.

Practice Exercises

• Create an abstract class Shape with an abstract method area(), then implement Circle and Rectangle.

• Build an abstract class Appliance with a concrete method powerOn() and an abstract method operate().

• Create an abstract class Account with an abstract method calculateInterest() and two subclasses for savings and fixed deposit accounts.

Mini Project / Task

Design a simple transport management system using an abstract class Transport with shared fields like name and speed, plus an abstract method move(). Implement subclasses such as Bus and Train and print their movement details.

Challenge (Optional)

Create an abstract class Notification with a concrete validation method and an abstract send() method. Then implement email, SMS, and push notification subclasses and process them through a single parent reference array.

Interfaces and Multiple Inheritance

In Java, an interface defines a contract: it specifies what a class must do without fully describing how it does it. Interfaces exist to support abstraction, loose coupling, and polymorphism. In real applications, interfaces are used everywhere: payment gateways implement a payment contract, logging tools implement a logger contract, and different notification systems implement a common messaging contract. Java does not allow multiple inheritance of classes because inheriting implementation from many classes can create ambiguity and complexity. However, Java does support multiple inheritance of type through interfaces, which means one class can implement multiple interfaces. This gives developers flexibility without the dangers of inheriting conflicting object state. Modern Java interfaces can also contain default and static methods, making them more powerful than earlier versions.

The main concepts are simple. A class implements one or more interfaces. An interface can declare abstract methods, default methods with implementation, static utility methods, and constants. Multiple inheritance in Java usually means a class implements several interfaces such as Printable, Scannable, and Faxable. If two interfaces define the same default method, the implementing class must override it and resolve the conflict explicitly. This design is widely used in enterprise systems because teams can program against interfaces instead of concrete classes, making code easier to test, replace, and extend.

Step-by-Step Explanation

To create an interface, use the interface keyword. Inside it, define method signatures. Then create a class and use implements to provide the method bodies. A class can implement one interface or several separated by commas. If an interface has a default method, the class may use it directly or override it. If two implemented interfaces contain the same default method, Java forces you to override that method in the class to avoid ambiguity. This is Java's controlled approach to multiple inheritance.

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }
}

interface Printer {
    void print();
}

interface Scanner {
    void scan();
}

class OfficeMachine implements Printer, Scanner {
    public void print() {
        System.out.println("Printing document");
    }

    public void scan() {
        System.out.println("Scanning document");
    }
}

Comprehensive Code Examples

interface Flyable {
    void fly();
}

class Bird implements Flyable {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

interface PaymentMethod {
    void pay(double amount);
}

interface Refundable {
    void refund(double amount);
}

class CreditCardPayment implements PaymentMethod, Refundable {
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using credit card");
    }

    public void refund(double amount) {
        System.out.println("Refunded $" + amount + " to credit card");
    }
}

interface A {
    default void show() {
        System.out.println("A show");
    }
}

interface B {
    default void show() {
        System.out.println("B show");
    }
}

class Demo implements A, B {
    public void show() {
        A.super.show();
        B.super.show();
        System.out.println("Resolved in Demo");
    }
}

Common Mistakes

• Forgetting to implement all abstract methods: if a class implements an interface, every required method must be defined unless the class is abstract.
• Confusing interface inheritance with class inheritance: interfaces define contracts, not object state like regular classes.
• Ignoring default method conflicts: when two interfaces provide the same default method, override it in the implementing class.

Best Practices

• Program to interfaces: declare variables, parameters, and return types using interfaces when possible.
• Keep interfaces focused: prefer small, meaningful contracts over large interfaces with unrelated methods.
• Use default methods carefully: they are useful for shared behavior, but too much logic in interfaces can hurt clarity.
• Name interfaces clearly: use names that describe capability, such as Serializable or Runnable.

Practice Exercises

• Create an interface called Playable with a method play(), then implement it in a class called Guitar.
• Create two interfaces, Writable and Readable, and a class FileDocument that implements both.
• Create two interfaces with the same default method name and write a class that resolves the conflict correctly.

Mini Project / Task

Build a small media device system where one class implements multiple interfaces such as Playable, Recordable, and Connectable. Add methods that simulate playing audio, recording sound, and connecting to a device.

Challenge (Optional)

Design a smart home controller using multiple interfaces like Switchable, Monitorable, and Schedulable. Then create one class that implements all of them and handles a default method conflict.

Encapsulation and Access Modifiers

Encapsulation is a core object-oriented programming principle that protects an object's internal state by controlling how its data is accessed and modified. In Java, this is commonly achieved by making fields private and exposing public methods such as getters, setters, or carefully designed business methods. This approach exists to prevent invalid data, reduce accidental misuse, and make classes easier to maintain. In real-world software, encapsulation is used in banking systems, employee records, inventory applications, and APIs where sensitive or important values must not be changed directly. Access modifiers are the tools Java gives us to enforce this control. The four main access levels are private, default package-private, protected, and public. private members are accessible only inside the same class. Default access allows use within the same package. protected allows package access and subclass access. public allows access from anywhere. Together, encapsulation and access modifiers help developers build safer and clearer code.

Step-by-Step Explanation

To encapsulate data in Java, start by declaring class fields with private. This prevents outside code from changing values directly. Next, create methods that provide controlled access. A getter returns a value. A setter updates a value, often with validation. In many professional classes, instead of exposing a generic setter, developers create meaningful methods such as deposit(), withdraw(), or changePassword(). This makes the code reflect business rules. Syntax is straightforward: define a class, declare private fields, and add public methods. If you want a member visible only in the same package, omit the modifier. Use protected when subclasses need access. Use public only for the parts of a class meant to be used by other classes. A good beginner rule is simple: fields are usually private, methods are public only when needed, and validation should happen before changing state.

Comprehensive Code Examples

class Person {
    private String name;

    public String getName() {
        return name;
    }

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

class BankAccount {
    private double balance;

    public double getBalance() {
        return balance;
    }

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

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

class Employee {
    private final int id;
    private String department;
    protected String role;

    public Employee(int id, String department, String role) {
        this.id = id;
        this.department = department;
        this.role = role;
    }

    public int getId() {
        return id;
    }

    void setDepartment(String department) {
        if (department != null && !department.isBlank()) {
            this.department = department;
        }
    }

    public String getSummary() {
        return id + " - " + department + " - " + role;
    }
}

Common Mistakes

• Making fields public: This allows uncontrolled changes. Fix it by using private fields and public methods.
• Creating setters without validation: Invalid values can enter the object. Fix it by checking ranges, null values, or business rules.
• Using public everywhere: This weakens class design. Fix it by exposing only what other classes truly need.
• Confusing protected with public: protected is not global access. Fix it by learning its package and inheritance behavior.

Best Practices

• Keep fields private by default.
• Expose behavior, not just data. Prefer methods like deposit() over unrestricted setters.
• Validate all incoming values.
• Use immutable fields when possible. Mark values final if they should not change.
• Choose the narrowest access level. Start restrictive, then open access only when necessary.

Practice Exercises

• Create a Student class with private fields for name and grade. Add public getter methods and a setter for grade that accepts only values from 0 to 100.
• Create a TemperatureSensor class with a private temperature field and a method that updates it only if the value is within a realistic range.
• Create a Book class with a private title and a final ISBN. Add methods to read the values and allow the title to be changed safely.

Mini Project / Task

Build a simple UserAccount class for a registration system. Store username, password, and login attempt count using proper access modifiers. Prevent direct password access and provide methods to change the password and record login attempts safely.

Challenge (Optional)

Design a ShoppingCart class where the item list cannot be modified directly from outside the class. Provide methods to add items, remove items, and calculate the total while keeping the internal data protected.

Polymorphism

Polymorphism is one of the most important ideas in object-oriented programming. The word means “many forms,” and in Java it allows one interface, parent class, or reference type to represent different object behaviors. This exists so developers can write flexible code that works with general types instead of hard-coding logic for every specific class. In real applications, polymorphism is used in payment systems where different payment methods share one contract, in notification services where email and SMS are handled through one common type, and in enterprise applications where multiple implementations can be swapped without changing business logic.

In Java, the most common form is runtime polymorphism, achieved through method overriding. A parent class or interface defines behavior, and child classes provide their own implementation. Java also supports compile-time polymorphism through method overloading, where multiple methods share the same name but have different parameters. Overloading improves readability, while overriding enables dynamic behavior based on the actual object type. Polymorphism works closely with inheritance and interfaces, and it is a foundation for clean architecture, dependency injection, and maintainable codebases.

For example, if a variable is declared as Animal, it can point to a Dog, Cat, or Bird. When a method like makeSound() is called, Java uses the real object type at runtime to choose the correct implementation. This helps reduce duplication and makes systems easier to extend. Instead of rewriting logic whenever a new type is introduced, you add a new class that follows the same contract.

Step-by-Step Explanation

To use polymorphism, first define a parent class or interface. Second, create child classes that override a shared method. Third, store child objects inside parent-type references. Finally, call the method through the parent reference and let Java decide which version runs.

Method overloading means same method name, different parameters in the same class. Method overriding means same method signature in a child class, replacing inherited behavior. Runtime polymorphism only applies to overridden instance methods, not static methods. A parent reference can access only members declared in the parent type, but overridden methods still execute from the child object.

class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        a1.makeSound();
        a2.makeSound();
    }
}

Comprehensive Code Examples

Basic example: runtime polymorphism with a parent reference.

class Shape {
    void draw() {
        System.out.println("Drawing shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing circle");
    }
}

Real-world example: payment processing using an interface.

interface PaymentMethod {
    void pay(double amount);
}

class CreditCardPayment implements PaymentMethod {
    public void pay(double amount) {
        System.out.println("Paid by credit card: " + amount);
    }
}

class UpiPayment implements PaymentMethod {
    public void pay(double amount) {
        System.out.println("Paid by UPI: " + amount);
    }
}

Advanced usage: polymorphism with collections.

import java.util.*;

interface Notification {
    void send();
}

class EmailNotification implements Notification {
    public void send() {
        System.out.println("Sending email");
    }
}

class SmsNotification implements Notification {
    public void send() {
        System.out.println("Sending SMS");
    }
}

public class Main {
    public static void main(String[] args) {
        List list = Arrays.asList(
            new EmailNotification(),
            new SmsNotification()
        );

        for (Notification n : list) {
            n.send();
        }
    }
}

Common Mistakes

• Confusing overloading with overriding. Fix: remember overriding needs inheritance and the same method signature.

• Forgetting @Override. Fix: always use it so the compiler catches signature errors.

• Expecting child-specific methods from a parent reference. Fix: access only parent-declared members unless safely cast.

• Using static methods as if they were polymorphic. Fix: understand that static methods are resolved by reference type, not object type.

Best Practices

• Program to interfaces, not concrete classes.

• Keep shared behavior in parent types and specialized behavior in child classes.

• Use polymorphism to replace long if-else chains based on type.

• Prefer clear contracts with interfaces for enterprise systems.

• Use meaningful method names and consistent overriding.

Practice Exercises

• Create a Vehicle class with a move() method, then override it in Car and Bike.

• Create an interface Appliance with turnOn(), then implement it in Fan and Light.

• Store three different child objects in a parent-type array and call the same overridden method on each.

Mini Project / Task

Build a simple employee bonus system where an Employee type defines calculateBonus(), and classes like Manager, Developer, and Intern provide different bonus rules.

Challenge (Optional)

Create a ticket booking system with a common Ticket interface and different ticket types such as bus, train, and flight. Add them to a list and process all bookings through one loop using polymorphism.

Anonymous Classes and Lambda Expressions

Anonymous classes and lambda expressions are two important Java features used when you need short, focused behavior without creating a separate named class. They exist to reduce boilerplate and make code easier to read when a class or method implementation is used only once. In real applications, they appear in event handling, background tasks, sorting, filtering collections, stream processing, callbacks, and business rule customization. An anonymous class is an inline class definition that can extend one class or implement one interface at the point of use. It was common before Java 8 for creating quick implementations such as listeners or comparators. Lambda expressions were introduced in Java 8 to provide a more compact syntax for functional interfaces, which are interfaces containing exactly one abstract method. They are widely used in enterprise Java for cleaner APIs, especially with collections, streams, executors, and frameworks that accept behavior as an argument.

Anonymous classes are useful when you need extra state, multiple method overrides from an interface with default methods plus custom members, or a small one-time implementation. Lambda expressions are better when the target is a functional interface and the intent is to express behavior clearly in a concise form. Common functional interfaces include Runnable, Comparator, Callable, Predicate, Function, and Consumer. A lambda can take parameters, optionally declare types, and return a value through either an expression or a block. Unlike anonymous classes, lambdas do not create a new scope for this; inside a lambda, this refers to the enclosing instance. Both features can capture local variables, but those variables must be effectively final, meaning their value is not changed after initialization.

Step-by-Step Explanation

To write an anonymous class, first identify the interface or superclass you want to implement. Then instantiate it and immediately add a class body with overridden methods. Example pattern: Type obj = new Type() { override methods here };. To write a lambda, first ensure the target type is a functional interface. Then replace the implementation with the form (parameters) -> expression or (parameters) -> { statements; }. If there is one parameter, parentheses may be omitted in simple cases. If the body is a single expression, Java returns the value automatically. When a block is used, an explicit return is required for non-void methods.

Use anonymous classes when you need a one-off object with slightly more structure. Use lambdas when you want short behavior passed into methods. In modern Java, lambdas are generally preferred for readability when functional interfaces are involved.

Comprehensive Code Examples

interface Greeting {
    void sayHello();
}

public class Demo {
    public static void main(String[] args) {
        Greeting g1 = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous class");
            }
        };

        Greeting g2 = () -> System.out.println("Hello from lambda");

        g1.sayHello();
        g2.sayHello();
    }
}

import java.util.*;

public class SortExample {
    public static void main(String[] args) {
        List names = Arrays.asList("Riya", "Amit", "Zara", "Dev");

        names.sort((a, b) -> a.compareTo(b));

        names.forEach(name -> System.out.println(name));
    }
}

import java.util.*;
import java.util.function.*;

public class AdvancedExample {
    public static void main(String[] args) {
        List numbers = Arrays.asList(10, 15, 20, 25, 30);

        Predicate isEven = n -> n % 2 == 0;
        Function label = n -> "Value: " + n;
        Consumer print = text -> System.out.println(text);

        numbers.stream()
               .filter(isEven)
               .map(label)
               .forEach(print);
    }
}

Common Mistakes

• Using lambdas with non-functional interfaces: A lambda works only when the interface has one abstract method. Fix: confirm the target is a functional interface.
• Trying to modify captured local variables: Variables used inside anonymous classes or lambdas must be effectively final. Fix: avoid reassigning them after initialization.
• Confusing this behavior: In anonymous classes, this refers to the anonymous object; in lambdas, it refers to the outer instance. Fix: understand scope before accessing members.
• Writing complex lambdas: Large blocks reduce readability. Fix: extract logic into named methods when the body grows.

Best Practices

• Prefer lambdas for short implementations of functional interfaces.
• Use anonymous classes only when you need extra structure or clearer explicit behavior.
• Keep lambda bodies small and intention-revealing.
• Use standard functional interfaces from java.util.function instead of inventing unnecessary custom ones.
• Add @FunctionalInterface to custom functional interfaces for safety and clarity.

Practice Exercises

• Create a functional interface named Calculator with one method. Implement addition using a lambda.
• Write an anonymous class that implements Runnable and prints a message when run.
• Store a list of integers and use a lambda with forEach to print only values greater than 50.

Mini Project / Task

Build a simple employee filter tool that stores employee names and salaries, then uses lambda expressions to print only employees whose salary is above a chosen threshold.

Challenge (Optional)

Create a custom functional interface for text transformation, then chain multiple lambda-based transformations such as trimming, converting to uppercase, and adding a prefix before printing the final result.

Error Handling with Try Catch

Error handling with try and catch is Java's structured way to manage runtime problems without crashing a program unexpectedly.
In real applications, errors can happen for many reasons: invalid user input, missing files, database connection failures, division by zero, or unexpected null values. Instead of letting the application stop abruptly, Java allows developers to anticipate risky code and define how the program should respond.
In Java, code that may throw an exception is placed inside a try block. If an exception occurs, Java looks for a matching catch block to handle it. This is widely used in enterprise software, especially when reading files, processing requests, calling APIs, and validating input from users or external systems.
Java exceptions can be checked or unchecked. Checked exceptions must be handled or declared, such as IOException. Unchecked exceptions happen at runtime, such as ArithmeticException or NullPointerException. A finally block can also be added to run cleanup code whether an error happens or not. This is useful for closing resources or logging final actions.

Step-by-Step Explanation

The basic syntax starts with try, followed by one or more catch blocks, and optionally finally.
1. Put risky code inside try.
2. Add a catch block with the exception type you want to handle.
3. Use the exception object to inspect the message.
4. Optionally add finally for cleanup.
A simple pattern is:
try { risky code } catch (ExceptionType e) { handle error }
You can also have multiple catch blocks to handle different exception types separately. Java chooses the first matching one. More specific exceptions should come before general ones.

Comprehensive Code Examples

Basic example

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero: " + e.getMessage());
        }
    }
}

Real-world example

public class AgeParser {
    public static void main(String[] args) {
        String input = "twenty";
        try {
            int age = Integer.parseInt(input);
            System.out.println("Age: " + age);
        } catch (NumberFormatException e) {
            System.out.println("Invalid age entered. Please use numbers only.");
        }
    }
}

Advanced usage

public class MultiCatchDemo {
    public static void main(String[] args) {
        String text = null;
        try {
            int number = Integer.parseInt(text);
            System.out.println(number);
        } catch (NumberFormatException e) {
            System.out.println("Text is not a valid number.");
        } catch (NullPointerException e) {
            System.out.println("Input text was null.");
        } finally {
            System.out.println("Parsing attempt finished.");
        }
    }
}

Common Mistakes

• Catching very general exceptions too early: Catching Exception first can hide specific issues. Fix: catch specific exception types before broader ones.
• Using try-catch for normal logic: Exceptions are not replacements for validation. Fix: validate input first when possible.
• Ignoring the exception details: An empty catch block makes debugging difficult. Fix: print, log, or handle the message meaningfully.
• Forgetting cleanup: Resources may remain open. Fix: use finally or try-with-resources where appropriate.

Best Practices

• Catch the most specific exception possible.
• Write user-friendly error messages, but keep technical details for logs.
• Use finally for cleanup code that must always run.
• Do not suppress exceptions silently.
• Keep try blocks small so the risky code is easy to identify.
• Use exception handling to recover gracefully, not to hide bad design.

Practice Exercises

• Create a program that divides two integers and handles division by zero using try and catch.
• Write a program that converts a string to an integer and handles invalid numeric input.
• Build a small example with multiple catch blocks for ArithmeticException and NumberFormatException.

Mini Project / Task

Build a console-based input checker that reads a user's age from a string variable, converts it to an integer, and displays a friendly error message if the value is missing or invalid.

Challenge (Optional)

Create a program that processes an array of strings as numbers, handles invalid entries individually with try and catch, and continues processing the remaining values without stopping.

Multiple Catch and Finally

In Java, exception handling allows your program to respond safely when something goes wrong during execution. The try, catch, and finally structure helps prevent sudden crashes and gives developers a controlled way to recover, log errors, or clean up resources. Multiple catch means a single try block can be followed by several catch blocks, each designed for a different exception type. This is useful when one piece of code may fail in different ways, such as invalid user input, missing files, or arithmetic errors. The finally block contains code that runs whether an exception occurs or not, making it ideal for cleanup tasks like closing files, database connections, or scanners.

In real-world applications, these features are essential. For example, a banking application may parse numbers, read files, and connect to services in one workflow. Each operation can fail for different reasons, so multiple catch blocks make error handling specific and readable. A finally block ensures resources are always released, which is critical in enterprise systems where poor cleanup can cause memory leaks or locked files.

The main parts are: try for risky code, one or more catch blocks for handling specific exceptions, and finally for cleanup. When using multiple catch blocks, Java checks them from top to bottom. This means you must place more specific exceptions before more general ones like Exception, otherwise the general one would catch everything first.

Step-by-Step Explanation

The basic syntax is: place risky code inside try. After that, add separate catch blocks for different exception classes. Optionally add a finally block at the end.

Execution flow works like this:
1. Java enters the try block.
2. If no exception happens, all catch blocks are skipped.
3. If an exception happens, Java looks for the first matching catch block.
4. After the matching catch finishes, Java runs finally.
5. If no exception matches, the exception continues upward after finally runs.

This pattern helps beginners write safer programs without mixing error-handling logic into normal business logic.

Comprehensive Code Examples

Basic example

public class BasicCatchDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero.");
        } catch (Exception e) {
            System.out.println("Some other error occurred.");
        } finally {
            System.out.println("Execution finished.");
        }
    }
}

Real-world example

import java.io.FileReader;
import java.io.IOException;

public class FileProcessingDemo {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            reader = new FileReader("data.txt");
            int number = Integer.parseInt("abc");
        } catch (IOException e) {
            System.out.println("File could not be opened.");
        } catch (NumberFormatException e) {
            System.out.println("Text is not a valid number.");
        } finally {
            System.out.println("Closing resources or logging status.");
            try {
                if (reader != null) reader.close();
            } catch (IOException e) {
                System.out.println("Error while closing file.");
            }
        }
    }
}

Advanced usage

public class OrderServiceDemo {
    public static void processOrder(String quantityText, int stock) {
        try {
            int quantity = Integer.parseInt(quantityText);
            int perItemPrice = 100;
            int total = perItemPrice / quantity;

            if (quantity > stock) {
                throw new IllegalArgumentException("Not enough stock.");
            }

            System.out.println("Order processed. Unit ratio: " + total);
        } catch (NumberFormatException e) {
            System.out.println("Quantity must be numeric.");
        } catch (ArithmeticException e) {
            System.out.println("Quantity cannot be zero.");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        } finally {
            System.out.println("Order request completed.");
        }
    }

    public static void main(String[] args) {
        processOrder("0", 10);
    }
}

Common Mistakes

• Placing Exception before specific exceptions: put specific catch blocks first, general ones last.
• Using finally for business logic: keep finally for cleanup, not core processing.
• Ignoring exception details: print or log useful messages instead of empty catch blocks.
• Assuming finally always means success: it runs in both success and failure cases.

Best Practices

• Catch only exceptions you can meaningfully handle.
• Order catch blocks from most specific to most general.
• Use finally for cleanup such as closing streams or releasing resources.
• Write clear error messages that help debugging and users.
• Keep try blocks small so the source of failure is easier to identify.

Practice Exercises

• Create a program that divides two numbers and uses multiple catch blocks for division by zero and invalid number input.
• Write a program that reads a file name from code, handles file errors, and prints a message in finally.
• Build a small parser that converts a string to an integer and handles both invalid input and custom validation errors.

Mini Project / Task

Create a console-based bill calculator that reads item quantity and price, handles invalid numeric input and division issues with multiple catch blocks, and uses a finally block to print a closing status message.

Challenge (Optional)

Design a method that performs three risky operations in one try block, handles each failure with separate catch blocks, and ensures cleanup always happens in finally. Then explain why catch order matters in your solution.

Custom Exceptions

Custom exceptions are user-defined exception classes created to represent specific error conditions in your application. Java already provides many built-in exceptions such as NullPointerException, IllegalArgumentException, and IOException, but enterprise applications often need more meaningful errors tied to business rules. For example, a banking system may need InsufficientFundsException, an e-commerce platform may need OutOfStockException, and a student portal may need InvalidGradeException. Custom exceptions improve readability, debugging, and error handling because they communicate intent clearly. In real projects, they are commonly used in service layers, validation logic, domain models, APIs, and persistence workflows. Java custom exceptions usually extend either Exception for checked exceptions or RuntimeException for unchecked exceptions. Checked exceptions are useful when callers are expected to handle recoverable situations, while unchecked exceptions are often used for programming errors or invalid business state that should not be ignored. Choosing the right type depends on whether the caller can reasonably recover. A good custom exception should have a meaningful name, a clear message, and optional constructors for passing causes so debugging information is preserved.

Step-by-Step Explanation

To create a custom exception, define a class that extends Exception or RuntimeException. By convention, the class name ends with Exception. Add constructors so the exception can accept a message and, when needed, another exception as the cause. Then throw it with the throw keyword when a rule is violated. If it is a checked exception, declare it using throws in the method signature. Finally, catch it where recovery or user-friendly handling should happen. Syntax flow: create class, extend base exception, add constructors, throw in logic, optionally catch and respond. This pattern keeps business rules separate from generic Java errors and makes code easier to maintain.

Comprehensive Code Examples

Basic example

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class Demo {
    static void register(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("User must be at least 18 years old.");
        }
        System.out.println("Registration successful");
    }

    public static void main(String[] args) {
        try {
            register(16);
        } catch (InvalidAgeException e) {
            System.out.println(e.getMessage());
        }
    }
}

Real-world example

class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccount {
    private double balance;

    public BankAccount(double balance) {
        this.balance = balance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Withdrawal denied: insufficient balance.");
        }
        balance -= amount;
    }
}

Advanced usage

class OrderProcessingException extends RuntimeException {
    public OrderProcessingException(String message) {
        super(message);
    }

    public OrderProcessingException(String message, Throwable cause) {
        super(message, cause);
    }
}

class OrderService {
    public void processOrder(String orderId) {
        try {
            simulateDatabaseSave();
        } catch (Exception e) {
            throw new OrderProcessingException("Failed to process order: " + orderId, e);
        }
    }

    private void simulateDatabaseSave() throws Exception {
        throw new Exception("Database connection lost");
    }
}

Common Mistakes

• Using vague names: Names like MyException do not explain the problem. Use specific names such as InvalidPasswordException.
• Forgetting constructors: Without message or cause constructors, debugging becomes harder. Add at least a message constructor.
• Choosing the wrong base type: Extending Exception when callers cannot realistically recover creates unnecessary handling. Use RuntimeException when appropriate.
• Swallowing exceptions: Catching a custom exception and doing nothing hides failures. Log, rethrow, or handle meaningfully.

Best Practices

• Make exception names business-focused so they reflect real domain rules.
• Preserve the original cause when wrapping lower-level exceptions.
• Keep messages clear and actionable for developers and support teams.
• Do not overcreate exceptions for trivial cases; use them where they add clarity.
• Document thrown exceptions in method contracts, especially for checked exceptions.

Practice Exercises

• Create a checked exception named InvalidEmailException and throw it if an email does not contain @.
• Create an unchecked exception named NegativePriceException and use it in a product class.
• Write a method that throws SeatUnavailableException when a requested seat is already booked.

Mini Project / Task

Build a simple library borrowing system where a custom exception named BookUnavailableException is thrown when a user tries to borrow a book with zero available copies.

Challenge (Optional)

Create a small payment module that uses multiple custom exceptions such as InvalidAmountException and PaymentFailedException, and decide which should be checked versus unchecked based on recoverability.

File I/O Reading

File I/O reading in Java means reading data from files stored on disk so a program can use that data while running. It exists because most real applications need to work with information outside the program itself, such as configuration files, logs, reports, CSV datasets, text documents, and imported records. In real life, Java applications read files in banking systems, school management software, web servers, ETL pipelines, and desktop tools. Java provides several ways to read files depending on the file size, format, and level of control you need.

The most common reading approaches include FileReader for character-based text, BufferedReader for efficient line-by-line reading, Scanner for token-based parsing, and the modern Files utility class from java.nio.file for simple and powerful file operations. Byte-based classes such as FileInputStream are used when reading binary data like images or PDFs. For beginners, text file reading is the best starting point because it is easy to understand and commonly used.

Step-by-Step Explanation

To read a file in Java, first import the required classes such as java.io.* or java.nio.file.*. Next, specify the file path. Then create a reader object, read the content, process it, and finally close the resource. A better approach is using try-with-resources, which closes the file automatically. When reading text line by line, BufferedReader is a common choice. It wraps another reader and improves performance. With modern Java, Files.readString(), Files.readAllLines(), and Files.newBufferedReader() are often cleaner.

You should also handle exceptions such as IOException. This protects your program when a file does not exist, the path is wrong, or access is denied. Beginners should remember that relative paths depend on the project working directory, so absolute paths may work differently across machines.

Comprehensive Code Examples

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadBasic {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("notes.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class ReadConfig {
    public static void main(String[] args) {
        try {
            for (String line : Files.readAllLines(Path.of("config.txt"))) {
                if (!line.isBlank()) {
                    System.out.println("Config: " + line);
                }
            }
        } catch (IOException e) {
            System.out.println("Could not load config file.");
        }
    }
}

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.BufferedReader;
import java.io.IOException;

public class ReadAndCount {
    public static void main(String[] args) {
        int count = 0;
        try (BufferedReader reader = Files.newBufferedReader(Path.of("students.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (!line.trim().isEmpty()) {
                    count++;
                }
            }
            System.out.println("Total non-empty lines: " + count);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Common Mistakes

• Forgetting to close the file: Use try-with-resources so Java closes it automatically.
• Using the wrong path: Check whether the file is in the project root or provide the correct absolute or relative path.
• Ignoring exceptions: Always catch or declare IOException to avoid crashes.
• Choosing the wrong class: Use character readers for text and input streams for binary files.

Best Practices

• Prefer BufferedReader or Files.newBufferedReader() for text files.
• Use Path and Files from NIO for modern, readable code.
• Validate file content before processing it.
• Keep file paths configurable instead of hardcoding them.
• Read large files line by line instead of loading everything into memory.

Practice Exercises

• Create a program that reads a text file and prints every line to the console.
• Write a program that counts how many lines are in a file.
• Read a file and print only lines that contain a specific word such as Java.

Mini Project / Task

Build a simple log reader that opens a file named app.log, prints each line, and shows the total number of lines that contain the word ERROR.

Challenge (Optional)

Create a program that reads a CSV-style text file, splits each line by commas, and prints the values in a formatted report while safely skipping empty or invalid rows.

File I/O Writing

File I/O (Input/Output) Writing in Java refers to the process of storing data from a Java program into a persistent storage medium, typically a file on a disk. This is a fundamental capability for almost any application that needs to save user preferences, log events, store configuration settings, export data, or create backups. Without the ability to write to files, applications would be limited to processing data only within their runtime memory, meaning all data would be lost once the program terminates. In real-world scenarios, file writing is crucial for everything from simple text editors saving documents to complex enterprise systems logging transactions, web servers caching data, or scientific applications storing experimental results. It provides a way to make data durable and shareable across different program executions or even different systems.

Java provides a rich set of classes within the java.io package and, more recently, the java.nio.file package (NIO.2) to handle file operations. These classes abstract away the complexities of interacting with the underlying operating system's file system, offering a consistent API for developers. The core concept behind writing to files is streams. A stream is a sequence of data. In the context of writing, an output stream is a destination for bytes or characters. Java offers different types of streams for different purposes:

• Byte Streams (OutputStream and its subclasses): Used for writing raw bytes. Examples include FileOutputStream for writing to a file, and BufferedOutputStream for efficient writing by buffering bytes. These are suitable for binary data like images, audio, or serialized objects.


• Character Streams (Writer and its subclasses): Used for writing characters. Examples include FileWriter for writing characters to a file, and BufferedWriter for efficient writing of characters, often line by line. These are ideal for text data, as they handle character encoding correctly.


• Convenience Classes: Classes like PrintWriter and DataOutputStream provide higher-level functionalities, such as writing formatted text or primitive Java data types directly.

Choosing the right stream depends on whether you're dealing with binary or text data, and whether you need buffering for performance improvements.

Step-by-Step Explanation

Writing to a file in Java typically involves these steps:

1. Choose the appropriate Stream/Writer: Decide if you need a byte stream (e.g., FileOutputStream) for binary data or a character stream (e.g., FileWriter) for text. For character streams, consider wrapping it in a BufferedWriter or PrintWriter for convenience and performance.


2. Create an instance of the Stream/Writer: You'll usually pass the file path or a File object to the constructor. Most constructors for file-based streams/writers have an optional boolean parameter, append. If true, data will be added to the end of the file; if false (default), the file will be truncated (its contents deleted) before writing.


3. Write data: Use the write() methods provided by the stream/writer. These methods can often take a single byte/character, a byte/character array, or a string.


4. Flush the stream (optional but recommended): For buffered streams, flush() forces any buffered data to be written to the underlying storage. While close() typically flushes automatically, explicit flushing can be useful if you want to ensure data is written before closing.


5. Close the stream: This is critical. close() releases system resources associated with the stream and ensures all buffered data is written. Failing to close streams can lead to resource leaks and data corruption. Modern Java often uses try-with-resources to ensure streams are closed automatically.


6. Handle Exceptions: File I/O operations can throw IOExceptions (e.g., if the file cannot be created, permissions issues, disk full). These must be caught or declared to be thrown.

Comprehensive Code Examples

Basic example (Writing a simple string to a file using FileWriter)

import java.io.FileWriter;
import java.io.IOException;

public class BasicFileWriter {
    public static void main(String[] args) {
        String fileName = "my_output.txt";
        String content = "Hello, Java File I/O!\nThis is a basic example.";

        try (FileWriter writer = new FileWriter(fileName)) {
            writer.write(content);
            System.out.println("Successfully wrote to " + fileName);
        } catch (IOException e) {
            System.err.println("An error occurred while writing to the file: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Real-world example (Logging application messages to a file with appending and buffering)

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class AppLogger {
    private static final String LOG_FILE = "application.log";
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static void log(String message) {
        String timestamp = LocalDateTime.now().format(formatter);
        String logEntry = String.format("[%s] %s%n", timestamp, message);

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(LOG_FILE, true))) { // 'true' for append mode
            writer.write(logEntry);
            System.out.println("Logged: " + message);
        } catch (IOException e) {
            System.err.println("Failed to write to log file: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        log("Application started.");
        log("Processing user request ID: 12345");
        log("Data saved successfully.");
        log("Application shutting down.");
    }
}

Advanced usage (Writing byte data and using PrintWriter for formatted output)

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Base64;

public class AdvancedFileWriter {

    public static void main(String[] args) {
        String textFile = "report.txt";
        String binaryFile = "data.bin";

        // Example 1: Using PrintWriter for formatted text output
        try (PrintWriter writer = new PrintWriter(textFile)) {
            writer.println("--- Sales Report ---");
            writer.printf("Product: %s, Quantity: %d, Price: %.2f%n", "Laptop", 10, 1200.50);
            writer.printf("Product: %s, Quantity: %d, Price: %.2f%n", "Mouse", 50, 25.99);
            writer.println("--------------------");
            System.out.println("Successfully wrote formatted text to " + textFile);
        } catch (IOException e) {
            System.err.println("Error writing to text file: " + e.getMessage());
        }

        // Example 2: Writing raw bytes (e.g., simulating binary data)
        String base64EncodedData = "SGVsbG8gQmluYXJ5IERhdGEh"; // "Hello Binary Data!" base64 encoded
        byte[] dataBytes = Base64.getDecoder().decode(base64EncodedData);

        try (FileOutputStream fos = new FileOutputStream(binaryFile)) {
            fos.write(dataBytes);
            System.out.println("Successfully wrote binary data to " + binaryFile);
        } catch (IOException e) {
            System.err.println("Error writing to binary file: " + e.getMessage());
        }
    }
}

Common Mistakes

• Not closing streams: This is the most common and serious mistake. It leads to resource leaks, potential data loss (buffered data might not be written), and file locking issues. Always use try-with-resources or ensure close() is called in a finally block.


• Incorrectly handling append mode: Forgetting the true argument in FileWriter(fileName, true) will overwrite the file each time, leading to data loss. Conversely, always appending when you intend to create a new file can lead to bloated files.


• Ignoring IOExceptions: Simply catching IOException and doing nothing can mask critical issues like disk full errors or permission problems, leading to silent failures. Always log or handle exceptions appropriately.


• Not using buffering for performance: Directly using FileWriter or FileOutputStream for frequent small writes can be very slow due to numerous system calls. Wrapping them in BufferedWriter or BufferedOutputStream significantly improves performance.

Best Practices

• Always use try-with-resources: This ensures that streams and writers are automatically closed, even if exceptions occur. It's the most robust and idiomatic way to handle resources in Java I/O.


• Use character streams for text, byte streams for binary: This ensures correct handling of character encodings for text and avoids corruption of binary data.


• Buffer streams for performance: Always wrap FileWriter/FileReader with BufferedWriter/BufferedReader, and FileOutputStream/FileInputStream with BufferedOutputStream/BufferedInputStream, especially for large files or frequent I/O operations.


• Specify character encoding: When dealing with text files, explicitly specify the character encoding (e.g., UTF-8) in the FileWriter or OutputStreamWriter constructor to avoid platform-dependent default encodings causing issues.


• Handle exceptions gracefully: Provide meaningful error messages to the user or log them for debugging. Consider strategies for recovery or graceful degradation.


• Use java.nio.file for modern file operations: For more complex file system interactions (e.g., creating directories, moving files, atomic operations), the java.nio.file package (NIO.2) offers a more powerful and flexible API.

Practice Exercises

1. Simple Greeting File: Write a Java program that prompts the user for their name and then writes a greeting message like "Hello, [Name]! Welcome to the Java world." into a file named greeting.txt. Overwrite the file if it already exists.


2. Number List: Create a program that writes the numbers from 1 to 100, each on a new line, into a file called numbers.txt.


3. Append Log Entry: Modify the previous program to append a new entry "Program executed at [current timestamp]" to an existing file named execution_log.txt without overwriting its previous contents.

Mini Project / Task

Develop a simple Java application that simulates a basic to-do list manager. The application should allow users to add new tasks. Each task should be stored on a new line in a file named todo.txt. When the application starts, it should load existing tasks (if any) and then allow the user to add a new task, which is then immediately appended to the file. For simplicity, do not implement task deletion or marking as complete.

Challenge (Optional)

Enhance the to-do list manager from the mini-project. Instead of just appending tasks, modify it to manage tasks more robustly. When a new task is added, ensure that the file is read, the new task is added to a list in memory, and then the ENTIRE updated list of tasks is rewritten back to the todo.txt file. This simulates how some applications handle data updates where the whole file might be rewritten. Consider what happens if the application crashes during the rewrite process – how could you make it more resilient (e.g., by writing to a temporary file first)?

Generics Basics

Java Generics, introduced in Java 5, provide a way to create classes, interfaces, and methods that operate on types specified as parameters. Think of it like a blueprint for a house: you can design a house (the generic type) and then specify what materials to use (the actual type parameter) when you build it. The primary motivation behind generics is to enable type-safe collections and reduce the need for explicit type casting, which can lead to runtime errors. Before generics, collections like ArrayList stored objects of type Object. This meant that when you retrieved an element, you had to cast it back to its original type. If you accidentally added an incompatible type to the collection, you wouldn't know until runtime when the cast failed, resulting in a ClassCastException. Generics solve this by enforcing type checking at compile time.

In real-world applications, generics are ubiquitous. They are fundamental to the Java Collections Framework (List, Set, Map), ensuring that collections hold only the specified type of objects. They are also used extensively in frameworks like Spring and Hibernate for type-safe dependency injection and data access objects (DAOs). For instance, a generic repository interface might handle CRUD operations for any entity type, providing a flexible and type-safe solution without duplicating code for each entity. Beyond collections, generics are vital for developing reusable algorithms and data structures that can work with various data types while maintaining compile-time type safety.

Generics come in several forms: generic classes, generic interfaces, and generic methods. A generic class is a class that is parameterized over types. For example, Box where T is a type parameter. A generic interface is similar, allowing an interface to be defined with type parameters. A generic method is a method that introduces its own type parameters, independent of the class it is defined in. This allows you to write a single method that can operate on different types of data. Bounded type parameters are another critical concept, allowing you to restrict the types that can be used as type arguments. This is achieved using the extends keyword (e.g., ), which means T can be any class that extends Number or Number itself. Wildcards (?) are also used with generics to provide more flexibility. ? extends T represents an unknown type that is a subtype of T (upper bounded wildcard), while ? super T represents an unknown type that is a supertype of T (lower bounded wildcard). These wildcards are crucial for designing flexible APIs that can accept a range of related types.

Step-by-Step Explanation

The basic syntax for defining a generic class involves placing the type parameter in angle brackets (<>) after the class name. For example, class MyClass { /* ... */ }. Here, T is a placeholder for the actual type that will be provided when an object of MyClass is created. When instantiating a generic class, you specify the actual type argument: MyClass myStringObject = new MyClass();. Since Java 7, you can use the diamond operator (<>) for type inference: MyClass myStringObject = new MyClass<>();.

For generic methods, the type parameter is declared before the return type: public void myGenericMethod(T arg) { /* ... */ }. This method can then be called with any type, and Java's compiler will infer the type parameter. Bounded type parameters are specified using extends for upper bounds (>) and super for lower bounds with wildcards (List).

Comprehensive Code Examples

Basic example

// Generic Box class
class Box {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public static void main(String[] args) {
        // Box for Integer
        Box integerBox = new Box<>();
        integerBox.setItem(10);
        System.out.println("Integer in box: " + integerBox.getItem());

        // Box for String
        Box stringBox = new Box<>();
        stringBox.setItem("Hello Generics!");
        System.out.println("String in box: " + stringBox.getItem());
    }
}

Real-world example

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

// Generic Repository Interface
interface Repository {
    void save(T entity);
    T findById(ID id);
    List findAll();
    void delete(ID id);
}

// Example Entity
class User {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() { return id; }
    public String getName() { return name; }

    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "'}";
    }
}

// Concrete implementation for User
class UserRepository implements Repository {
    private List users = new ArrayList<>();
    private Long nextId = 1L;

    @Override
    public void save(User entity) {
        if (entity.getId() == null) {
            entity = new User(nextId++, entity.getName()); // Assign new ID
        }
        users.add(entity);
        System.out.println("Saved: " + entity);
    }

    @Override
    public User findById(Long id) {
        return users.stream()
                     .filter(user -> user.getId().equals(id))
                     .findFirst()
                     .orElse(null);
    }

    @Override
    public List findAll() {
        return new ArrayList<>(users);
    }

    @Override
    public void delete(Long id) {
        users.removeIf(user -> user.getId().equals(id));
        System.out.println("Deleted user with ID: " + id);
    }

    public static void main(String[] args) {
        UserRepository userRepository = new UserRepository();

        userRepository.save(new User(null, "Alice"));
        userRepository.save(new User(null, "Bob"));

        User foundUser = userRepository.findById(1L);
        System.out.println("Found User: " + foundUser);

        List allUsers = userRepository.findAll();
        System.out.println("All Users: " + allUsers);

        userRepository.delete(2L);
        System.out.println("All Users after delete: " + userRepository.findAll());
    }
}

Advanced usage

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

class Util {
    // Generic method with bounded type parameter
    // > ensures T can be compared
    public static > T findMax(T x, T y) {
        return x.compareTo(y) > 0 ? x : y;
    }

    // Wildcard example: Upper Bounded Wildcard
    // Accepts List of Number or any of its subtypes (Integer, Double, etc.)
    public static double sumOfList(List list) {
        double sum = 0.0;
        for (Number n : list) {
            sum += n.doubleValue();
        }
        return sum;
    }

    // Wildcard example: Lower Bounded Wildcard
    // Accepts List of Integer or any of its supertypes (Number, Object)
    public static void addIntegers(List list) {
        for (int i = 1; i <= 5; i++) {
            list.add(i); // Can add Integer or its subtypes
        }
    }

    public static void main(String[] args) {
        // findMax usage
        System.out.println("Max of 5 and 7: " + Util.findMax(5, 7));
        System.out.println("Max of 'apple' and 'orange': " + Util.findMax("apple", "orange"));

        // sumOfList usage
        List integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        System.out.println("Sum of integerList: " + sumOfList(integerList));

        List doubleList = new ArrayList<>();
        doubleList.add(1.5);
        doubleList.add(2.5);
        System.out.println("Sum of doubleList: " + sumOfList(doubleList));

        // addIntegers usage
        List numberList = new ArrayList<>();
        addIntegers(numberList);
        System.out.println("Number List after addIntegers: " + numberList);

        List

HashMaps and Sets

Core Concepts & Sub-types

• HashMap: Stores key-value pairs. Keys must be unique, and each key maps to exactly one value. Values can be duplicated. It allows one null key and multiple null values. The order of elements is not guaranteed.
• HashSet: Stores unique elements. It is essentially a HashMap where the values are dummy objects (a constant PRESENT object). It ensures that no duplicate elements are stored. Like HashMap, it doesn't guarantee order and allows one null element.

• LinkedHashMap/LinkedHashSet: Maintain insertion order. Useful when you need predictable iteration order.
• TreeMap/TreeSet: Store elements in a sorted order (natural order or by a custom comparator). These are based on Red-Black trees and offer O(log n) performance for operations.

Step-by-Step Explanation

Comprehensive Code Examples

import java.util.HashMap;

public class BasicHashMapExample {
    public static void main(String[] args) {
        HashMap studentScores = new HashMap<>();

        // Add elements
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        studentScores.put("Charlie", 92);
        studentScores.put("Alice", 97); // Updates Alice's score

        System.out.println("Student Scores: " + studentScores);

        // Get a score
        int bobScore = studentScores.get("Bob");
        System.out.println("Bob's Score: " + bobScore);

        // Check if a student exists
        System.out.println("Contains Charlie? " + studentScores.containsKey("Charlie"));

        // Remove a student
        studentScores.remove("Bob");
        System.out.println("After removing Bob: " + studentScores);
    }
}

import java.util.HashMap;
import java.util.Map;

public class InventoryManager {
    private HashMap inventory;

    public InventoryManager() {
        this.inventory = new HashMap<>();
    }

    public void addProduct(String productName, int quantity) {
        inventory.put(productName, inventory.getOrDefault(productName, 0) + quantity);
        System.out.println("Added " + quantity + " of " + productName + ". Current stock: " + inventory.get(productName));
    }

    public boolean sellProduct(String productName, int quantity) {
        if (inventory.containsKey(productName) && inventory.get(productName) >= quantity) {
            inventory.put(productName, inventory.get(productName) - quantity);
            System.out.println("Sold " + quantity + " of " + productName + ". Remaining stock: " + inventory.get(productName));
            return true;
        } else {
            System.out.println("Not enough stock for " + productName + ". Available: " + inventory.getOrDefault(productName, 0));
            return false;
        }
    }

    public void displayInventory() {
        System.out.println("\nCurrent Inventory:");
        for (Map.Entry entry : inventory.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static void main(String[] args) {
        InventoryManager manager = new InventoryManager();
        manager.addProduct("Laptop", 10);
        manager.addProduct("Mouse", 50);
        manager.addProduct("Laptop", 5); // Add more laptops
        manager.displayInventory();

        manager.sellProduct("Laptop", 7);
        manager.sellProduct("Keyboard", 3); // Product not in stock
        manager.sellProduct("Mouse", 60); // Not enough stock
        manager.displayInventory();
    }
}

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class UniqueElementsExample {
    public static void main(String[] args) {
        List words = Arrays.asList("apple", "banana", "orange", "apple", "grape", "banana");
        System.out.println("Original list: " + words);

        // Use HashSet to get unique words
        Set uniqueWords = new HashSet<>(words);
        System.out.println("Unique words: " + uniqueWords);

        // Check for presence
        System.out.println("Contains 'orange'? " + uniqueWords.contains("orange"));
        System.out.println("Contains 'kiwi'? " + uniqueWords.contains("kiwi"));

        // Set operations (union and intersection)
        Set set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
        Set set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));

        Set union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("Union of set1 and set2: " + union); // [1, 2, 3, 4, 5, 6, 7, 8]

        Set intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println("Intersection of set1 and set2: " + intersection); // [4, 5]
    }
}

Common Mistakes

• Forgetting hashCode() and equals(): When using custom objects as keys in a HashMap or elements in a HashSet, failing to override hashCode() and equals() correctly will lead to incorrect behavior. Objects that are logically equal might be stored as separate entries or not found when retrieved, because their default hashCode() and equals() implementations (from Object) are based on memory addresses.
  Fix: Always override both hashCode() and equals() methods in pairs, ensuring that if two objects are equal according to equals(), they must have the same hashCode(). IDEs can often auto-generate these for you.
• Modifying keys used in a HashMap: If you change the state of an object that is being used as a key in a HashMap after it has been inserted, its hashCode() might change. This can make the key unretrievable, as the HashMap will look for it in the bucket corresponding to its original hash code.
  Fix: Use immutable objects as keys whenever possible. If mutable objects must be used, ensure their state relevant to hashCode() and equals() does not change while they are keys in the map.
• Assuming order: Both HashMap and HashSet do not guarantee any specific order of elements. Relying on insertion order or any other order will lead to non-deterministic behavior.
  Fix: If order is important, use LinkedHashMap or LinkedHashSet for insertion order, or TreeMap or TreeSet for sorted order.

Best Practices

• Override hashCode() and equals() correctly: This is paramount for custom objects used in hash-based collections. Use your IDE's auto-generation features and review the generated code carefully.
• Choose the right collection: Don't just default to HashMap/HashSet. If order is important, consider LinkedHashMap/LinkedHashSet or TreeMap/TreeSet. If you need thread-safety, use ConcurrentHashMap or synchronized wrappers.
• Initial Capacity: For HashMaps and HashSets, providing an appropriate initial capacity can improve performance by reducing the number of rehashes. If you know roughly how many elements you'll store, initialize with new HashMap<>(expectedSize) or new HashSet<>(expectedSize).
• Load Factor: Be aware of the load factor (default 0.75). When the number of entries exceeds capacity * loadFactor, the map/set is rehashed (its internal array is resized), which can be an expensive operation.
• Use getOrDefault(): When retrieving values from a HashMap, getOrDefault(key, defaultValue) is often cleaner and safer than checking for null after get(key).

Practice Exercises

Mini Project / Task

Challenge (Optional)

Introduction to Streams API

The Java Streams API, introduced in Java 8, provides a modern way to process groups of data such as lists, sets, and arrays. Instead of writing manual loops to filter, transform, sort, and aggregate data, developers can build a stream pipeline that describes what should happen rather than how to do it step by step.

Streams exist to make collection processing more expressive, concise, and easier to maintain. In real applications, they are used for tasks like filtering active users, converting entities into DTOs, calculating totals in invoices, grouping records for reports, and extracting values from API responses. A stream does not store data itself; it works on data from a source such as a List and applies operations in sequence.

Key ideas include intermediate operations such as filter, map, and sorted, and terminal operations such as collect, forEach, count, and reduce. Intermediate operations build the pipeline, while a terminal operation triggers execution. Streams can also be sequential or parallel, although beginners should master sequential streams first.

Step-by-Step Explanation

To use a stream, start with a collection like List. Call stream() on it, then chain operations.

1. Source: the collection or array that provides data.
2. Intermediate operations: these transform or filter elements. They are lazy, meaning they do not run immediately.
3. Terminal operation: this ends the pipeline and produces a result.

Common operations:
filter keeps matching elements.
map converts each element to another form.
sorted orders elements.
distinct removes duplicates.
collect gathers results into a list or other structure.
reduce combines elements into one value.

Comprehensive Code Examples

import java.util.List;
import java.util.stream.Collectors;

public class BasicStreamExample {
    public static void main(String[] args) {
        List names = List.of("Alice", "Bob", "Anita", "David");

        List result = names.stream()
                .filter(name -> name.startsWith("A"))
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

import java.util.List;
import java.util.stream.Collectors;

class Employee {
    String name;
    double salary;
    boolean active;

    Employee(String name, double salary, boolean active) {
        this.name = name;
        this.salary = salary;
        this.active = active;
    }

    public String getName() { return name; }
    public double getSalary() { return salary; }
    public boolean isActive() { return active; }
}

public class RealWorldStreamExample {
    public static void main(String[] args) {
        List employees = List.of(
                new Employee("Asha", 70000, true),
                new Employee("Ravi", 50000, false),
                new Employee("Neha", 90000, true)
        );

        List activeEmployeeNames = employees.stream()
                .filter(Employee::isActive)
                .filter(e -> e.getSalary() > 60000)
                .map(Employee::getName)
                .collect(Collectors.toList());

        System.out.println(activeEmployeeNames);
    }
}

import java.util.List;

public class AdvancedStreamExample {
    public static void main(String[] args) {
        List numbers = List.of(5, 10, 15, 20);

        int total = numbers.stream()
                .map(n -> n * 2)
                .reduce(0, Integer::sum);

        long count = numbers.stream()
                .filter(n -> n > 10)
                .count();

        System.out.println("Total: " + total);
        System.out.println("Count: " + count);
    }
}

Common Mistakes

• Forgetting a terminal operation: a stream pipeline will not run without collect, count, forEach, or another terminal method.
• Trying to reuse a stream: once consumed, a stream cannot be used again. Create a new stream from the source.
• Using streams for very simple logic: a plain loop may be clearer for short, stateful tasks.
• Modifying external variables inside lambdas: this can make code harder to understand and may cause issues.

Best Practices

• Keep stream pipelines readable and short.
• Use method references like Employee::getName when they improve clarity.
• Prefer immutable results when possible.
• Use streams for transformation and querying, not for complex side effects.
• Learn common collectors such as toList(), groupingBy(), and joining() as you progress.

Practice Exercises

• Create a list of integers and use a stream to return only even numbers.
• Create a list of names and convert all names to uppercase using map.
• Create a list of prices and use reduce to calculate the total sum.

Mini Project / Task

Build a small program that takes a list of product names and prices, filters products above a chosen price, converts the names to uppercase, and prints the final list.

Challenge (Optional)

Create a program that reads a list of words, removes duplicates, sorts them by length, and collects the result into a new list.

Multithreading Basics

Step-by-Step Explanation

Comprehensive Code Examples

class MyRunnable implements Runnable {
    private String threadName;

    public MyRunnable(String name) {
        this.threadName = name;
        System.out.println("Creating " +  threadName );
    }

    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // Let the thread sleep for a while.
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
}

public class BasicMultithreading {
    public static void main(String args[]) {
        MyRunnable runnable1 = new MyRunnable( "Thread-1");
        Thread thread1 = new Thread(runnable1);
        thread1.start();

        MyRunnable runnable2 = new MyRunnable( "Thread-2");
        Thread thread2 = new Thread(runnable2);
        thread2.start();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

class FileProcessor implements Runnable {
    private String filePath;

    public FileProcessor(String filePath) {
        this.filePath = filePath;
    }

    @Override
    public void run() {
        System.out.println("Processing file: " + filePath + " by thread: " + Thread.currentThread().getName());
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            int lineCount = 0;
            while ((line = reader.readLine()) != null) {
                // Simulate some work, e.g., parsing or counting
                lineCount++;
                // System.out.println("Read line: " + line); // Uncomment for detailed output
            }
            System.out.println("Finished processing " + filePath + ". Total lines: " + lineCount);
        } catch (IOException e) {
            System.err.println("Error processing file " + filePath + ": " + e.getMessage());
        }
    }
}

public class ConcurrentFileProcessing {
    public static void main(String[] args) {
        // Create dummy files for demonstration
        createDummyFile("file1.txt", 100);
        createDummyFile("file2.txt", 150);
        createDummyFile("file3.txt", 200);

        Thread t1 = new Thread(new FileProcessor("file1.txt"), "Processor-1");
        Thread t2 = new Thread(new FileProcessor("file2.txt"), "Processor-2");
        Thread t3 = new Thread(new FileProcessor("file3.txt"), "Processor-3");

        t1.start();
        t2.start();
        t3.start();

        System.out.println("Main thread continues its work...");
    }

    private static void createDummyFile(String fileName, int numLines) {
        try (java.io.FileWriter writer = new java.io.FileWriter(fileName)) {
            for (int i = 0; i < numLines; i++) {
                writer.write("Line " + (i + 1) + " for " + fileName + "\n");
            }
        } catch (IOException e) {
            System.err.println("Error creating dummy file: " + e.getMessage());
        }
    }
}

public class AdvancedMultithreading {
    public static void main(String[] args) {
        // Using an anonymous Runnable class
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 (Anonymous) is running.");
            }
        });

        // Using a lambda expression (Java 8+) for a simpler Runnable
        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 (Lambda) is running.");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread 2 was interrupted.");
            }
            System.out.println("Thread 2 (Lambda) finished.");
        });

        thread1.start();
        thread2.start();

        // Waiting for thread2 to complete before main thread continues fully
        try {
            thread2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("Main thread was interrupted while waiting.");
        }
        System.out.println("Main thread finished all operations.");
    }
}

Common Mistakes

Synchronization and Threads

Step-by-Step Explanation

• synchronized keyword: This is the most fundamental synchronization construct. It can be applied to methods or blocks of code. When a thread invokes a synchronized method or enters a synchronized block, it automatically acquires a lock associated with the object (for instance methods/blocks) or the class (for static methods/blocks). Only one thread can hold the lock at a time, preventing other threads from entering synchronized code protected by the same lock until the first thread releases it.
• wait(), notify(), notifyAll(): These methods are defined in the Object class and are used for inter-thread communication. A thread can call wait() to temporarily release a lock and go into a waiting state until another thread calls notify() or notifyAll() on the same object. This is crucial for producer-consumer scenarios.
• java.util.concurrent package: This package introduced in Java 5 provides a rich set of concurrency utilities, including Locks (ReentrantLock), Executors (ExecutorService, ThreadPoolExecutor), Concurrent Collections (ConcurrentHashMap, CopyOnWriteArrayList), and Semaphores. These high-level constructs often offer more flexibility and better performance than intrinsic locks (synchronized).

Comprehensive Code Examples

Basic example: Creating and starting threads

class MyRunnable implements Runnable {
    private String threadName;

    public MyRunnable(String name) {
        this.threadName = name;
        System.out.println("Creating " + threadName);
    }

    @Override
    public void run() {
        System.out.println("Running " + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread " + threadName + " interrupted.");
        }
        System.out.println("Thread " + threadName + " exiting.");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyRunnable runnable1 = new MyRunnable("Thread-1");
        Thread thread1 = new Thread(runnable1);
        thread1.start();

        MyRunnable runnable2 = new MyRunnable("Thread-2");
        Thread thread2 = new Thread(runnable2);
        thread2.start();
    }
}

Real-world example: Shared Counter with Synchronization

class SharedCounter {
    private int count = 0;

    // Synchronized method to increment the counter
    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " incremented to: " + count);
    }

    public int getCount() {
        return count;
    }
}

class CounterThread implements Runnable {
    private SharedCounter counter;

    public CounterThread(SharedCounter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            counter.increment();
            try {
                Thread.sleep(10); // Simulate some work
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class SynchronizedCounterDemo {
    public static void main(String[] args) throws InterruptedException {
        SharedCounter counter = new SharedCounter();

        Thread t1 = new Thread(new CounterThread(counter), "Thread-A");
        Thread t2 = new Thread(new CounterThread(counter), "Thread-B");

        t1.start();
        t2.start();

        t1.join(); // Wait for t1 to finish
        t2.join(); // Wait for t2 to finish

        System.out.println("Final count: " + counter.getCount()); // Should be 10
    }
}

Advanced usage: Producer-Consumer with wait() and notify()

import java.util.LinkedList;
import java.util.Queue;

class Buffer {
    private Queue list;
    private int capacity;

    public Buffer(int capacity) {
        this.capacity = capacity;
        this.list = new LinkedList<>();
    }

    public void produce(int item) throws InterruptedException {
        synchronized (this) {
            while (list.size() == capacity) {
                System.out.println("Buffer is full. Producer waiting...");
                wait(); // Wait if buffer is full
            }
            list.add(item);
            System.out.println("Produced: " + item + ". Buffer size: " + list.size());
            notifyAll(); // Notify consumers that an item is available
        }
    }

    public int consume() throws InterruptedException {
        synchronized (this) {
            while (list.isEmpty()) {
                System.out.println("Buffer is empty. Consumer waiting...");
                wait(); // Wait if buffer is empty
            }
            int item = list.remove();
            System.out.println("Consumed: " + item + ". Buffer size: " + list.size());
            notifyAll(); // Notify producers that space is available
            return item;
        }
    }
}

class Producer implements Runnable {
    private Buffer buffer;

    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                buffer.produce(i);
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

class Consumer implements Runnable {
    private Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                buffer.consume();
                Thread.sleep(150);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Buffer buffer = new Buffer(5);

        Thread producerThread = new Thread(new Producer(buffer), "Producer");
        Thread consumerThread = new Thread(new Consumer(buffer), "Consumer");

        producerThread.start();
        consumerThread.start();
    }
}

Common Mistakes

• Forgetting to synchronize: The most common mistake leading to race conditions and data corruption. Always identify shared mutable resources and protect them. Fix: Use synchronized blocks/methods or java.util.concurrent.locks.
• Deadlock: Occurs when two or more threads are blocked indefinitely, each waiting for the other to release a resource. This often happens with nested synchronized blocks acquiring locks in different orders. Fix: Ensure a consistent locking order across threads, use timeout mechanisms, or leverage higher-level concurrency constructs.
• Calling wait(), notify(), notifyAll() outside of a synchronized block: These methods must be called on an object for which the current thread holds the monitor (lock). Calling them without holding the lock will result in an IllegalMonitorStateException. Fix: Always wrap calls to these methods within a synchronized block on the object whose monitor is being used.

Best Practices

• Minimize synchronized blocks: Keep synchronized blocks as small as possible to reduce contention and improve concurrency. Only synchronize the critical section that modifies shared state.
• Prefer java.util.concurrent utilities: For complex scenarios, the classes in java.util.concurrent (e.g., ReentrantLock, Semaphore, ExecutorService, concurrent collections) often provide more flexibility, better performance, and higher-level abstractions than raw synchronized keyword and wait()/notify().
• Avoid nested locks: If you must acquire multiple locks, always acquire them in the same order across all threads to prevent deadlocks.
• Use volatile for simple visibility: For variables where only visibility (ensuring writes by one thread are visible to others) is required, but not atomicity (compound operations), volatile can be a lighter alternative to synchronized.
• Document thread-safety: Clearly state whether a class is thread-safe and, if so, how it achieves thread-safety, especially when designing APIs.

Practice Exercises

• Beginner-friendly: Create two threads. Each thread should print numbers from 1 to 5, but one thread prints even numbers and the other prints odd numbers. Ensure the output is interleaved but each thread completes its sequence.
• Shared Resource: Design a simple shared bank account class with methods deposit(amount) and withdraw(amount). Create multiple threads that concurrently try to deposit and withdraw money. Ensure the final balance is correct and no negative balance occurs due to race conditions.
• Thread Pool Concept: Simulate a simple task queue. Create a main thread that adds 10 simple tasks (e.g., printing a message) to a shared queue. Create 3 worker threads that continuously pull tasks from the queue and execute them.

Mini Project / Task

Challenge (Optional)

Maven and Dependency Management

Step-by-Step Explanation

# Create a new project using the quickstart archetype
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

# Navigate into the project directory
cd my-app

# Compile the project
mvn compile

# Run the tests
mvn test

# Package the project into a JAR
mvn package

# Run the packaged application (after packaging)
java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0
    com.mycompany.app
    my-app
    1.0-SNAPSHOT

    
        UTF-8
        11
        11
    

    
        
        
            org.junit.jupiter
            junit-jupiter-api
            5.10.0
            test
        
        
            org.junit.jupiter
            junit-jupiter-engine
            5.10.0
            test
        

        
        
            org.slf4j
            slf4j-api
            2.0.9
        
        
        
            ch.qos.logback
            logback-classic
            1.4.11
            runtime 
        
    

    
        
            
                org.apache.maven.plugins
                maven-surefire-plugin
                3.2.2
            
            
                org.apache.maven.plugins
                maven-compiler-plugin
                3.11.0
                
                    11
                    11
                
            
            
                org.apache.maven.plugins
                maven-jar-plugin
                3.3.0
                
                    
                        
                            true
                            com.mycompany.app.App
                        
                    
                
            
        
    

package com.mycompany.app;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App {
    private static final Logger logger = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        logger.info("Application started.");
        System.out.println("Hello World!");
        logger.debug("Hello World message printed to console.");
        logger.error("An example error message.");
        logger.info("Application finished.");
    }
}

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0

    com.mycompany.app
    my-app
    1.0-SNAPSHOT

    
        UTF-8
        11
        11
        5.10.0
        2.0.9
        1.4.11
    

    
        
            org.junit.jupiter
            junit-jupiter-api
            ${junit.version}
            test
        
        
            org.slf4j
            slf4j-api
            ${slf4j.version}
        
        
            ch.qos.logback
            logback-classic
            ${logback.version}
            runtime
        
    

    
         
            
                
                    org.apache.maven.plugins
                    maven-compiler-plugin
                    3.11.0
                
                
                    org.apache.maven.plugins
                    maven-surefire-plugin
                    3.2.2
                
            
        
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                
                    ${maven.compiler.source}
                    ${maven.compiler.target}
                
            
        
    

    
        
            dev
            
                development
            
            
                
                    
                        org.codehaus.mojo
                        exec-maven-plugin
                        3.1.0
                        
                            
                                
                                    java
                                
                            
                        
                        
                            com.mycompany.app.App
                            
                                --env=dev
                            
                        
                    
                
            
        
        
            prod
            
                production
            
            
                
                    
                        org.apache.maven.plugins
                        maven-jar-plugin
                        
                            
                                
                                    true
                                    com.mycompany.app.App
                                    
                                        ${build.env}