Interface Java: Mendefinisikan Kontrak dan implements

Interface Adalah Kontrak

Interface mendeklarasikan apa yang bisa dilakukan sebuah class tanpa mengatakan bagaimana. Isinya daftar signature method yang dijanjikan akan dipenuhi oleh setiap class yang mengimplementasikannya. Tujuannya adalah decoupling: kode bisa bekerja dengan tipe interface tanpa peduli class konkret mana yang ada di baliknya.

interface Shape {
    double area();          // every Shape must provide an area
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

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

    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape berarti Circle wajib mendefinisikan area dan perimeter. Begitu itu dipenuhi, Circle adalah Shape dan bisa disimpan di variabel bertipe Shape.

Banyak Class, Satu Tipe

Kekuatannya terlihat saat beberapa class yang tidak saling berhubungan mengimplementasikan interface yang sama. Kode yang ditulis untuk Shape bisa menangani semuanya:

import java.util.List;

interface Shape {
    double area();
}

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

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(2, 3), new Circle(2));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // works for every Shape, whatever its class
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Loop itu tidak pernah bertanya "ini Circle atau Rectangle?". Ia hanya memanggil area() dan memercayai kontraknya. Menambahkan Triangle nanti tidak membutuhkan perubahan apa pun di sini.

Mengimplementasikan Banyak Interface

Sebuah class hanya bisa meng-extend satu class, tetapi bisa mengimplementasikan interface sebanyak apa pun. Beginilah cara Java melakukan "multiple inheritance" perilaku dengan aman:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

Tuliskan interface-nya dipisahkan koma setelah implements. Class itu wajib memenuhi semuanya.

Method default dan static

Sejak Java 8, interface bisa membawa body method. Method default memberi class yang mengimplementasikannya implementasi siap pakai yang diwarisi secara gratis (dan boleh di-override):

interface Greeter {
    String name();

    default String greet() {        // shared implementation
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() is inherited from the interface
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

Method default memungkinkan sebuah interface berkembang, yaitu menambahkan method tanpa merusak setiap implementasi yang sudah ada. Sebaliknya, method interface static berperilaku seperti static member lainnya: ia adalah utilitas yang kamu panggil langsung pada interface itu, misalnya Comparator.naturalOrder().

Konstanta

Field di dalam interface secara implisit bersifat public static final: field itu adalah konstanta, bukan state instance:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

Secara tradisional, interface tidak menyimpan state per objek; tidak adanya field instance adalah bagian dari hal yang membedakannya dengan class.

Functional Interface

Interface yang punya tepat satu abstract method disebut functional interface, dan kamu bisa mengimplementasikannya dengan lambda expression, bukan dengan class utuh:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // lambda implements the single method
        System.out.println(doubler.apply(21));
    }
}

Inilah fondasi lambda di Java dan tipe-tipe di java.util.function (Function, Predicate, Supplier, dan kawan-kawannya). Anotasi @FunctionalInterface membuat maksudnya jelas dan memungkinkan compiler menegakkan aturan satu method itu.

Interface vs Abstract Class

Keduanya memungkinkanmu menulis kode berdasarkan abstraksi, jadi kapan memilih yang mana?

• Interface: kemampuan yang bisa dimiliki class yang tidak saling berhubungan. Bird dan Airplane sama-sama bisa menjadi Flyable. Sebuah class bisa mengimplementasikan banyak interface. Tidak ada state instance.
• Abstract class: state dan kode bersama di antara class yang erat kaitannya. Cat dan Dog sama-sama meng-extend Animal, mewarisi field bersama dan method yang sebagian sudah diimplementasikan. Sebuah class hanya bisa meng-extend satu class.

Pola yang umum adalah menggabungkan keduanya: interface mendefinisikan kontraknya, dan abstract class mengimplementasikan bagian boilerplate, sehingga subclass konkret cukup mengisi bagian yang spesifik saja.

Berikutnya: Abstract Class

Interface mendefinisikan perilaku tanpa state. Abstract class berada di antara interface dan class utuh: ia bisa mendeklarasikan method yang belum diimplementasikan sekaligus membawa field dan constructor. Itu topik halaman berikutnya.