Java Academy · Pelajaran

Antarmuka Fungsional Kustom

Definisikan antarmuka sendiri dengan @FunctionalInterface.

Antarmuka Fungsional Kustom adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Yang Membuat Antarmuka Menjadi Fungsional

Antarmuka fungsional memiliki tepat satu metode abstrak (SAM). Metode tunggal itulah yang diimplementasikan oleh lambda.

Metode bawaan dan statis tidak dihitung dalam batas tersebut.

interface Greeter {
    String greet(String name);
}

public class Main {
    public static void main(String[] args) {
        Greeter g = name -> "Hello, " + name;
        System.out.println(g.greet("Ada"));
    }
}

Anotasi @FunctionalInterface

@FunctionalInterface memberi tahu kompilator untuk menegakkan aturan satu metode abstrak. Jika Anda tidak sengaja menambahkan metode abstrak kedua, kompilasi akan gagal.

@FunctionalInterface
interface Calculator {
    int compute(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        System.out.println(add.compute(3, 4));
    }
}

Mengapa Anotasi Ini Membantu

Anotasi ini mendokumentasikan tujuan dan melindungi kontrak. Tanpanya, antarmuka tersebut tetap berfungsi sebagai antarmuka fungsional, tetapi rekan satu tim dapat merusaknya dengan menambahkan metode abstrak lain.

@FunctionalInterface
interface Transformer {
    String apply(String input);
}

public class Main {
    public static void main(String[] args) {
        Transformer reverse = s -> new StringBuilder(s).reverse().toString();
        System.out.println(reverse.apply("abc"));
    }
}

Antarmuka Kustom dengan Generik

Antarmuka Anda dapat bersifat generik, sama seperti antarmuka bawaan.

@FunctionalInterface
interface Converter<S, T> {
    T convert(S source);
}

public class Main {
    public static void main(String[] args) {
        Converter<String, Integer> toInt = Integer::parseInt;
        System.out.println(toInt.convert("123") + 1);
    }
}

Metode Bawaan Diizinkan

Antarmuka fungsional boleh memiliki metode default. Metode tersebut menambahkan perilaku tanpa melanggar aturan satu metode abstrak.

@FunctionalInterface
interface Operation {
    int apply(int x);

    default Operation then(Operation next) {
        return x -> next.apply(this.apply(x));
    }
}

public class Main {
    public static void main(String[] args) {
        Operation inc = x -> x + 1;
        Operation dbl = x -> x * 2;
        System.out.println(inc.then(dbl).apply(5));
    }
}

Metode Statis Juga Diizinkan

Metode statis dapat berperan sebagai pabrik, serupa dengan Function.identity().

@FunctionalInterface
interface Mapper {
    int map(int x);

    static Mapper identity() {
        return x -> x;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Mapper.identity().map(99));
    }
}

Melempar Pengecualian Terperiksa

Jika metode abstrak Anda mendeklarasikan pengecualian terperiksa, lambda dapat melemparkannya. Function bawaan tidak dapat melakukan ini, yang menjadi salah satu alasan untuk mendefinisikan antarmuka Anda sendiri.

@FunctionalInterface
interface RiskyParser {
    int parse(String s) throws NumberFormatException;
}

public class Main {
    public static void main(String[] args) {
        RiskyParser p = Integer::parseInt;
        System.out.println(p.parse("77"));
    }
}

Meneruskan Antarmuka Kustom ke Metode

Antarmuka Anda menjadi tipe parameter, sehingga pemanggil dapat menyediakan perilaku melalui lambda.

@FunctionalInterface
interface IntCombiner {
    int combine(int a, int b);
}

public class Main {
    static int reduce(int[] arr, IntCombiner c) {
        int acc = arr[0];
        for (int i = 1; i < arr.length; i++) acc = c.combine(acc, arr[i]);
        return acc;
    }

    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4};
        System.out.println(reduce(data, (a, b) -> a + b));
    }
}

Antarmuka Tiga Argumen

JDK hanya menyediakan antarmuka dengan satu dan dua argumen. Untuk tiga argumen atau lebih, definisikan antarmuka Anda sendiri.

@FunctionalInterface
interface TriFunction<A, B, C, R> {
    R apply(A a, B b, C c);
}

public class Main {
    public static void main(String[] args) {
        TriFunction<Integer, Integer, Integer, Integer> sum3 = (a, b, c) -> a + b + c;
        System.out.println(sum3.apply(1, 2, 3));
    }
}

Referensi Metode Sesuai dengan Antarmuka Kustom

Metode apa pun yang tanda tangannya cocok dengan SAM dapat diberikan sebagai referensi metode.

@FunctionalInterface
interface StringTest {
    boolean check(String s);
}

public class Main {
    public static void main(String[] args) {
        StringTest blank = String::isBlank;
        System.out.println(blank.check("   "));
    }
}

Kelas Anonim vs Lambda

Lambda merupakan pengganti ringkas untuk kelas anonim yang mengimplementasikan antarmuka fungsional. Keduanya menghasilkan perilaku yang sama.

@FunctionalInterface
interface Action {
    void run();
}

public class Main {
    public static void main(String[] args) {
        Action old = new Action() {
            public void run() { System.out.println("anonymous"); }
        };
        Action neo = () -> System.out.println("lambda");
        old.run();
        neo.run();
    }
}

Pemeriksaan Singkat

Apa yang dijamin oleh @FunctionalInterface?

Ringkasan

Anda mendefinisikan antarmuka fungsional sendiri:

Antarmuka fungsional memiliki tepat satu metode abstrak (SAM).
@FunctionalInterface menegakkan aturan tersebut pada waktu kompilasi.
Metode bawaan dan statis, generik, serta pengecualian terperiksa semuanya diizinkan.
Antarmuka kustom mengisi kekurangan yang tidak dicakup JDK, seperti fungsi dengan tiga argumen atau lambda dengan pengecualian terperiksa.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Antarmuka Fungsional Kustom” gratis?

Ya — teks lengkap “Antarmuka Fungsional Kustom” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Antarmuka Fungsional Kustom”?

Definisikan antarmuka sendiri dengan @FunctionalInterface. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Antarmuka Fungsional Kustom” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy