أساسيات جافا

المعاملات والتعبيرات

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

المعاملات والتعبيرات

التعبير (expression) هو أي تركيب من متغيرات وقيم ومعاملات (operators) يُقيّمه Java لينتج قيمة واحدة. فهم المعاملات أمر جوهري لأن كل سطر مفيد تقريبًا في Java يحتوي على معامل واحد على الأقل. في هذا الدرس ستتعلم كل فئة من المعاملات، وترى مثالًا صغيرًا قابلًا للتشغيل، وتكتشف كيف يقرر Java أيّ عملية يؤدّي أولًا عند وجود عدة معاملات معًا.

معاملات الحساب (Arithmetic Operators)

تُجري معاملات الحساب عمليات رياضية على الأنواع الرقمية مثل int وdouble.

public class ArithmeticDemo {
    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 تعطي 3 لا 3.4. إذا أردت نتيجة عشرية فيجب أن يكون أحد المعاملَين من نوع double: 17.0 / 5 تعطي 3.4.

يُعيد معامل باقي القسمة % ما تبقّى بعد القسمة. وهو مفيد جدًا — التحقق من أن عددًا زوجي (n % 2 == 0)، والتدوير عبر مؤشرات المصفوفة، وغير ذلك كثير.

معاملات المقارنة (Relational Operators)

تقارن معاملات المقارنة بين قيمتين وتُنتج دائمًا نتيجة boolean (true أو false). وهي عماد كل جملة if وشرط حلقة.

int x = 10;
int y = 20;

System.out.println(x == y);  // false — يساوي
System.out.println(x != y);  // true  — لا يساوي
System.out.println(x <  y);  // true  — أصغر من
System.out.println(x >  y);  // false — أكبر من
System.out.println(x <= y);  // true  — أصغر من أو يساوي
System.out.println(x >= y);  // false — أكبر من أو يساوي

== مقابل = : علامة المساواة الواحدة = تُسنِد قيمة. علامة المساواة المزدوجة == تختبر التساوي. كتابة if (x = 5) بدلًا من if (x == 5) خطأ شائع — لحسن الحظ يرصده Java كخطأ في الترجمة للأنواع غير المنطقية.

المعاملات المنطقية (Logical Operators)

تجمع المعاملات المنطقية قيم boolean أو تعكسها. تستخدمها لبناء شروط مركّبة.

boolean isAdult = true;
boolean hasTicket = false;

// AND — يجب أن يكون كلاهما صحيحًا
System.out.println(isAdult && hasTicket);  // false

// OR  — يكفي أن يكون أحدهما صحيحًا
System.out.println(isAdult || hasTicket);  // true

// NOT — يعكس القيمة
System.out.println(!isAdult);             // false

يستخدم Java التقييم المختصر (short-circuit evaluation) مع && و||. مع &&: إذا كان الطرف الأيسر false فلا يُقيَّم الطرف الأيمن أبدًا. مع ||: إذا كان الطرف الأيسر true فيُتخطّى الطرف الأيمن. هذا مهم عندما يملك الطرف الأيمن تأثيرًا جانبيًا أو قد يُلقي استثناءً.

استخدم && للحماية من NullPointerException: if (user != null && user.isActive()) — بفضل التقييم المختصر، لا يُستدعى user.isActive() إلا عندما يكون user غير null.

معاملات الإسناد (Assignment Operators)

معامل الإسناد الأساسي = يخزّن قيمة في متغير. يوفّر Java أيضًا معاملات الإسناد المركّبة التي تجمع عملية حسابية مع الإسناد، مما يجعل الكود أقصر وأوضح.

int score = 100;

score += 10;   // score = score + 10  → 110
score -= 5;    // score = score - 5   → 105
score *= 2;    // score = score * 2   → 210
score /= 3;    // score = score / 3   → 70  (قسمة صحيحة)
score %= 8;    // score = score % 8   → 6

System.out.println(score);  // 6

معاملات الزيادة والنقصان (Increment & Decrement)

لأن إضافة أو طرح 1 شائع جدًا، يوفّر Java معاملَين مخصَّصَين: ++ (زيادة) و-- (نقصان). كل منهما بصيغتين: بادئة (prefix) (المعامل قبل المتغير) ولاحقة (postfix) (المعامل بعد المتغير).

int n = 5;

// لاحقة: استخدم القيمة الحالية أولًا ثم غيّرها
System.out.println(n++);  // يطبع 5، ثم يصبح n يساوي 6
System.out.println(n);    // 6

// بادئة: غيّر القيمة أولًا ثم استخدمها
System.out.println(++n);  // يصبح n يساوي 7، ثم يطبع 7
System.out.println(n);    // 7

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

أولوية المعاملات (Operator Precedence)

عند وجود عدة معاملات في تعبير واحد، يتّبع Java جدول الأولوية — مشابهًا لقاعدة الترتيب في الرياضيات (الضرب قبل الجمع). أهم القواعد التي يجب حفظها:

++ / -- (لاحقة)، ثم ++ / -- (بادئة)، !
* / %
+ -
< > <= >=
== !=
&&
||
= += -= وغيرها (الأدنى أولوية)

int result = 3 + 4 * 2;
// الضرب أولًا: 4 * 2 = 8، ثم 3 + 8 = 11
System.out.println(result);  // 11

result = (3 + 4) * 2;
// الأقواس تتجاوز الأولوية: 3 + 4 = 7، ثم 7 * 2 = 14
System.out.println(result);  // 14

عند الشك، استخدم الأقواس. لا تُكلّف شيئًا، وتوضّح نيّتك، وتمنع أخطاء الأولوية الخفية. كتابة (a > b) && (c != 0) أوضح من a > b && c != 0 رغم أنهما ينتجان النتيجة ذاتها.

الجمع بين المفاهيم

هذا برنامج صغير يجمع عدة معاملات لتحديد ما إذا كان الطالب قد نجح في الامتحان:

public class PassFail {
    public static void main(String[] args) {
        int score = 72;
        int minPass = 50;
        boolean attended = true;

        // شرط مركّب باستخدام معاملات المقارنة والمنطق
        boolean passed = attended && (score >= minPass);

        // إسناد مركّب لإضافة مكافأة
        if (passed) {
            score += 5;   // مكافأة على الحضور
        }

        System.out.println("Final score: " + score);   // 77
        System.out.println("Passed: " + passed);        // true
    }
}

الخلاصة

تنقسم معاملات Java إلى خمس مجموعات عملية: الحساب (+ - * / %)، المقارنة (== != < > <= >=)، المنطق (&& || !)، الإسناد (= += -= *= /= %=)، والزيادة والنقصان (++ --). تحدّد أولوية المعاملات ترتيب التقييم — استخدم الأقواس بسخاء لجعل التعبيرات واضحة. في الدرس القادم ستتعلم كيف يوسّع Java الأنواع أو يضيّقها تلقائيًا عند خلط الأنواع في تعبير واحد.