Java Academy · Pelajaran

Functional Interface Tersuai

Tentukan milik Anda sendiri dengan @FunctionalInterface

Pelajaran 4 daripada 413 langkah

Functional Interface Tersuai ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Ciri Antara Muka Fungsian

Antara muka fungsian mempunyai tepat satu kaedah abstrak (SAM). Kaedah tunggal itu dilaksanakan oleh lambda.

Kaedah lalai dan statik tidak dikira dalam had 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 memberitahu pengkompil supaya menguatkuasakan peraturan satu kaedah abstrak. Jika anda secara tidak sengaja menambah kaedah 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));
    }
}

Sebab Anotasi Ini Membantu

Anotasi ini mendokumentasikan tujuan dan melindungi kontrak. Tanpanya, antara muka itu masih berfungsi sebagai antara muka fungsian, tetapi rakan sepasukan boleh merosakkannya dengan menambah kaedah abstrak yang 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"));
    }
}

Antara Muka Tersuai dengan Generik

Antara muka anda boleh menjadi generik, sama seperti antara muka terbina dalam.

@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);
    }
}

Kaedah Lalai Dibenarkan

Antara muka fungsian boleh mempunyai kaedah default. Kaedah ini menambah tingkah laku tanpa melanggar peraturan satu kaedah 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));
    }
}

Kaedah Statik Juga Dibenarkan

Kaedah statik boleh bertindak sebagai kilang, 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));
    }
}

Melemparkan Pengecualian Tersemak

Jika kaedah abstrak anda mengisytiharkan pengecualian tersemak, lambda boleh melemparkannya. Function terbina dalam tidak boleh berbuat demikian, dan itulah salah satu sebab untuk mentakrifkan antara muka 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"));
    }
}

Menghantar Antara Muka Tersuai kepada Kaedah

Antara muka anda menjadi jenis parameter, lalu membolehkan pemanggil membekalkan tingkah laku 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));
    }
}

Antara Muka Tiga Argumen

JDK hanya menyediakan antara muka dengan satu dan dua argumen. Untuk tiga argumen atau lebih, takrifkan antara muka 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));
    }
}

Rujukan Kaedah Sesuai dengan Antara Muka Tersuai

Sebarang kaedah yang tandatangannya sepadan dengan SAM boleh dibekalkan sebagai rujukan kaedah.

@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 Tanpa Nama berbanding Lambda

Lambda ialah pengganti ringkas bagi kelas tanpa nama yang melaksanakan antara muka fungsian. Kedua-duanya menghasilkan tingkah laku 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();
    }
}

Semakan Pantas

Apakah yang dijamin oleh @FunctionalInterface?

Jawab dalam pelajaran interaktif

Ringkasan

Anda mentakrifkan antara muka fungsian sendiri:

Antara muka fungsian mempunyai tepat satu kaedah abstrak (SAM).
@FunctionalInterface menguatkuasakan peraturan itu semasa kompilasi.
Kaedah lalai dan statik, generik serta pengecualian tersemak semuanya dibenarkan.
Antara muka tersuai mengisi kekurangan yang tidak diliputi oleh JDK, seperti fungsi tiga argumen atau lambda dengan pengecualian tersemak.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Functional Interface Tersuai” percuma?

Ya — teks penuh “Functional Interface Tersuai” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Functional Interface Tersuai”?

Tentukan milik Anda sendiri dengan @FunctionalInterface Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Functional Interface Tersuai” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy