Class Java: Mendefinisikan Field, Method, dan Objek

Class Adalah Cetak Biru

Sampai sekarang kodemu tinggal di dalam method yang mengoper nilai-nilai biasa ke sana kemari. Class memungkinkanmu menggabungkan data yang saling berkaitan dan perilaku yang bekerja pada data itu menjadi satu tipe yang punya nama. Class adalah cetak birunya; benda yang benar-benar kamu pakai adalah objek yang dibuat dari class itu.

Sebuah class mendeklarasikan dua jenis member: field (data yang disimpan setiap objek) dan method (hal yang bisa dilakukan setiap objek).

class Dog {
    String name;          // a field: every Dog has a name
    int age;              // another field

    void bark() {         // a method: behavior every Dog has
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // create an object from the blueprint
        d.name = "Rex";       // set its fields
        d.age = 3;
        d.bark();             // call its method
    }
}

new Dog() membangun sebuah objek di memori dan memberimu referensi ke objek itu. d.name dan d.bark() menjangkau objek tertentu tersebut.

Setiap Objek Punya State Sendiri

Inti dari sebuah class adalah kamu bisa mencetak banyak objek yang berdiri sendiri, masing-masing dengan nilai field-nya sendiri. Mengubah yang satu tidak pernah menyentuh yang lain.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex dan bella adalah dua objek yang terpisah. Masing-masing punya name sendiri, jadi setiap bark() mencetak nilai yang berbeda. Data per objek ini disebut state instance.

Field dan Method Bekerja Sama

Method di dalam class bisa membaca dan mengubah field milik objeknya secara langsung, tanpa perlu mengopernya sebagai parameter. Method itu sudah "menempel" pada objek yang datanya ia sentuh.

class Counter {
    int count;            // starts at 0 by default

    void increment() {
        count++;          // updates this object's field
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Perhatikan bahwa increment() tidak menerima argumen. Ia bekerja pada field milik Counter mana pun tempat method itu dipanggil. Inilah perbedaan antara method class dan method static yang berdiri sendiri: method ini punya objek implisit untuk dikerjakan.

Kata Kunci this

Di dalam method, this adalah referensi ke objek tempat method itu dipanggil. Biasanya kamu tidak membutuhkannya, karena menulis count sudah berarti this.count. Namun this menjadi penting saat nama parameter bentrok dengan nama field, yang sangat sering terjadi di setter dan constructor.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x is the field; x is the parameter
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

Kesalahan pemula yang umum adalah menulis x = x; di dalam move. Itu hanya mengisi parameter dengan dirinya sendiri dan membiarkan field-nya tidak tersentuh. Compiler tidak akan memperingatkanmu, dan objekmu diam-diam tetap menyimpan nilai lamanya. this.x = x; adalah yang benar-benar mengubah field.

Nilai Default Field dan Referensi null

Saat kamu membuat objek, field-nya tidak dibiarkan berisi sampah: Java menginisialisasinya dengan nilai default, yaitu 0 untuk angka, false untuk boolean, dan null untuk referensi objek seperti String. Nilai default null itulah sumber crash klasik.

class User {
    String name;          // not assigned, so it defaults to null
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name bernilai null karena tidak ada yang mengisinya, jadi memanggil .length() padanya melempar NullPointerException. Selalu beri nilai yang bermakna pada objek sebelum memakai field-nya. Masalah inilah yang diselesaikan oleh constructor.

Mengatur Kode di Sekitar Class

Program sungguhan memodelkan domainnya sebagai class yang menyimpan data beserta operasi pada data itu. Di sini, satu class BankAccount menyimpan saldo dan menjaga cara saldo itu berubah:

class BankAccount {
    String owner;
    double balance;

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

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // not enough funds
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

Data (balance) dan aturan untuk mengubahnya (deposit, withdraw) berada di satu tempat. Kode di tempat lain meminta rekening itu melakukan sesuatu, bukan mengutak-atik angkanya secara langsung. Inilah fondasi desain yang rapi dan mudah dirawat.

Berikutnya: Constructor

Mengisi setiap field secara manual setelah new itu membosankan dan gampang terlupa, dan seperti yang baru saja kamu lihat, field yang terlupa menyisakan null yang siap membuat crash. Constructor memungkinkanmu mewajibkan dan menginisialisasi field sebuah objek tepat saat objek itu dibuat, sehingga BankAccount tidak pernah bisa ada tanpa pemilik. Itu topik halaman berikutnya.