Antarmuka Fungsional

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Java di Coddy. Pelajaran 39 dari 87.

functional interface adalah interface yang memiliki tepat satu method abstrak. Batasan satu method ini membuat functional interface istimewa karena dapat diimplementasikan menggunakan ekspresi lambda, sehingga gaya penulisan kode menjadi lebih ringkas.

Java menyediakan anotasi @FunctionalInterface untuk secara eksplisit menandai sebuah interface sebagai fungsional. Meskipun opsional, anotasi ini membantu compiler menemukan error jika kamu tidak sengaja menambahkan method abstrak kedua:

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

Kamu bisa mengimplementasikan functional interface dengan cara tradisional menggunakan class, atau dengan lebih ringkas menggunakan ekspresi lambda:

// Implementasi tradisional
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Ekspresi lambda (jauh lebih singkat!)
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

Functional interface tetap dapat memiliki default method dan static method karena keduanya tidak dihitung dalam aturan satu abstract method. Package java.util.function Java menyediakan banyak functional interface bawaan seperti Predicate, Function, dan Consumer yang akan sering kamu temui saat bekerja dengan streams dan collections.

Tantangan

Mudah

Mari buat sistem transformasi string menggunakan antarmuka fungsional dan ekspresi lambda. Kamu akan membuat pemroses teks fleksibel yang dapat menerapkan berbagai transformasi pada string, semuanya menggunakan satu antarmuka fungsional.

Kamu akan mengatur kodemu dalam tiga file:

StringTransformer.java: Definisikan antarmuka fungsional yang merepresentasikan operasi transformasi string apa pun. Tandai dengan anotasi @FunctionalInterface untuk memastikan antarmuka ini tetap fungsional. Antarmukamu harus mendeklarasikan satu method abstrak bernama transform yang menerima String dan mengembalikan String.
TextProcessor.java: Buat class yang menggunakan antarmuka fungsionalmu untuk memproses teks. Class ini harus memiliki field untuk menyimpan StringTransformer dan constructor untuk menginisialisasinya. Sertakan method bernama process(String text) yang menerapkan transformer ke teks yang diberikan dan mengembalikan hasilnya. Desain ini memungkinkan kamu memasukkan perilaku transformasi apa pun melalui constructor.
Main.java: Satukan semuanya dengan membuat berbagai transformasi menggunakan ekspresi lambda. Kamu akan menerima dua input: string teks dan tipe operasi (upper, lower, atau reverse).
Berdasarkan tipe operasi, buat TextProcessor dengan lambda yang sesuai:
- upper: mengubah teks menjadi huruf besar
- lower: mengubah teks menjadi huruf kecil
- reverse: membalik teks (petunjuk: gunakan StringBuilder)
Lalu, panggil process() dengan teks input dan cetak hasilnya dalam format ini: Result: [transformed text]

Kamu akan menerima dua input: teks yang akan diubah (String) dan tipe operasi (String).

Perhatikan bahwa class TextProcessor yang sama dapat melakukan operasi yang sangat berbeda, bergantung pada lambda yang kamu berikan. Itulah keunggulan antarmuka fungsional!

Coba sendiri

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String operation = scanner.nextLine();
        
        TextProcessor processor;
        
        // TODO: Berdasarkan jenis operasi, buat TextProcessor dengan lambda yang sesuai:
        // - "upper": mengubah teks menjadi huruf kapital
        // - "lower": mengubah teks menjadi huruf kecil
        // - "reverse": membalik teks (petunjuk: gunakan StringBuilder)
        
        // TODO: Panggil process() dengan teks input dan cetak hasilnya
        // Format output: "Result: [transformed text]"
    }
}