# ☕ Pengenalan kepada Java

## 📘 Apa Itu Java?

**Java** ialah bahasa pengaturcaraan tahap tinggi yang direka oleh Sun Microsystems (kini dimiliki oleh Oracle). Ia menggunakan paradigma **berorientasikan objek (OOP)** dan boleh dijalankan di mana-mana platform menggunakan **Java Virtual Machine (JVM)**, iaitu runtime khas untuk menjalankan aplikasi Java.

Java digunakan secara meluas untuk membangunkan aplikasi web, aplikasi mudah alih (terutama Android), sistem perniagaan, permainan video, dan perisian perusahaan.

> ⚙️ **Untuk sistem SKB yang dibangunkan oleh pasukan kita, Java digunakan sebagai bahasa utama bagi bahagian backend**, kerana kestabilan, keselamatan dan kemampuannya mengendalikan aplikasi berskala besar.

---

## 🔧 Ciri-Ciri Utama Java

Bahasa Java mempunyai beberapa kelebihan penting:

- ✅ **Berorientasikan Objek (OOP)** – Bina aplikasi yang modular dan mudah diurus
- 🔁 **Platform-Independent** – Kod boleh dijalankan di mana-mana platform yang menyokong JVM
- 🛡️ **Selamat & Terkawal** – Dengan pengurusan memori automatik
- 🌐 **Digunakan Secara Luas** – Digunakan oleh syarikat gergasi dan komuniti global

---

## 🧱 Struktur Asas Program Java

🔰 Ini ialah struktur minimum program Java yang sah:

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

📌 Penjelasan:
- `class HelloWorld` – Semua kod mesti berada dalam kelas
- `main()` – Titik masuk program
- `System.out.println()` – Arahan untuk paparan ke skrin

---


## 🔣 Pemboleh Ubah dan Jenis Data

📌 Kita gunakan **pemboleh ubah** untuk menyimpan nilai dalam memori semasa program dijalankan.

```java
int umur = 25;
double gaji = 4500.75;
char abjad = 'A';
boolean isPelajar = true;
String nama = "Ali";
```

### ✅ Jenis Data Penting dalam Java

| Jenis Data | Keterangan             | Contoh                    |
|------------|------------------------|---------------------------|
| `int`      | Nombor bulat           | `int umur = 25;`          |
| `double`   | Nombor perpuluhan      | `double gaji = 4500.75;`  |
| `char`     | Satu aksara            | `char abjad = 'A';`       |
| `boolean`  | Nilai benar/palsu      | `boolean isPelajar = true;` |
| `String`   | Rangkaian aksara (teks)| `String nama = "Ali";`    |

---

### 🔄 Perbezaan: Primitif vs Bukan Primitif

| Ciri              | **Primitif**                         | **Bukan Primitif**               |
|-------------------|--------------------------------------|----------------------------------|
| Didefinisi oleh   | Bahasa Java                          | Kelas (Class)                    |
| Contoh            | `int`, `double`, `char`, `boolean`   | `String`, `Array`, `Object`      |
| Boleh `null`      | ❌ Tidak boleh                       | ✅ Boleh                          |
| Ada method        | ❌ Tiada                             | ✅ Ada                            |
| Digunakan untuk   | Nilai asas                           | Objek dan struktur data          |
| Penyimpanan       | Nilai terus                          | Rujukan ke objek                 |

---

### 🧪 Contoh Program Lengkap

```java
public class DataJenisDemo {
    public static void main(String[] args) {
        // Primitif
        int umur = 25;
        double gaji = 4500.75;
        char abjad = 'A';
        boolean isPelajar = true;

        // Bukan Primitif
        String nama = "Ali";

        // Papar maklumat
        System.out.println("Nama: " + nama);
        System.out.println("Umur: " + umur + " tahun");
        System.out.println("Gaji: RM" + gaji);
        System.out.println("Abjad: " + abjad);
        System.out.println("Status Pelajar: " + isPelajar);

        // Demonstrasi objek
        Integer umurObj = umur; // Autoboxing
        System.out.println("Umur sebagai objek: " + umurObj.toString());
    }
}
```

---



## ⚙️ Operator Aritmetik dan Logik

📌 Digunakan untuk **kiraan matematik** dan **membuat keputusan logik** dalam sesuatu program.

### 🧮 Operator Aritmetik

Operator ini digunakan untuk melakukan operasi matematik asas:

| Operator | Nama        | Contoh            | Hasil         |
|----------|-------------|-------------------|---------------|
| `+`      | Tambah      | `10 + 5`          | `15`          |
| `-`      | Tolak       | `10 - 3`          | `7`           |
| `*`      | Darab       | `4 * 5`           | `20`          |
| `/`      | Bahagi      | `20 / 4`          | `5`           |
| `%`      | Modulus     | `10 % 3`          | `1` (baki)    |

### 🔍 Operator Perbandingan

Operator ini membandingkan dua nilai dan hasilnya ialah `true` atau `false`:

| Operator | Nama               | Contoh          | Hasil     |
|----------|--------------------|-----------------|-----------|
| `==`     | Sama dengan        | `5 == 5`        | `true`    |
| `!=`     | Tidak sama dengan  | `5 != 3`        | `true`    |
| `<`      | Kurang daripada    | `2 < 5`         | `true`    |
| `>`      | Lebih daripada     | `6 > 3`         | `true`    |
| `<=`     | Kurang atau sama   | `4 <= 4`        | `true`    |
| `>=`     | Lebih atau sama    | `5 >= 2`        | `true`    |

### 🧠 Operator Logik

Digunakan untuk gabungkan syarat logik, selalunya dalam `if`:

| Operator | Nama              | Contoh                         | Hasil     |
|----------|-------------------|--------------------------------|-----------|
| `&&`     | Dan (AND)         | `(5 > 3) && (3 < 10)`          | `true`    |
| `||`     | Atau (OR)         | `(5 < 3) || (3 < 10)`          | `true`    |
| `!`      | Tidak (NOT)       | `!(5 == 5)`                    | `false`   |

---

### 🧪 Contoh Program Lengkap

```java
public class OperatorDemo {
    public static void main(String[] args) {
        int a = 10 + 5; // Aritmetik
        System.out.println("Nilai a: " + a); // 15

        boolean logik = (a > 10) && (a < 20); // Logik
        System.out.println("Adakah a di antara 10 dan 20? " + logik); // true

        int baki = a % 4;
        System.out.println("Baki apabila a dibahagi 4: " + baki); // 3
    }
}
```

---


## 🔁 Kawalan Aliran

📌 Digunakan untuk mengawal aliran kod berdasarkan syarat dan pengulangan.

### Kawalan Bersyarat
```java
if (umur >= 18) {
    System.out.println("Dewasa");
} else {
    System.out.println("Belum cukup umur");
}
```

### Ulangan (Loop)
```java
for (int i = 0; i < 3; i++) {
    System.out.println("Ulangan ke-" + i);
}
```

---

## 📦 Array (Senarai Statik)

📌 Digunakan untuk menyimpan banyak nilai dalam satu struktur.

```java
int[] nombor = {1, 2, 3, 4};
System.out.println(nombor[0]); // output: 1
```

---

## 📚 Koleksi: ArrayList & HashMap

📌 Koleksi digunakan untuk mengurus kumpulan data secara dinamik (tidak seperti array statik).

### 🔸 ArrayList
```java
import java.util.ArrayList;

ArrayList<String> senarai = new ArrayList<>();
senarai.add("Ali");
senarai.add("Siti");

System.out.println(senarai.get(0)); // Ali
```
- Boleh tambah, padam dan akses elemen dengan mudah
- Bersifat dinamik: saiz berubah ikut keperluan

### 🔸 HashMap
```java
import java.util.HashMap;

HashMap<String, Integer> skor = new HashMap<>();
skor.put("Ali", 90);
skor.put("Siti", 85);

System.out.println(skor.get("Ali")); // 90
```
- Simpan data dalam pasangan `key-value`
- Contoh: nama pelajar sebagai key, markah sebagai value

---

## ⚠️ Exception Handling (Pengendalian Ralat)

📌 Java membolehkan anda tangani ralat semasa runtime supaya aplikasi tidak terus berhenti secara tiba-tiba.

### Contoh:
```java
try {
    int hasil = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Ralat: Bahagi dengan sifar!");
}
```

- `try` – kod yang berpotensi cetuskan ralat
- `catch` – blok yang dijalankan jika berlaku ralat
- `finally` – (opsyenal) sentiasa dijalankan

---

# 📦 Pengurusan Memori: Stack, Heap & Garbage Collector dalam Java

---

## 📊 Jadual Ringkasan: Garbage Collector dalam Java

| Ciri                          | Penjelasan                                                                 |
|-------------------------------|-----------------------------------------------------------------------------|
| Apa itu GC?                   | Proses automatik oleh JVM untuk membuang objek dalam heap yang tidak digunakan |
| Bila GC jalan?                | Bila heap makin penuh, atau secara berkala ditentukan oleh JVM              |
| Apa objek yang dibuang?       | Objek yang **tiada lagi reference aktif** dari stack, static, atau thread  |
| Kawasan utama GC bekerja      | **Heap memory**                                                            |
| Apa yang tidak disentuh GC?   | Stack memory, reference masih aktif, primitive types                       |

---

## 🔁 Carta Alir Garbage Collector

```
[JVM Berjalan]
       ↓
[Cipta Objek Baru dalam Heap]
       ↓
[Masih Ada Reference?]
    ┌──────────────┐
    │     Ya       │ → [Objek Aktif, Simpan Dalam Heap]
    └────┬─────────┘
         │ Tidak
         ↓
[Objek Tiada Reference]
         ↓
[Layak untuk Dibuang oleh GC]
         ↓
[Garbage Collector Jalan]
         ↓
[Buang Objek dari Heap, Kosongkan Memori]
         ↓
[JVM Terus Berjalan]
```

## ✅ Contoh 1: Garbage Collector Buang Objek Bila Tiada Reference

```java
public class GCDemo {
    static class Data {
        int[] values = new int[1_000_000]; // Ambil ruang dalam heap
    }

    public static void main(String[] args) {
        System.out.println("Program bermula...");

        for (int i = 0; i < 10; i++) {
            Data d = new Data(); // d hanya hidup dalam 1 pusingan
            System.out.println("Objek " + (i + 1) + " dicipta");
        }

        System.out.println("Semua objek tiada reference, GC boleh buang bila perlu.");
    }
}
```

### 💡 Penjelasan:
- `Data d` hanya wujud dalam setiap pusingan
- Bila pusingan seterusnya bermula, `d` yang lama **hilang reference**
- Objek lama di heap jadi **layak dibuang oleh GC**

### ✅ Expected Output:

```
Program bermula...
Objek 1 dicipta
Objek 2 dicipta
...
Objek 10 dicipta
Semua objek tiada reference, GC boleh buang bila perlu.
```

---

## ❌ Contoh 2: Memory Leak — Objek Masih Dirujuk Walaupun Tak Digunakan Lagi

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

public class MemoryLeakDemo {
    static List<Data> cache = new ArrayList<>();

    static class Data {
        int[] values = new int[1_000_000]; // 1 juta int = ±4MB
    }

    public static void main(String[] args) {
        System.out.println("Program mula (dengan memory leak)...");

        for (int i = 0; i < 1000; i++) {
            cache.add(new Data()); // Objek masih dirujuk oleh `cache`
            System.out.println("Tambah objek ke-" + (i + 1));
        }

        System.out.println("Selesai. Semua objek masih dirujuk — GC tak boleh buang.");
    }
}
```

### ❗ Penjelasan:
- Semua objek `new Data()` masih disimpan dalam `static List cache`
- GC **tak boleh buang** sebab reference masih ada
- Bila terlalu banyak objek disimpan, **heap penuh → `OutOfMemoryError`**

### ❌ Expected Output:

```
Program mula (dengan memory leak)...
Tambah objek ke-1
Tambah objek ke-2
...
Tambah objek ke-300
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
```

---

## 📌 Jalankan dengan GC Log (opsyenal):

```bash
java -Xmx128m -XX:+PrintGC GCDemo
```

---

## ✅ Ringkasan

| Contoh                          | Apa Jadi?                                    |
|----------------------------------|-----------------------------------------------|
| `GCDemo`                         | GC boleh buang objek selepas hilang reference |
| `MemoryLeakDemo`                 | Semua objek masih dirujuk → GC tak boleh buang |
| `static` atau `List` tanpa buang | Punca memory leak biasa dalam Java            |
---

## 🧠 Asas Pemrograman Berorientasikan Objek (OOP)

**OOP** (Object-Oriented Programming) ialah gaya pengaturcaraan yang menstrukturkan kod berdasarkan **kelas** dan **objek**.

Objek mewakili entiti dunia sebenar dan menggabungkan **data (atribut)** serta **fungsi (method)** dalam satu unit.

---

### 🔎 Apa Itu Kelas & Objek?

#### 🧱 Kelas
Kelas ialah **blueprint** atau pelan untuk mencipta objek.

```java
public class Kereta {
    String warna;

    // Constructor
    Kereta(String w) {
        warna = w;
    }

    void hon() {
        System.out.println("Beep!");
    }
}
```

#### 🚗 Objek
Objek ialah contoh sebenar yang dicipta daripada kelas.

```java
public class Main {
    public static void main(String[] args) {
        Kereta k1 = new Kereta("Merah");
        k1.hon();  // Beep!
        System.out.println("Warna kereta: " + k1.warna);
    }
}
```

**Output dijangka:**
```
Beep!
Warna kereta: Merah
```

---

### 🔑 Empat Prinsip Utama OOP

| Prinsip           | Fungsi                                                                 |
|-------------------|------------------------------------------------------------------------|
| ✅ **Encapsulation** | Sembunyikan data dan kawal akses melalui getter/setter                   |
| 🔁 **Inheritance**   | Wariskan sifat/fungsi dari kelas lain                                 |
| 🔄 **Polymorphism**  | Fungsi sama tapi hasil berbeza bergantung objek atau parameter         |
| 🧩 **Abstraction**   | Sembunyikan detail, hanya dedah fungsi penting                         |

---

### ✅ Contoh Setiap Prinsip

#### 🛡️ Encapsulation

```java
public class Pelajar {
    private String nama;

    public void setNama(String n) {
        nama = n;
    }

    public String getNama() {
        return nama;
    }
}

public class Main {
    public static void main(String[] args) {
        Pelajar p = new Pelajar();
        p.setNama("Ali");
        System.out.println("Nama pelajar: " + p.getNama());
    }
}
```

**Output dijangka:**
```
Nama pelajar: Ali
```

---

#### 👪 Inheritance

```java
class Manusia {
    void bercakap() {
        System.out.println("Bercakap...");
    }
}

class Pelajar extends Manusia {
    void belajar() {
        System.out.println("Belajar...");
    }
}

public class Main {
    public static void main(String[] args) {
        Pelajar p = new Pelajar();
        p.bercakap();
        p.belajar();
    }
}
```

**Output dijangka:**
```
Bercakap...
Belajar...
```

---

#### 🌀 Polymorphism

##### 1. Overriding (mengganti method parent)

```java
class Haiwan {
    void bunyi() {
        System.out.println("Haiwan berbunyi");
    }
}

class Kucing extends Haiwan {
    @Override
    void bunyi() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Haiwan h = new Kucing();
        h.bunyi();
    }
}
```

**Output dijangka:**
```
Meow
```

##### 2. Overloading (method sama nama, parameter berbeza)

```java
class Kalkulator {
    int tambah(int a, int b) {
        return a + b;
    }

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

public class Main {
    public static void main(String[] args) {
        Kalkulator k = new Kalkulator();
        System.out.println("Tambah int: " + k.tambah(2, 3));
        System.out.println("Tambah double: " + k.tambah(2.5, 3.5));
    }
}
```

**Output dijangka:**
```
Tambah int: 5
Tambah double: 6.0
```

---

#### 🔍 Abstraction

##### Menggunakan `abstract class` dengan lebih dari satu method

```java
abstract class Haiwan {
    abstract void suara();
    abstract void makan();
}

class Anjing extends Haiwan {
    void suara() {
        System.out.println("Guk guk");
    }

    void makan() {
        System.out.println("Anjing makan tulang");
    }
}

public class Main {
    public static void main(String[] args) {
        Haiwan h = new Anjing();
        h.suara();
        h.makan();
    }
}
```

**Output dijangka:**
```
Guk guk
Anjing makan tulang
```

---

### 🧩 Interface

```java
interface BolehTerbang {
    void terbang();
}

class Burung implements BolehTerbang {
    public void terbang() {
        System.out.println("Burung terbang di langit");
    }
}

public class Main {
    public static void main(String[] args) {
        BolehTerbang b = new Burung();
        b.terbang();
    }
}
```

**Output dijangka:**
```
Burung terbang di langit
```

---

### 🎯 Kenapa OOP Penting?

- 💡 Modular: Boleh bina komponen yang mudah digabung
- 🔧 Senang selenggara dan kemas kini
- 🔄 Guna semula kod (reuse) dengan `inheritance` dan `interface`
- 🔐 Lebih selamat dengan `private` & `protected` data

---

## 📚 Logik & Struktur Kod

📌 Untuk aplikasi lebih besar, anda perlu:
- Gunakan `method` – pecah kod kepada fungsi kecil
- Gunakan `class` – uruskan komponen aplikasi
- Gunakan `package` – susun projek dalam modul terpisah

Contoh struktur fail:
```
projek/
├── model/
│   └── Pelajar.java
├── service/
│   └── PelajarService.java
└── AppUtama.java
```


---

### 🎯 Kenapa OOP Penting?

- 💡 Mudah untuk bina aplikasi besar secara modular
- 🔧 Kod lebih tersusun dan senang diselenggara
- 🔄 Boleh guna semula kod dengan warisan (inheritance)
- 🔐 Lebih selamat dengan kawalan akses data

## 📚 Logik & Struktur Kod

📌 Untuk aplikasi lebih besar, anda perlu:
- Gunakan `method` – pecah kod kepada fungsi kecil
- Gunakan `class` – urus komponen aplikasi
- Gunakan `package` – susun projek besar secara modul

---

## 🎓 Kesimpulan

Dengan menguasai:

✅ Struktur asas  
✅ Pemboleh ubah & kawalan aliran  
✅ Array & logik  
✅ Prinsip OOP  

...anda sudah mampu membina aplikasi konsol Java yang lengkap dan tersusun.

---


