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

ما الذي تفعله المعاملات

المعاملات هي الرموز التي تجمع القيم لحساب قيم جديدة. أنت تستخدمها بالفعل بشكل عفوي - + يجمع، و> يقارن - وتجمعها جافا في عدة عائلات: الحسابية والمقارنة والمنطقية والإسناد، إضافة إلى بعض المعاملات الخاصة مثل الزيادة والمعامل الثلاثي.

تأخذ معظم المعاملات قيمتين (واحدة قبل الرمز وأخرى بعده) وتنتج نتيجة. الحيلة تكمن في معرفة نوع تلك النتيجة والترتيب الذي تُطبّق به - وهنا بالضبط يتعثر المبتدئون.

المعاملات الحسابية

تعمل المعاملات الحسابية الخمسة على الأعداد: + و- و* و/ و% (الباقي).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (قسمة صحيحة!)
        System.out.println(a % b);   // 2  (الباقي)
    }
}

المعامل % هو الباقي بعد القسمة: الناتج 17 % 5 هو 2 لأن العدد 5 يدخل في 17 ثلاث مرات ويتبقى 2. إنه الأداة اليومية لاختبار القابلية للقسمة - فـ n % 2 == 0 هو الفحص المعتاد لـ «هل n زوجي؟».

لاحظ أيضاً أن + يقوم بدور مزدوج: مع الأعداد يجمع، لكن مع وجود String على أي من الطرفين فإنه يدمج النصوص.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

يُقرأ السطر الأول بالتسلسل من البداية إلى النهاية: "Total: " + 3 هو بالفعل سلسلة نصية، لذا يُضاف 4 كنص. ضع العملية الحسابية بين قوسين عندما تريد حسابها أولاً.

مزلق القسمة الصحيحة

هذه هي المفاجأة الأكثر شيوعاً على الإطلاق. عندما يكون كلا معاملَي / عددين صحيحين، تُجري جافا قسمة صحيحة وتُسقط الكسر - فهي لا تقرّب، بل تقتطع باتجاه الصفر.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2 وليس 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (يكفي double واحد)
        System.out.println((double) 5 / 2); // 2.5 (تحويل أحد المعاملَين)
    }
}

للحصول على نتيجة عشرية، اجعل أحد المعاملَين على الأقل من النوع double - إما بكتابته مع .0، أو بتحويل أحد الطرفين باستخدام (double). أما (double)(5 / 2) فإنه لا يفيد، لأن القسمة الصحيحة 5 / 2 قد حدثت بالفعل قبل التحويل؛ فعليك تحويل أحد المعاملَين، لا النتيجة.

معاملات المقارنة

تطرح معاملات المقارنة سؤالاً بنعم/لا وتُرجع قيمة boolean. وعددها ستة: == و!= و< و> و<= و>=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

انتبه للفرق بين = (الإسناد - «ضع هذه القيمة هنا») و== (المقارنة - «هل هما متساويان؟»). الخلط بينهما خطأ كلاسيكي.

تنبيه مهم: == يقارن مراجع الكائنات لا محتواها. وللسلاسل النصية، استخدم .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - كائنان مختلفان
        System.out.println(a.equals(b));   // true  - النص نفسه
    }
}

استخدم == مع الأنواع البدائية مثل int وboolean، واستخدم .equals() كلما قارنت محتوى كائنات مثل String.

المعاملات المنطقية

تجمع المعاملات المنطقية القيم المنطقية: && (و)، و|| (أو)، و! (نفي). بهذه الطريقة تعبّر عن شروط مثل «بالغ بما يكفي و يملك تذكرة».

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

يُجري && و|| تقييماً بالدائرة القصيرة: تتوقف جافا عن التقييم بمجرد أن تصبح الإجابة مؤكدة. مع &&، إذا كان الطرف الأول false فلن يُفحص الطرف الثاني أبداً؛ ومع ||، إذا كان الطرف الأول true فيُتخطّى الطرف الثاني. هذا ليس مجرد تحسين أداء - بل يمكنك الاعتماد عليه من أجل الأمان:

if (text != null && text.length() > 0) { ... }

إذا كان text يساوي null، فإن الطرف الأول يكون false ولا يُستدعى text.length() أبداً، مما يتجنّب حدوث NullPointerException. اعكس الترتيب وسينهار البرنامج.

الإسناد والزيادة

= يُسند، لكن جافا تملك أيضاً إسنادات مركّبة تدمج عملية مع الإسناد: += و-= و*= و/= و%=. أما ++ / -- فيضيفان أو يطرحان واحداً.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

يأتي ++ بصيغتين: اللاحقة (count++) تُرجع القيمة القديمة ثم تزيد؛ والسابقة (++count) تزيد أولاً ثم تُرجع القيمة الجديدة. لا يهم هذا الفرق إلا عندما تستخدم النتيجة ضمن التعبير نفسه:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // يطبع 5، ثم يصبح x يساوي 6
        System.out.println(++x);   // يصبح x يساوي 7، ويطبع 7
    }
}

عندما يكون ++ في سطر مستقل بذاته، لا فرق بين اللاحقة والسابقة - لذا فضّل الصيغة الأوضح قراءةً، ولا تحشر عمليات الزيادة داخل تعبيرات أكبر.

المعامل الثلاثي

المعامل الثلاثي condition ? a : b هو صيغة if/else مختصرة تنتج قيمة: إذا كان الشرط true فإنه يُقيَّم إلى a، وإلا إلى b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

يتألق في عمليات الإسناد القصيرة من نوع «هذا أو ذاك». قاوم تداخل المعاملات الثلاثية داخل بعضها - فهذا يصبح غير قابل للقراءة بسرعة، وصيغة if/else العادية أوضح.

الأسبقية والأقواس

تُطبّق المعاملات بترتيب ثابت، يشبه إلى حد كبير الرياضيات: * و/ و% ترتبط أقوى من + و-، اللذين يرتبطان أقوى من معاملات المقارنة، التي ترتبط أقوى من &&، ثم ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14 وليس 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

لست بحاجة إلى حفظ الجدول كاملاً. عندما يخلط تعبير بين العائلات أو تضطر إلى التوقف لاستنتاج الترتيب، أضف أقواساً - فهي لا تكلّف شيئاً وتجعل القصد واضحاً للقارئ التالي.

التالي: تحويل الأنواع (Casting)

عدد من المزالق هنا - القسمة الصحيحة، وخلط int مع double - يعود في جوهره إلى الأنواع. يُسمّى التحويل المتعمّد بين الأنواع العددية التحويل (Casting)، وهو موضوع الصفحة التالية.