الواجهات والأصناف المجرّدة

مقدمة إلى الواجهات الدالية (Functional Interfaces)

15 دقيقة الدرس 7 من 14

مقدمة إلى الواجهات الدالية (Functional Interfaces)

تعلمت من قبل أن الواجهة تستطيع التصريح بتوابع مجردة تلتزم الفئات المُنفِّذة بتعريفها. الواجهة الدالية هي ببساطة واجهة تصرّح بتابع مجرد واحد بالضبط. هذا القيد الوحيد هو ما يجعلها مميزة: إذ يعني أنك تستطيع تمثيل الواجهة بأكملها بقطعة سلوك واحدة — دالة — ويستطيع Java استبدال تعبير لامبدا موجز في أي مكان يُتوقع فيه تلك الواجهة.

يتناول هذا الدرس المفهوم، والتوصيف @FunctionalInterface، ولماذا تُشكّل هذه الفكرة أساس كود Java الحديث.

قاعدة التابع المجرد الوحيد

انظر إلى هذه الواجهة:

public interface Transformer {
    String transform(String input);
}

تمتلك Transformer تابعًا مجردًا واحدًا بالضبط، مما يجعلها واجهة دالية. قبل Java 8 كنت تنفّذها بفئة مجهولة:

Transformer upper = new Transformer() {
    @Override
    public String transform(String input) {
        return input.toUpperCase();
    }
};

System.out.println(upper.transform("hello")); // HELLO

هذا يعمل، لكنه سبعة أسطر من الكود الزائد للتعبير عن فكرة واحدة: التحويل إلى أحرف كبيرة. تتيح الواجهة الدالية لـ Java اختصار ذلك كليًا.

التوصيف @FunctionalInterface

أضف @FunctionalInterface إلى أي واجهة تنوي الإبقاء عليها كنوع SAM (تابع مجرد وحيد):

@FunctionalInterface
public interface Transformer {
    String transform(String input);
}

ما يفعله التوصيف وما لا يفعله: @FunctionalInterface حارس وقت الترجمة، وليس تغييرًا في وقت التشغيل. إن أضفت عن طريق الخطأ تابعًا مجردًا ثانيًا يُبلّغ المُترجم فورًا عن خطأ: "Invalid '@FunctionalInterface' annotation; Transformer is not a functional interface". بدون التوصيف تظل الواجهة تعمل كواجهة دالية — التوصيف يجعل نيتك صريحة ومحمية فحسب.

التوابع الافتراضية، والتوابع الساكنة، والتوابع الموروثة من Object (مثل equals أو toString) لا تُحتسب توابع مجردة في هذه القاعدة. تستطيع الواجهة امتلاك ما تشاء منها وتبقى واجهة دالية صالحة:

@FunctionalInterface
public interface Transformer {
    String transform(String input);           // التابع المجرد الوحيد

    default Transformer andThen(Transformer after) {
        return input -> after.transform(this.transform(input));
    }

    static Transformer identity() {
        return input -> input;
    }
}

لماذا هذا مهم: الطريق إلى اللامبدا

الواجهة الدالية هي النوع الهدف الذي يستوفيه تعبير اللامبدا. لا يمتلك Java دوالًا مستقلة — كل قطعة سلوك يجب أن تعيش داخل فئة أو واجهة. الواجهات الدالية هي الآلية التي تُتيح وجود صياغة اللامبدا. حين يرى Java:

Transformer upper = input -> input.toUpperCase();

يتحقق: ما النوع المتوقع على اليسار؟ Transformer. هل تمتلك Transformer تابعًا مجردًا واحدًا بالضبط؟ نعم — String transform(String). هل يطابق اللامبدا تلك التوقيع (يأخذ String ويعيد String)؟ نعم. تنجح عملية الترجمة ويصبح اللامبدا تنفيذًا لـ transform.

فكّر في الواجهة الدالية كعقد واللامبدا كتنفيذ. الواجهة تُسمّي السلوك وتوثّقه؛ واللامبدا هي أقصر طريقة ممكنة لتوفير ذلك السلوك بشكل مضمّن.

الواجهات الدالية المدمجة في Java

تحتوي حزمة java.util.function على عشرات الواجهات الدالية الجاهزة، لذا نادرًا ما تحتاج إلى كتابة واجهتك الخاصة. الأربعة التي ستراها في كل مكان هي:

Function<T, R> — تأخذ T وتعيد R. التابع المجرد: R apply(T t).
Predicate<T> — تأخذ T وتعيد boolean. التابع المجرد: boolean test(T t).
Consumer<T> — تأخذ T ولا تعيد شيئًا. التابع المجرد: void accept(T t).
Supplier<T> — لا تأخذ شيئًا وتعيد T. التابع المجرد: T get().

إليك هذه الواجهات في العمل، جميعها تستخدم اللامبدا كتنفيذات:

import java.util.function.*;

Function<String, Integer>  length    = s -> s.length();
Predicate<String>          isEmpty   = s -> s.isEmpty();
Consumer<String>           printer   = s -> System.out.println(s);
Supplier<String>           greeting  = () -> "Hello, Java!";

System.out.println(length.apply("functional"));  // 10
System.out.println(isEmpty.test(""));            // true
printer.accept("printed by a Consumer");
System.out.println(greeting.get());             // Hello, Java!

تمرير السلوك كمعامل

تظهر القوة الحقيقية حين تقبل واجهة دالية كمعامل لتابع، مما يسمح للمستدعين بحقن أي سلوك يريدونه:

import java.util.function.Predicate;
import java.util.List;

public class Filter {
    public static List<String> keep(List<String> items, Predicate<String> condition) {
        return items.stream()
                    .filter(condition)
                    .toList();
    }
}

// المستدعي يقرر القاعدة — لا حاجة لفئة فرعية
List<String> words = List.of("apple", "fig", "banana", "kiwi");

List<String> longWords  = Filter.keep(words, s -> s.length() > 4);
List<String> startWithB = Filter.keep(words, s -> s.startsWith("b"));

System.out.println(longWords);   // [apple, banana]
System.out.println(startWithB);  // [banana]

لا يعرف تابع Filter.keep شيئًا عن القاعدة؛ المستدعي يوفّرها كلامبدا. هذا هو نمط الاستراتيجية (Strategy Pattern) معبَّرًا عنه بكلمتين بدلًا من تسلسل فئات.

لا تنشئ واجهات دالية مخصصة دون داعٍ. قبل كتابة واجهتك الخاصة، تحقق من java.util.function. تغطي Function وPredicate وConsumer وSupplier الغالبية العظمى من الحالات. إدخال أنواع مخصصة يضيف أسماء يجب على المتعاونين تعلّمها دون إضافة تعبيرية حقيقية.

الخلاصة

الواجهة الدالية تمتلك تابعًا مجردًا واحدًا بالضبط. يوثّق التوصيف @FunctionalInterface تلك النية ويضيف فحصًا في وقت الترجمة. لأنه لا يوجد سوى تابع مجرد واحد، يستطيع Java مطابقة تعبير اللامبدا معه تلقائيًا. تُقدّم حزمة java.util.function في Java المعجم المعياري (Function وPredicate وConsumer وSupplier) فنادرًا ما تكتب واجهتك الخاصة. في الدرس القادم سنتعمق في صياغة اللامبدا ونستكشف مراجع التوابع (Method References).