Java Handout · ⁨Catatan Tangan Java⁩

Setiap program Java berada di dalam sebuah kelas. Ia dimulai pada method bernama main. System.out.println(...) mencetak baris; System.out.print(...) mencetak tanpa baris baru.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
        System.out.println("I am learning Java.");
    }
}

• Java dikompilasi: komiler memeriksa seluruh program, lalu ia dijalankan.
• Setiap statement diakhiri dengan titik koma ;.

Sebuah variabel harus mendeklarasikan tipenya. Tipe primitif umum: int (bilangan bulat), double (desimal), boolean (true/false), char (satu huruf).

public class Main {
    public static void main(String[] args) {
        int age = 17;
        double price = 9.99;
        boolean passed = true;
        System.out.println(age + " " + price + " " + passed);
    }
}

Komentar adalah // (satu baris) atau /* ... */ (blok). Indentasi kode di dalam kurung kurawal { }. Nama kelas dimulai dengan Huruf Besar; variabel dan method menggunakan camelCase (huruf kecil pertama).

public class Main {
    public static void main(String[] args) {
        // greet the user
        String firstName = "Mei";
        System.out.println("Hi, " + firstName);
    }
}

Kesalahan umum

• Setiap statement diakhiri dengan titik koma ;.
• main harus tepat public static void main(String[] args).
• println menambahkan baris baru; print tidak.

Aritmatika Java menggunakan + - * / dan % (sisa bagi). Dengan dua ints, / adalah pembagian integer — ini membuang desimal. +=, -=, dan ++ adalah jalan pintas.

public class Main {
    public static void main(String[] args) {
        int a = 7, b = 2;
        System.out.println(a / b);    // 3 (integer division)
        System.out.println(a % b);    // 1
        double x = 7.0 / 2;           // 3.5 (one side is double)
        System.out.println(x);
    }
}

Beberapa nilai adalah objek dengan method. String memiliki .length(), .substring(), .toUpperCase(). Math memiliki Math.max, Math.sqrt, Math.pow. Kelas wrapper (Integer, Double) membungkus primitif — mis. Integer.parseInt("42").

public class Main {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s.length());                  // 5
        System.out.println(s.toUpperCase());             // HELLO
        System.out.println(Math.max(3, 9));              // 9
        System.out.println(Integer.parseInt("42") + 1);  // 43
    }
}

Math.random() mengembalikan random double dari 0.0 hingga (tetapi tidak termasuk) 1.0. Skala dan cast untuk mendapatkan bilangan bulat — ini adalah idiom AP:

public class Main {
    public static void main(String[] args) {
        // a random whole number from 1 to 6 (a dice roll)
        int roll = (int) (Math.random() * 6) + 1;
        System.out.println(roll >= 1 && roll <= 6);   // true
    }
}

• Integer.MAX_VALUE (2147483647) dan Integer.MIN_VALUE adalah batas dari int; melampauinya akan melingkar kembali (overflow).
• Variabel objek yang menunjuk ke objek apa pun memegang null; memanggil method padanya melempar NullPointerException.

Casting mengubah tipe nilai. (int) membuang desimal; (double) menghindari pembagian integer ketika Anda membutuhkan hasil yang presisi.

public class Main {
    public static void main(String[] args) {
        double pi = 3.99;
        System.out.println((int) pi);            // 3
        int total = 7, n = 2;
        System.out.println((double) total / n);  // 3.5
    }
}

Kesalahan umum

• Pembagian integer: 5 / 2 adalah 2, bukan 2.5. Cast terlebih dahulu: (double) 5 / 2.
• Bandingkan String (dan objek lainnya) dengan .equals(), bukan ==.
• == pada dua objek menguji apakah mereka adalah OBJEK YANG SAMA, bukan apakah mereka terlihat sama.

if menjalankan blok ketika kondisi true; else if dan else menambah kasus lebih lanjut. Kondisi masuk ke ( ), blok ke { }.

public class Main {
    public static void main(String[] args) {
        int score = 72;
        if (score >= 80) {
            System.out.println("A");
        } else if (score >= 60) {
            System.out.println("B");
        } else {
            System.out.println("fail");
        }
    }
}

Bandingkan dengan ==, !=, <, >, <=, >= — perbandingan menghasilkan boolean. Gabungkan dengan && (dan), || (atau), ! (tidak) — operator logika. Untuk Strings, gunakan .equals(...), bukan ==.

public class Main {
    public static void main(String[] args) {
        int age = 16;
        boolean member = true;
        System.out.println(age >= 18 && member);   // false
        String a = "hi";
        System.out.println(a.equals("hi"));        // true
    }
}

switch memilih di antara banyak nilai tetap. Setiap case diakhiri dengan break; default adalah fallback.

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1: System.out.println("Mon"); break;
            case 3: System.out.println("Wed"); break;
            default: System.out.println("other");
        }
    }
}

Kesalahan umum

• Kondisi harus berupa boolean; if (x = 5) tidak bisa dikompilasi (gunakan ==).
• Setiap switch case memerlukan break;, atau kontrol akan turun ke case berikutnya.
• && dan || adalah operator logika; & dan | adalah bitwise.

Siklus while berulang selama kondisi true. Ubah sesuatu di dalamnya, atau ia akan berulang selamanya.

public class Main {
    public static void main(String[] args) {
        int n = 1;
        while (n <= 3) {
            System.out.println(n);
            n++;
        }
    }
}

Siklus for menggabungkan awal, kondisi, dan langkah ke dalam satu baris. Terbaik ketika Anda mengetahui jumlahnya.

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.print(i + " ");
        }
        System.out.println();   // 0 1 2 3 4
    }
}

Pola akumulator: mulai variabel sebelum loop, lalu update setiap giliran.

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;
        }
        System.out.println(total);   // 15
    }
}

Loop di dalam loop adalah loop bersarang. Loop dalam berjalan penuh pada setiap giliran luar.

public class Main {
    public static void main(String[] args) {
        for (int r = 0; r < 3; r++) {
            for (int c = 0; c < 3; c++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

Kesalahan umum

• for (int i = 0; i < n; i++) berjalan n kali (0 hingga n - 1); menggunakan <= berjalan satu kali ekstra.
• Jangan letakkan titik koma tepat setelah for (...) atau while (...) — itu membuat loop kosong.
• Deklarasikan counter di header for agar scope-nya berakhir dengan loop.

Sebuah String adalah teks. Method berguna: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). String bersifat immutable — setiap method mengembalikan String baru.

public class Main {
    public static void main(String[] args) {
        String s = "Python";
        System.out.println(s.length());          // 6
        System.out.println(s.charAt(0));         // P
        System.out.println(s.substring(0, 3));   // Pyt
        System.out.println(s.toUpperCase());     // PYTHON
    }
}

Method yang akan Anda gunakan setiap hari:

compareTo menyusun String dalam urutan kamus — ujian AP menggunakannya untuk pertanyaan pengurutan:

public class Main {
    public static void main(String[] args) {
        String a = "apple", b = "banana";
        System.out.println(a.compareTo(b) < 0);    // true (apple comes first)
        System.out.println(a.compareTo("apple"));  // 0 (equal)
    }
}

Gabungkan strings dengan + (konkatenasi). Kunjungi setiap karakter dengan loop dan .charAt(i).

public class Main {
    public static void main(String[] args) {
        String word = "banana";
        int count = 0;
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'a') count++;
        }
        System.out.println(count);   // 3
    }
}

Ketika Anda membangun String panjang dalam loop, StringBuilder jauh lebih cepat: append potongan-potongan, lalu panggil .toString() sekali.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        System.out.println(sb.toString().trim());   // 1 2 3 4 5
    }
}

Kesalahan umum

• Strings bersifat immutable: s.toUpperCase() mengembalikan String baru, jadi simpan hasilnya.
• Baca karakter dengan s.charAt(i); panjangnya adalah s.length() (sebuah method, dengan ()).
• Membangun String dengan += dalam loop besar lambat; gunakan StringBuilder.

Array menyimpan jumlah nilai tetap dari satu tipe. Index dari 0, dan dapatkan ukuran dengan .length.

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 71, 95};
        System.out.println(scores[0]);       // 88
        System.out.println(scores.length);   // 3
        scores[1] = 100;
        System.out.println(scores[1]);       // 100
    }
}

Jelajahi array dengan loop untuk menemukan nilai maksimum, total, jumlah, atau melakukan pencarian. Loop for-each (for (int x : a)) membaca setiap nilai secara berurutan.

public class Main {
    public static void main(String[] args) {
        int[] a = {3, 9, 2, 7};
        int max = a[0], total = 0;
        for (int x : a) {
            if (x > max) max = x;
            total += x;
        }
        System.out.println(max + " " + total);   // 9 21
    }
}

Array 2-D adalah grid baris dan kolom: grid[row][col].

public class Main {
    public static void main(String[] args) {
        int[][] grid = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(grid[1][2]);   // 6
        for (int[] row : grid) {
            for (int v : row) System.out.print(v + " ");
        }
        System.out.println();             // 1 2 3 4 5 6
    }
}

Kesalahan umum

• Ukuran array adalah a.length (tanpa kurung siku, tanpa ()), dan bersifat tetap saat dibuat.
• Indeks yang valid adalah 0 hingga a.length - 1; a[a.length] akan menyebabkan ArrayIndexOutOfBoundsException.
• Array baru (int[5]) diisi dengan angka nol, bukan dibiarkan kosong.

ArrayList (ArrayList) adalah daftar yang dapat berubah ukurannya—ia membesar dan mengecil saat Anda menambah atau menghapus item. Ini menyimpan objek, jadi gunakan tipe pembungkus seperti Integer (Integer) (bukan int/int). Bagian ⟨<Integer>⟩ adalah tipe generik. Metode utama: .add(x), .get(i), .set(i, x), .size(), .remove(i).

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        nums.add(10);
        nums.add(20);
        nums.add(30);
        System.out.println(nums.size());   // 3
        System.out.println(nums.get(1));   // 20
        nums.set(0, 99);
        System.out.println(nums);          // [99, 20, 30]
    }
}

remove (.remove(i)) menggeser setiap elemen berikutnya satu posisi ke kiri. Jika Anda menghapus sambil menghitung i naik, Anda akan melewatkan elemen berikutnya. Perbaikan: loop mundur, atau jangan increment i setelah operasi remove.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
        // Remove every 4 — loop backwards so removals don't skip items.
        for (int i = nums.size() - 1; i >= 0; i--) {
            if (nums.get(i) == 4) nums.remove(i);
        }
        System.out.println(nums);   // [7, 9]
    }
}

Kesalahan umum

• ArrayList menggunakan .size(), .get(i) dan .add(...) — bukan [] yang Anda gunakan pada array.
• Menghapus item sambil looping maju berdasarkan indeks akan melewatkan item berikutnya (bug remove). Loop mundur, atau gunakan iterator.
• Simpan objek, bukan primitif: gunakan Integer (ArrayList<Integer>), dan Java melakukan auto-boxing pada nilai int (int).

Kelas adalah cetak biru untuk objek. Medan menyimpan data, konstruktor mengatur objek baru, dan metodenya adalah tindakan. this.name berarti "name dari objek ini". Buatlah sebuah objek dengan new.

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex", 3);
        System.out.println(d.describe());   // Rex is 3 years old
        d.haveBirthday();
        System.out.println(d.describe());   // Rex is 4 years old
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {   // constructor
        this.name = name;
        this.age = age;
    }

    public String describe() {
        return name + " is " + age + " years old";
    }

    public void haveBirthday() {
        age++;
    }
}

Anggota static (static) milik class itu sendiri, bukan salah satu objek. Panggil method static pada nama class—seperti Math.random() (Math.max)—dan field static dibagikan oleh setiap objek:

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

class Counter {
    private static int count = 0;      // shared by ALL Counter objects

    public Counter() { count++; }

    public static int made() {         // called on the class: Counter.made()
        return count;
    }
}

Enkapsulasi berarti menyembunyikan data di balik method. Tandai field sebagai private (private) agar kode luar tidak bisa menyentuhnya langsung; tampilkan accessor (getter) untuk membaca, dan method untuk mengubahnya dengan aman. Method tersebut dapat mengawasi data—di sini deposit harus bernilai positif.

public class Main {
    public static void main(String[] args) {
        Account a = new Account(100);
        a.deposit(50);
        a.deposit(-999);                       // rejected by the guard
        System.out.println(a.getBalance());    // 150
    }
}

class Account {
    private int balance;                       // hidden from outside

    public Account(int start) {
        balance = start;
    }

    public void deposit(int amount) {
        if (amount > 0) balance += amount;     // guard keeps balance valid
    }

    public int getBalance() {                  // accessor (getter)
        return balance;
    }
}

Kesalahan umum

• Constructor memiliki nama class dan tanpa tipe pengembalian (bahkan bukan void/void).
• Gunakan this. (this.field) untuk membedakan field dari parameter dengan nama yang sama.
• Buat field menjadi private (private) dan akses melalui method getter/setter (enkapsulasi).

Pewarisan memungkinkan subclass mendaur ulang superclass. Tulis extends (class Cat extends Animal) dan subclass (Cat) akan mendapatkan field dan method dari parent (Animal) secara gratis. Panggil constructor parent dengan super (super(...)).

public class Main {
    public static void main(String[] args) {
        Cat c = new Cat("Milo");
        c.eat();      // Milo is eating  (inherited from Animal)
        c.speak();    // Meow            (Cat's own method)
    }
}

class Animal {
    protected String name;
    public Animal(String name) { this.name = name; }
    public void eat() { System.out.println(name + " is eating"); }
}

class Cat extends Animal {
    public Cat(String name) { super(name); }     // call Animal's constructor
    public void speak() { System.out.println("Meow"); }
}

Subclass dapat menimpa (override) method untuk menggantikan versi orang tuanya. Polimorfisme berarti variabel bertipe parent (Shape) dapat menyimpan subtype mana pun, dan Java memilih method yang tepat (toString) saat waktu eksekusi. @Override (System.out.println(obj)) secara otomatis memanggil method yang ditimpa (obj.toString()).

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Square(3) };
        for (Shape s : shapes) {
            System.out.println(s);          // each calls its own toString
        }
    }
}

class Shape {
    public String toString() { return "a shape"; }
}

class Circle extends Shape {
    private int r;
    public Circle(int r) { this.r = r; }
    public String toString() { return "Circle r=" + r; }     // override
}

class Square extends Shape {
    private int side;
    public Square(int side) { this.side = side; }
    public String toString() { return "Square side=" + side; }   // override
}

Kesalahan umum

• Method yang ditimpa harus mencocokkan tanda tangannya persis; tambahkan @Override (@Override) agar compiler menangkap kesalahan.
• super(...) harus menjadi baris pertama dari constructor subclass.
• Objek subclass IS-A objek superclass, tetapi sebaliknya tidak.

Rekursi adalah method yang memanggil dirinya sendiri. Setiap rekursi memerlukan kasus dasar (kapan berhenti) dan pemanggilan rekursif yang mendekatinya. Tanpa kasus dasar, ia tidak akan pernah berhenti dan menyebabkan stack overflow.

public class Main {
    public static void main(String[] args) {
        System.out.println(factorial(5));   // 120
    }

    public static int factorial(int n) {
        if (n <= 1) return 1;            // base case
        return n * factorial(n - 1);     // recursive call: n * (n-1)!
    }
}

Jejakkan: factorial(5) menunggu factorial(4), yang menunggu factorial(3)… hingga factorial(1) mengembalikan 1. Kemudian jawaban dikalikan kembali ke atas: 1 → 2 → 6 → 24 → 120.

Rekursi juga bekerja pada String—lepas satu karakter setiap pemanggilan:

public class Main {
    public static void main(String[] args) {
        System.out.println(reverse("PYTHON"));   // NOHTYP
    }

    static String reverse(String s) {
        if (s.length() <= 1) return s;               // base case
        return reverse(s.substring(1)) + s.charAt(0);
    }
}

Merge sort adalah sorting rekursif pada ujian AP: belah array menjadi dua, urutkan masing-masing bagian secara rekursif, lalu gabungkan kedua bagian yang sudah terurut. Berjalan dalam O(n log n)—jauh lebih cepat daripada sorting O(n²) pada array besar.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7, 3};
        mergeSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));   // [1, 2, 3, 5, 7, 9]
    }

    static void mergeSort(int[] a, int lo, int hi) {
        if (lo >= hi) return;                 // base case: one element
        int mid = (lo + hi) / 2;
        mergeSort(a, lo, mid);                // sort the left half
        mergeSort(a, mid + 1, hi);            // sort the right half
        merge(a, lo, mid, hi);                // merge the two halves
    }

    static void merge(int[] a, int lo, int mid, int hi) {
        int[] tmp = new int[hi - lo + 1];
        int i = lo, j = mid + 1, k = 0;
        while (i <= mid && j <= hi) {
            if (a[i] <= a[j]) tmp[k++] = a[i++];
            else              tmp[k++] = a[j++];
        }
        while (i <= mid) tmp[k++] = a[i++];
        while (j <= hi)  tmp[k++] = a[j++];
        for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
    }
}

Kesalahan umum

• Rekursi memerlukan kasus dasar, atau akan menyebabkan StackOverflowError.
• Setiap pemanggilan rekursif harus bergerak LEBIH DEKAT ke kasus dasar.
• Jejakkan contoh kecil secara manual untuk memeriksa apakah rekursi mengembalikan nilai yang benar.
• Dalam merge sort, langkah merge melakukan pekerjaan nyata; rekursi hanya membelah array.

Pencarian linear memeriksa setiap elemen — bekerja pada array apa pun. Pencarian biner jauh lebih cepat tetapi memerlukan array terurut: ia melihat nilai tengah, lalu membuang separuh setiap langkah. Keduanya mengembalikan indeks, atau -1 jika tidak ditemukan.

public class Main {
    public static void main(String[] args) {
        int[] a = {2, 5, 8, 12, 16, 23};      // sorted, so binary search works
        System.out.println(linear(a, 12));    // 3
        System.out.println(binary(a, 12));    // 3
        System.out.println(binary(a, 9));     // -1 (not found)
    }

    static int linear(int[] a, int target) {
        for (int i = 0; i < a.length; i++)
            if (a[i] == target) return i;
        return -1;
    }

    static int binary(int[] a, int target) {
        int lo = 0, hi = a.length - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
}

Selection sort berulang kali menemukan nilai tersisa terkecil dan menukarnya ke depan. Insertion sort mengambil setiap nilai dan menggesernya kembali ke tempatnya di antara nilai-nilai yang sudah terurut.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 0; i < a.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++)
                if (a[j] < a[min]) min = j;
            int t = a[min]; a[min] = a[i]; a[i] = t;   // swap into place
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 1; i < a.length; i++) {
            int key = a[i], j = i - 1;
            while (j >= 0 && a[j] > key) {    // shift bigger values right
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = key;                  // drop key into the gap
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

Bagaimana kecepatan membandingkan:

Kesalahan umum

• Pencarian biner hanya berfungsi pada array yang terurut.
• Pencarian linear adalah O(n); pencarian biner adalah O(log n) tetapi memerlukan pengurutan terlebih dahulu.
• Selection dan insertion sort adalah O(n²)—mudah dipelajari, lambat pada data besar.

Scanner (Scanner) membaca teks satu baris per baris. Untuk file sungguhan Anda menulis new FileReader(...); (new Scanner(new File("scores.txt"))) di sini kita membungkus Scanner (String) agar contoh berjalan di mana saja. Gunakan nextLine().split() (.split(" ")) untuk memecah baris menjadi bagian-bagian dan Integer.parseInt() (Integer.parseInt(...)) untuk parsing angka dari teks.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Real file:  Scanner in = new Scanner(new File("scores.txt"));
        String data = "Alice 80\nBob 95\nCara 72";
        Scanner in = new Scanner(data);
        int total = 0, count = 0;
        while (in.hasNextLine()) {
            String line = in.nextLine();
            String[] parts = line.split(" ");      // break the line on the space
            total += Integer.parseInt(parts[1]);
            count++;
        }
        System.out.println("average = " + (total / count));   // average = 82
    }
}

Ujian AP CS A memiliki empat pertanyaan respons bebas, masing-masing dengan bentuk tetap:

• Q1 — Metode & kontrol: tulis metode sesuai spesifikasi yang diberikan; perulangan, if, String/Math.
• Q2 — Desain kelas: tulis satu kelas lengkap (bidang, konstruktor, metode) berdasarkan deskripsi.
• Q3 — Array / ArrayList: proses array 1-D atau ArrayList (pencarian, penghitungan, membuat daftar baru).
• Q4 — Array 2-D: jelajahi grid berdasarkan baris dan kolom.

Keterampilan yang selalu sama: baca spesifikasi, tulis metode tepat seperti yang dijelaskan, kembalikan tipe yang benar.

public class Main {
    public static void main(String[] args) {
        // Q1 style: implement a method to a spec, then it is tested.
        System.out.println(countEven(new int[]{4, 7, 10, 3, 6}));   // 3
    }

    /** Returns how many values in arr are even. */
    public static int countEven(int[] arr) {
        int count = 0;
        for (int x : arr)
            if (x % 2 == 0) count++;
        return count;
    }
}

Kesalahan umum

• nextInt() meninggalkan baris baru di belakang, sehingga nextLine() berikutnya membaca baris kosong — bacalah itu terlebih dahulu.
• Periksa hasNext() sebelum membaca, untuk menghindari keluar dari akhir file.
• Dalam FRQ, baca header metode dengan teliti: cocokkan tipe kembalian dan parameter secara eksak.