Abstract Class Java: Penjelasan Kata Kunci abstract

Apa Itu Abstract Class

Interface mendeklarasikan perilaku tanpa state. Class biasa sudah diimplementasikan sepenuhnya dan bisa dibuat instance-nya. Abstract class berada di antara keduanya: ia bisa punya field, constructor, dan method yang sudah jadi seperti class biasa, tetapi juga boleh membiarkan beberapa method tanpa implementasi, dan ia tidak bisa dibuat instance-nya secara langsung. Kamu menandainya dengan kata kunci abstract.

Tujuannya adalah mengumpulkan semua hal yang sama di antara subclass dalam satu tempat, sambil memaksa setiap subclass mengisi bagian yang memang berbeda.

abstract class Animal {
    private final String name;

    Animal(String name) { this.name = name; }   // shared constructor

    String getName() { return name; }            // shared, finished method

    abstract String sound();                     // no body - each subclass decides
}

class Dog extends Animal {
    Dog(String name) { super(name); }
    String sound() { return "Woof"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog("Rex");
        System.out.println(a.getName() + " says " + a.sound());
    }
}

Animal mendefinisikan getName() sekali untuk semua subclass dan mendeklarasikan sound() sebagai abstract, yaitu method yang punya signature tetapi tidak punya body, dan Dog wajib menyediakannya.

Abstract Class Tidak Bisa Dibuat Instance-nya

Karena abstract class bisa punya method yang belum selesai, membuatnya secara langsung akan menghasilkan objek yang tidak lengkap. Compiler menolaknya:

Animal a = new Animal("???");   // error: Animal is abstract; cannot be instantiated

Yang selalu kamu buat adalah instance dari subclass konkret, yaitu subclass yang sudah mengimplementasikan setiap abstract method. Instance subclass itu lalu bisa disimpan di variabel bertipe abstract class, dan memang begitulah cara abstraksi ini dipakai.

Abstract Method Memaksa Subclass Mengambil Keputusan

Method abstract adalah janji yang harus ditepati subclass. Kalau sebuah subclass lupa mengimplementasikannya, subclass itu sendiri menjadi abstract dan compiler akan memberitahumu. Inilah kekuatan utama abstract class: ia menjamin perilaku tertentu pasti ada, tanpa menentukan apa yang dilakukan perilaku itu.

abstract class Shape {
    abstract double area();                       // every shape must define this

    void describe() {                             // shared, written once
        System.out.printf("%s with area %.2f%n",
            getClass().getSimpleName(), area());
    }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Square(3) };
        for (Shape s : shapes) {
            s.describe();                         // calls the right area() automatically
        }
    }
}

describe() ditulis sekali di Shape, tetapi memanggil area() milik masing-masing subclass. Abstract class menyediakan kerangka yang sama, dan subclass menyediakan detailnya.

State Bersama dan Constructor

Berbeda dengan interface tradisional, abstract class bisa menyimpan field instance dan mendefinisikan constructor. Constructor itu tidak pernah membuat Animal atau Shape dengan sendirinya. Ia berjalan lewat super(...) saat sebuah subclass dibuat, untuk menginisialisasi state bersama.

abstract class Account {
    private double balance;

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

    double getBalance() { return balance; }

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

    abstract double interestRate();               // differs per account type

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

class Savings extends Account {
    Savings(double opening) { super(opening); }
    double interestRate() { return 0.05; }
}

public class Main {
    public static void main(String[] args) {
        Account acc = new Savings(1000);
        acc.deposit(500);
        acc.applyInterest();
        System.out.printf("balance: %.2f%n", acc.getBalance());
    }
}

Field balance, deposit, dan applyInterest berada di satu tempat. Hanya aturan yang benar-benar berbeda, yaitu interestRate(), yang dibiarkan abstract. Constructor subclass wajib memanggil super(...) untuk menginisialisasi state yang diwarisi itu.

Jebakan: Mencampur abstract dan final

abstract dan final itu berlawanan. Method abstract menuntut override, sedangkan method final melarangnya. Menandai hal yang sama dengan keduanya, atau membuat abstract class yang final, menghasilkan error kompilasi. Ingat juga bahwa abstract class boleh punya nol abstract method: mendeklarasikan class sebagai abstract hanya untuk mencegahnya dibuat instance-nya itu sah, dan kadang berguna untuk tipe dasar yang hanya ingin kamu extend.

abstract final class Bad { }        // error: abstract and final conflict

abstract class Base {
    abstract final void f();        // error: an abstract method can't be final
}

Abstract Class vs Interface

Keduanya mirip, jadi pilihannya bergantung pada apa yang ingin kamu bagikan:

• Abstract class: pakai untuk class yang erat kaitannya dan berbagi state serta kode. Savings dan Checking sama-sama meng-extend Account, sehingga keduanya mewarisi field balance dan logika deposit. Sebuah class hanya bisa meng-extend satu class.
• Interface: pakai untuk kemampuan yang bisa dimiliki class yang tidak saling berhubungan. Bird dan Airplane sama-sama bisa menjadi Flyable tanpa berbagi implementasi apa pun. Sebuah class bisa mengimplementasikan banyak interface.

Pola yang sering dipakai adalah menggabungkan keduanya: interface mendefinisikan kontraknya, lalu abstract class mengimplementasikan kode boilerplate, sehingga subclass konkret cukup mengisi bagian yang unik saja.

Berikutnya: Polymorphism

Perhatikan bahwa di setiap contoh di atas, kita menyimpan instance subclass di variabel bertipe abstract class, lalu memanggil sebuah method dan otomatis mendapatkan perilaku subclass-nya. Kemampuan itu, satu tipe referensi dengan banyak perilaku saat runtime, disebut polymorphism, dan itulah yang membuat abstract class dan interface benar-benar berguna. Itulah topik halaman berikutnya.