Learn the core concepts of Java programming from scratch.

Java Fundamental

Java is one of the most popular and widely-used programming languages in the world. Created by James Gosling at Sun Microsystems in 1995, Java was designed with the philosophy of **"Write Once, Run Anywhere" (WORA)** — meaning compiled Java code can run on any platform that supports the Java Virtual Machine (JVM).

## Why Learn Java?

*   **Platform Independent** — Java code compiles to bytecode that runs on any OS via the JVM.
*   **Object-Oriented** — Everything in Java revolves around objects and classes, making code modular and reusable.
*   **Strongly Typed** — Java enforces strict type checking at compile time, catching errors early.
*   **Massive Ecosystem** — From Android development to enterprise backends, Java powers some of the world's largest systems.
*   **Career Demand** — Java consistently ranks among the top languages employers look for.

## What Can You Build With Java?

*   Android mobile applications
*   Enterprise web applications (Spring Boot, Jakarta EE)
*   Microservices and distributed systems
*   Big data processing (Hadoop, Apache Spark)
*   Desktop applications
*   Game development

## How Java Works

```
Source Code (.java) → Compiler (javac) → Bytecode (.class) → JVM → Machine Code
```

Unlike languages that compile directly to machine code, Java takes an intermediate step. The Java compiler (`javac`) converts your source code into **bytecode**, which is then interpreted or JIT-compiled by the **Java Virtual Machine (JVM)** at runtime.

## JDK, JRE, and JVM

*   **JDK (Java Development Kit)** — The full development toolkit: compiler, debugger, and libraries.
*   **JRE (Java Runtime Environment)** — The runtime needed to execute Java programs.
*   **JVM (Java Virtual Machine)** — The engine that runs Java bytecode on your machine.

In this course, we'll start from the basics and build up a strong foundation in Java programming.


Chapter 0 : Intro

Introduction to Java

Every Java program starts with a **class** and a **main method**. Let's write the classic "Hello, World!" program.

## Your First Java Program

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

**Output:**

```
Hello, World!
```

## Breaking It Down

| Part                                     | Meaning                                                                                          |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `public class HelloWorld`                | Declares a public class named `HelloWorld`. The filename must match: `HelloWorld.java`           |
| `public static void main(String[] args)` | The entry point of every Java program. The JVM looks for this exact signature to start execution |
| `System.out.println(...)`                | Prints text to the console followed by a newline                                                 |

## Key Rules

1.  **Every Java file must have a class** — and the filename must match the public class name.
2.  **The `main` method is required** — it's where your program begins.
3.  **Statements end with a semicolon** `;`.
4.  **Java is case-sensitive** — `System` is not the same as `system`.

## `print` vs `println`

```java
System.out.print("Hello ");    // no newline
System.out.print("World!");    // continues on same line

System.out.println("Hello");   // adds a newline
System.out.println("World!");  // prints on next line
```

**Output:**

```
Hello World!
Hello
World!
```

## Running Your Program

```bash
javac HelloWorld.java    # compile
java HelloWorld          # run
```

The compiler (`javac`) creates a `HelloWorld.class` bytecode file, which the JVM (`java`) then executes.


Chapter 1 : Basics

Hello World

Variables are containers for storing data values. In Java, every variable must have a **declared type**.

## Declaring Variables

```java
// syntax: type variableName = value;
int age = 25;
String name = "Victor";
double salary = 85000.50;
boolean isActive = true;
```

## Primitive Data Types

Java has **8 primitive types**:

| Type      | Size    | Range / Description        | Example               |
| --------- | ------- | -------------------------- | --------------------- |
| `byte`    | 1 byte  | -128 to 127                | `byte b = 100;`       |
| `short`   | 2 bytes | -32,768 to 32,767          | `short s = 5000;`     |
| `int`     | 4 bytes | -2³¹ to 2³¹-1              | `int x = 42;`         |
| `long`    | 8 bytes | -2⁶³ to 2⁶³-1              | `long l = 100000L;`   |
| `float`   | 4 bytes | \~7 decimal digits         | `float f = 3.14f;`    |
| `double`  | 8 bytes | \~15 decimal digits        | `double d = 3.14159;` |
| `char`    | 2 bytes | Single character (Unicode) | `char c = 'A';`       |
| `boolean` | 1 bit   | `true` or `false`          | `boolean b = true;`   |

## Reference Types

Reference types hold references to objects. The most common is `String`:

```java
String greeting = "Hello, Java!";
int[] numbers = {1, 2, 3, 4, 5};
```

## Type Casting

**Widening (automatic)** — smaller type to larger type:

```java
int myInt = 100;
double myDouble = myInt;  // 100.0 — automatic
```

**Narrowing (manual)** — larger type to smaller type:

```java
double myDouble = 9.78;
int myInt = (int) myDouble;  // 9 — manual cast, decimal truncated
```

## Constants

Use the `final` keyword to declare a constant (value cannot be changed):

```java
final double PI = 3.14159;
final String APP_NAME = "MyApp";

// PI = 3.14;  // ❌ Error: cannot assign to final variable
```

## Naming Conventions

*   **Variables and methods**: `camelCase` → `firstName`, `calculateTotal()`
*   **Classes**: `PascalCase` → `HelloWorld`, `BankAccount`
*   **Constants**: `UPPER_SNAKE_CASE` → `MAX_SIZE`, `PI`


Variables and Data Types

Operators are symbols that perform operations on variables and values.

## Arithmetic Operators

```java
int a = 10, b = 3;

System.out.println(a + b);   // 13  — Addition
System.out.println(a - b);   // 7   — Subtraction
System.out.println(a * b);   // 30  — Multiplication
System.out.println(a / b);   // 3   — Division (integer)
System.out.println(a % b);   // 1   — Modulus (remainder)
```

> **Note:** Integer division truncates the decimal. Use `double` for precise results: `10.0 / 3` → `3.333...`

## Assignment Operators

```java
int x = 10;
x += 5;    // x = x + 5  → 15
x -= 3;    // x = x - 3  → 12
x *= 2;    // x = x * 2  → 24
x /= 4;    // x = x / 4  → 6
x %= 4;    // x = x % 4  → 2
```

## Comparison Operators

These return a `boolean` (`true` or `false`):

```java
int a = 10, b = 20;

System.out.println(a == b);   // false — equal to
System.out.println(a != b);   // true  — not equal
System.out.println(a > b);    // false — greater than
System.out.println(a < b);    // true  — less than
System.out.println(a >= 10);  // true  — greater or equal
System.out.println(a <= 5);   // false — less or equal
```

## Logical Operators

```java
boolean x = true, y = false;

System.out.println(x && y);   // false — AND (both must be true)
System.out.println(x || y);   // true  — OR (at least one true)
System.out.println(!x);       // false — NOT (inverts)
```

## Increment and Decrement

```java
int count = 5;

count++;   // 6 — post-increment
count--;   // 5 — post-decrement
++count;   // 6 — pre-increment
--count;   // 5 — pre-decrement
```

**Pre vs Post:**

```java
int a = 5;
int b = ++a;  // a becomes 6, b = 6 (increment first)
int c = a++;  // c = 6 (assign first), then a becomes 7
```

## Ternary Operator

A shorthand for simple `if-else`:

```java
int age = 20;
String status = (age >= 18) ? "Adult" : "Minor";
System.out.println(status);  // "Adult"
```


Operators

Conditional statements let your program make decisions and execute different code based on conditions.

## if Statement

```java
int temperature = 35;

if (temperature > 30) {
    System.out.println("It's hot outside!");
}
```

## if-else

```java
int age = 16;

if (age >= 18) {
    System.out.println("You can vote.");
} else {
    System.out.println("Too young to vote.");
}
```

## if-else if-else

```java
int score = 75;

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");
}
```

## switch Statement

Best for matching a variable against multiple known values:

```java
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;
    case 4:
        System.out.println("Thursday");
        break;
    case 5:
        System.out.println("Friday");
        break;
    default:
        System.out.println("Weekend");
        break;
}
```

> **Important:** Without `break`, execution "falls through" to the next case.

## Enhanced Switch (Java 14+)

```java
int day = 3;

String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    default -> "Weekend";
};

System.out.println(dayName);  // "Wednesday"
```

The arrow syntax (`->`) eliminates the need for `break` and allows returning values directly.


Chapter 2 : Control Flow

Conditional Statements

Loops let you execute a block of code repeatedly. Java provides several loop constructs.

## for Loop

Best when you know how many times to iterate:

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

**Output:**

```
Iteration: 0
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4
```

## while Loop

Runs as long as the condition is `true`:

```java
int count = 0;

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

## do-while Loop

Executes the body **at least once**, then checks the condition:

```java
int num = 10;

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

// Prints "Number: 10" once, even though condition is false
```

## Enhanced for Loop (for-each)

Ideal for iterating over arrays and collections:

```java
String[] fruits = {"Apple", "Banana", "Cherry"};

for (String fruit : fruits) {
    System.out.println(fruit);
}
```

## break and continue

**`break`** — exits the loop entirely:

```java
for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    System.out.println(i);  // prints 0 to 4
}
```

**`continue`** — skips the current iteration:

```java
for (int i = 0; i < 5; i++) {
    if (i == 2) continue;
    System.out.println(i);  // prints 0, 1, 3, 4 (skips 2)
}
```

## Nested Loops

```java
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.print(i * j + "\t");
    }
    System.out.println();
}
```

**Output:**

```
1	2	3
2	4	6
3	6	9
```


Loops

An array is a fixed-size container that holds multiple values of the **same type**.

## Declaring Arrays

```java
// Declare and initialize
int[] numbers = {10, 20, 30, 40, 50};

// Declare with size (default values: 0 for int)
int[] scores = new int[5];

// Declare then assign
String[] colors;
colors = new String[]{"Red", "Green", "Blue"};
```

## Accessing Elements

Arrays are **zero-indexed**:

```java
int[] nums = {10, 20, 30};

System.out.println(nums[0]);   // 10
System.out.println(nums[2]);   // 30
System.out.println(nums.length);  // 3
```

## Modifying Elements

```java
int[] nums = {10, 20, 30};
nums[1] = 99;
System.out.println(nums[1]);  // 99
```

## Iterating Over Arrays

**for loop:**

```java
int[] nums = {1, 2, 3, 4, 5};

for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
```

**for-each:**

```java
for (int num : nums) {
    System.out.println(num);
}
```

## Multi-Dimensional Arrays

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

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

// Iterate
for (int[] row : matrix) {
    for (int val : row) {
        System.out.print(val + " ");
    }
    System.out.println();
}
```

## Useful Array Operations

```java
import java.util.Arrays;

int[] nums = {5, 2, 8, 1, 9};

// Sort
Arrays.sort(nums);  // {1, 2, 5, 8, 9}

// Search (array must be sorted first)
int index = Arrays.binarySearch(nums, 5);  // 2

// Fill
int[] zeros = new int[5];
Arrays.fill(zeros, 7);  // {7, 7, 7, 7, 7}

// Copy
int[] copy = Arrays.copyOf(nums, 3);  // {1, 2, 5}

// To string
System.out.println(Arrays.toString(nums));  // [1, 2, 5, 8, 9]
```


Chapter 3 : Arrays & Strings

Arrays

Strings in Java are **objects** that represent sequences of characters. They are **immutable** — once created, they cannot be changed.

## Creating Strings

```java
// String literal (recommended)
String name = "Victor";

// Using new keyword
String greeting = new String("Hello");
```

## Common String Methods

```java
String text = "Hello, World!";

text.length();              // 13
text.charAt(0);             // 'H'
text.indexOf("World");      // 7
text.substring(7);          // "World!"
text.substring(0, 5);       // "Hello"
text.toUpperCase();         // "HELLO, WORLD!"
text.toLowerCase();         // "hello, world!"
text.trim();                // removes leading/trailing spaces
text.contains("World");     // true
text.startsWith("Hello");   // true
text.endsWith("!");         // true
text.replace("World", "Java");  // "Hello, Java!"
text.isEmpty();             // false
```

## String Comparison

```java
String a = "hello";
String b = "hello";
String c = new String("hello");

// == compares references
System.out.println(a == b);       // true (same pool reference)
System.out.println(a == c);       // false (different objects)

// .equals() compares content (always use this)
System.out.println(a.equals(c));  // true
System.out.println(a.equalsIgnoreCase("HELLO"));  // true
```

> **Rule:** Always use `.equals()` to compare String content, never `==`.

## String Concatenation

```java
String first = "Victor";
String last = "Preston";

// Using +
String full = first + " " + last;  // "Victor Preston"

// Using concat()
String full2 = first.concat(" ").concat(last);
```

## StringBuilder

For building strings in loops, use `StringBuilder` (mutable and faster):

```java
StringBuilder sb = new StringBuilder();

for (int i = 0; i < 5; i++) {
    sb.append("Item ").append(i).append("\n");
}

String result = sb.toString();
System.out.println(result);
```

## String Formatting

```java
String name = "Victor";
int age = 28;

// printf style
System.out.printf("Name: %s, Age: %d%n", name, age);

// String.format
String info = String.format("Name: %s, Age: %d", name, age);
```

| Format | Type                  |
| ------ | --------------------- |
| `%s`   | String                |
| `%d`   | Integer               |
| `%f`   | Float/Double          |
| `%.2f` | Float with 2 decimals |
| `%n`   | Newline               |


Strings

Java is an **object-oriented** language. Everything revolves around **classes** (blueprints) and **objects** (instances).

## Defining a Class

```java
public class Car {
    // Fields (attributes)
    String brand;
    String color;
    int year;

    // Method (behavior)
    void drive() {
        System.out.println(brand + " is driving!");
    }
}
```

## Creating Objects

```java
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.brand = "Toyota";
        myCar.color = "Red";
        myCar.year = 2024;

        myCar.drive();  // "Toyota is driving!"
    }
}
```

## Constructors

A constructor initializes an object when it's created:

```java
public class Car {
    String brand;
    int year;

    // Constructor
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    void display() {
        System.out.println(brand + " (" + year + ")");
    }
}

// Usage
Car car = new Car("Honda", 2023);
car.display();  // "Honda (2023)"
```

## The `this` Keyword

`this` refers to the current object instance:

```java
public class Person {
    String name;

    public Person(String name) {
        this.name = name;  // this.name = field, name = parameter
    }
}
```

## Access Modifiers

| Modifier    | Class | Package | Subclass | World |
| ----------- | ----- | ------- | -------- | ----- |
| `public`    | Yes   | Yes     | Yes      | Yes   |
| `protected` | Yes   | Yes     | Yes      | No    |
| (default)   | Yes   | Yes     | No       | No    |
| `private`   | Yes   | No      | No       | No    |

## Getters and Setters (Encapsulation)

Keep fields `private` and expose them through methods:

```java
public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // Getter
    public double getBalance() {
        return balance;
    }

    // Setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}
```

## Static Members

`static` fields and methods belong to the **class**, not instances:

```java
public class Counter {
    static int count = 0;

    public Counter() {
        count++;
    }

    static int getCount() {
        return count;
    }
}

// Usage
new Counter();
new Counter();
System.out.println(Counter.getCount());  // 2
```


Chapter 4 : OOP

Classes and Objects

Inheritance allows a class to **inherit** fields and methods from another class. Polymorphism means objects can take **many forms**.

## Inheritance

Use the `extends` keyword:

```java
// Parent (superclass)
public class Animal {
    String name;

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

    void speak() {
        System.out.println(name + " makes a sound.");
    }
}

// Child (subclass)
public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // calls parent constructor
    }

    @Override
    void speak() {
        System.out.println(name + " barks!");
    }
}

// Usage
Dog dog = new Dog("Rex");
dog.speak();  // "Rex barks!"
```

## The `super` Keyword

*   `super()` — calls the parent constructor
*   `super.method()` — calls the parent's version of an overridden method

```java
public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    void speak() {
        super.speak();  // "Whiskers makes a sound."
        System.out.println(name + " meows!");
    }
}
```

## Polymorphism

A parent reference can hold a child object:

```java
Animal myAnimal = new Dog("Buddy");
myAnimal.speak();  // "Buddy barks!" — calls Dog's version

Animal[] animals = {
    new Dog("Rex"),
    new Cat("Whiskers"),
    new Animal("Bird")
};

for (Animal a : animals) {
    a.speak();  // each calls its own version
}
```

## Method Overloading

Same method name, **different parameters** (compile-time polymorphism):

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

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

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

## Abstract Classes

Cannot be instantiated directly — must be extended:

```java
abstract class Shape {
    abstract double area();  // no body — subclass must implement

    void describe() {
        System.out.println("Area: " + area());
    }
}

class Circle extends Shape {
    double radius;

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

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

## Interfaces

A contract that classes must fulfill:

```java
interface Drawable {
    void draw();  // implicitly public and abstract
}

interface Resizable {
    void resize(double factor);
}

class Square implements Drawable, Resizable {
    double side;

    Square(double side) {
        this.side = side;
    }

    @Override
    public void draw() {
        System.out.println("Drawing square with side: " + side);
    }

    @Override
    public void resize(double factor) {
        side *= factor;
    }
}
```

> **Key difference:** A class can implement **multiple interfaces** but extend only **one class**.


Inheritance and Polymorphism

Exceptions are events that disrupt the normal flow of a program. Java provides a robust mechanism to **catch** and **handle** them gracefully.

## try-catch

```java
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
    System.out.println("Error: " + e.getMessage());
}
```

## Multiple catch Blocks

```java
try {
    int[] nums = {1, 2, 3};
    System.out.println(nums[10]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index out of bounds!");
} catch (Exception e) {
    System.out.println("Something went wrong: " + e.getMessage());
}
```

> **Order matters:** Catch the most specific exception first, then broader ones.

## finally Block

The `finally` block **always executes**, whether an exception occurred or not:

```java
try {
    int result = 10 / 2;
    System.out.println("Result: " + result);
} catch (ArithmeticException e) {
    System.out.println("Error!");
} finally {
    System.out.println("This always runs.");
}
```

## throw and throws

**`throw`** — manually throw an exception:

```java
public void setAge(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative");
    }
    this.age = age;
}
```

**`throws`** — declares that a method might throw an exception:

```java
public void readFile(String path) throws IOException {
    FileReader reader = new FileReader(path);
    // ...
}
```

## Custom Exceptions

```java
public class InsufficientFundsException extends Exception {
    private double amount;

    public InsufficientFundsException(double amount) {
        super("Insufficient funds. Short by: " + amount);
        this.amount = amount;
    }

    public double getAmount() {
        return amount;
    }
}

// Usage
public void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance) {
        throw new InsufficientFundsException(amount - balance);
    }
    balance -= amount;
}
```

## Exception Hierarchy

```
Throwable
├── Error (serious, don't catch)
│   ├── OutOfMemoryError
│   └── StackOverflowError
└── Exception
    ├── IOException (checked)
    ├── SQLException (checked)
    └── RuntimeException (unchecked)
        ├── NullPointerException
        ├── ArrayIndexOutOfBoundsException
        ├── ArithmeticException
        └── IllegalArgumentException
```

*   **Checked exceptions** — must be caught or declared with `throws`
*   **Unchecked exceptions** — extend `RuntimeException`, no obligation to catch
