معاملات الدوال في جافا: الوسائط والتمرير بالقيمة والإرجاع

المعاملات تتيح للدالة أن تستقبل مُدخلات

الدالة التي تفعل الشيء نفسه دائمًا محدودة. المعاملات هي المُدخلات التي تعلن عنها داخل قوسي الدالة كي تتمكن الدالة نفسها من العمل على قيم مختلفة في كل مرة تستدعيها فيها.

تذكر كل معامل مع نوعه واسمه. داخل جسم الدالة، يتصرف المعامل كأنه متغير محلي عادي يحمل بالفعل ما مرره المُستدعي.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name هو المعامل. أما "Sam" و"Alex" فهما الوسيطتان - القيمتان المحددتان المقدمتان عند الاستدعاء. تعريف واحد للدالة، ومخرجان مختلفان.

المعاملات مقابل الوسائط

تُستخدم هاتان الكلمتان بشكل فضفاض، لكن من المفيد إبقاء الفرق واضحًا:

• المعامل هو العنصر النائب في التعريف: String name.
• الوسيطة هي القيمة التي تمررها فعليًا: "Sam".

إذن void greet(String name) يعلن عن معامل، وgreet("Sam") يمرر وسيطة. عندما يقول أحدهم «هذه الدالة تأخذ معاملين»، فهو يقصد التعريف؛ وعندما يقول «مررت وسيطتين»، فهو يقصد الاستدعاء.

تعدد المعاملات

افصل بين المعاملات بفواصل، وأعطِ كلًا منها نوعه الخاص - لا يمكنك مشاركة نوع واحد بين معاملين كما قد تفعل في تعريف متغير:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

تُربط الوسائط بالمعاملات حسب الموضع بدقة، وليس حسب الاسم. يعمل describe("Sam", 30, true) لأن الترتيب يتطابق مع (String name, int age, boolean active). إذا بدّلت بين وسيطتين من أنواع متوافقة، تحصل على خطأ منطقي صامت وليس خطأ في الترجمة (compile) - لذا فإن الترتيب مهم.

من الأخطاء الشائعة كتابة int add(int a, b). كل معامل يحتاج إلى نوعه الخاص: int add(int a, int b).

إرجاع قيمة

المعاملات هي الطريقة التي تتدفق بها البيانات إلى الداخل؛ والقيمة المُرجَعة هي الطريقة التي تتدفق بها النتيجة إلى الخارج. أعلن عن نوع الإرجاع قبل اسم الدالة، واستخدم return لإعادة قيمة إلى المُستدعي:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // القيمة 3.0 تفرض القسمة بالفاصلة العائمة
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

يجب أن يتطابق نوع الإرجاع (double) مع ما تُرجِعه فعليًا عبر return. الدالة المُعلَنة بـ void لا تُرجِع شيئًا - ومع ذلك يمكنها استخدام return; المجرد للخروج مبكرًا، لكنها لا تستطيع إرجاع قيمة. في اللحظة التي يُنفَّذ فيها return، تنتهي الدالة ويعود التحكم إلى موضع الاستدعاء.

جافا تمرر بالقيمة

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

public class Main {
    static void tryToChange(int n) {
        n = 999;   // يغير هذه النسخة المحلية فقط
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // لا يزال 5
    }
}

تبقى x تساوي 5. عدّلت الدالة نسختها الخاصة من الرقم، لا الأصل.

تمرير الكائنات: لا يزال بالقيمة، لكن انتبه للمرجع

تبدو الكائنات استثناءً، لكنها ليست كذلك. ما يُنسَخ هو المرجع (السهم الذي يشير إلى الكائن)، وليس الكائن نفسه. لذا تشير الدالة إلى الكائن نفسه ويمكنها تعديله:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // يعدّل الكائن المشترك - مرئي للمُستدعي
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // يعيد إسناد النسخة المحلية فقط - غير مرئي
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // لا يزال [a, b, new] - إعادة الإسناد لم تخرج إلى الخارج
    }
}

نتيجتان مختلفتان، وقاعدة واحدة. تتبع addItem المرجع وتغير القائمة الفعلية، لذا يرى المُستدعي ظهور new. أما replace فتعيد إسناد المعامل إلى قائمة جديدة تمامًا - لكن ذلك يعيد توجيه النسخة المحلية من المرجع فقط، لذا تبقى قائمة list لدى المُستدعي دون تغيير. الخلاصة: يمكنك تغيير كائن عبر معامل، لكنك لا تستطيع أبدًا جعل متغير المُستدعي يشير إلى مكان جديد.

التالي: تحميل الدوال الزائد (Overloading)

أصبحت الآن تعرف كيف تزود الدالة بالمدخلات التي تحتاجها بالضبط. لكن ماذا لو أردت أن يقبل اسم دالة واحد مجموعات مختلفة من المعاملات - مثل print(int) وprint(String)؟ هذا هو تحميل الدوال الزائد، وهو موضوع الصفحة التالية.