٦٫١

الحلقة while: عدّ المحطات

تركب قطار الحرمين من المدينة المنورة، والمضيف يعلن اسم كل محطة تمرّ بها: نفس الإعلان يتكرر في كل محطة. كيف نقول لجافا «كرّر هذا العمل» بدل أن نكتبه عشرات المرات؟

قبل الأمثلة، هذه دورة حلقة while في صورة واحدة:

int count = 1; count <= 5 true System.out.println(count); count++; false ما بعد الحلقة التهيئة مرة واحدة قبل الحلقة الشرط يُفحص أولًا في كل مرة الجسم يُنفَّذ إذا صحّ الشرط التحديث يقرّب العدّاد من النهاية الخروج حين يصير الشرط خاطئًا
في WhileDemo: التهيئة int count = 1; مرة واحدة، ثم يُفحص الشرط count <= 5. إن كان true يُنفَّذ الجسم ثم التحديث count++ ونعود إلى الشرط. فيُطبع 1 إلى 5، وعندما يصير count يساوي 6 يصير الشرط false فنخرج. الشرط فُحص 6 مرات والجسم نُفِّذ 5 مرات.

انطلق القطار من محطة المدينة المنورة متجهًا إلى مكة المكرمة، ومضيف الرحلة يمسك الميكروفون: «وصلنا إلى محطة جديدة». سيعيد هذه الجملة في كل محطة. لو كتبنا البرنامج الذي يعلن خمس محطات بالطريقة التي نعرفها لكتبنا السطر نفسه خمس مرات:

FiveStations.java
public class FiveStations {    public static void main(String[] args) {        System.out.println("Next station!");        System.out.println("Next station!");        System.out.println("Next station!");        System.out.println("Next station!");        System.out.println("Next station!");    }}

يعمل البرنامج، لكن ماذا لو كانت الرحلة مئة محطة؟ أو لو لم نعرف عدد المحطات إلا أثناء التشغيل؟ نفس المشكلة تظهر عندما نريد جمع مئة رقم: كتابة n1 وn2 حتى n100 ليست حلًّا معقولًا. الحل هو الحلقة التكرارية (loop).

ما الحلقة؟

الحلقة جزء من البرنامج يكرر جملة أو مجموعة جمل. ولها ثلاثة عناصر نسمّيها بأسمائها لأننا سنتحدث عنها كثيرًا:

  • الجسم (body): الجملة أو الجمل التي تتكرر، وتكون عادةً بين قوسين { }.
  • الشرط (condition): تعبير منطقي true أو false يقرر هل نكرر مرة أخرى أم نخرج. هو «باب الخروج» من الحلقة.
  • العدّاد (counter): متغير نبدأه بقيمة ثم نغيّره في كل دورة حتى يصير الشرط خاطئًا يومًا ما.

في جافا ثلاثة أنواع من الحلقات: while وdo-while وfor. نبدأ في هذا الدرس بأبسطها: while.

بناء حلقة while

تبدأ الجملة بالكلمة while ثم الشرط بين قوسين، ثم الجسم:

while (condition) {
    statement1;
    statement2;
}

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

أول حلقة: العدّ من 1 إلى 5

هذا هو مثال المعمل الأول. المضيف يعدّ المحطات من 1 إلى 5:

WhileDemo.java
public class WhileDemo {    public static void main(String[] args) {        int count = 1;        while (count <= 5) {            System.out.println(count);            count++;        }    }}

اقرأ السطور بترتيب التنفيذ: السطر int count = 1; يُنفَّذ مرة واحدة فقط قبل الحلقة، فهو تهيئة العدّاد. بعده يُفحص count <= 5. ما دام صحيحًا يُطبع العدّاد، ثم يأتي السطر count++ وهو التحديث (update) الذي يقرّب الحلقة من نهايتها. المطبوع هو الأرقام 1 و2 و3 و4 و5 كلٌّ في سطر.

توقّع ثم جرّبغيّر سطر التحديث إلى count += 2 قبل أن تشغّل. ماذا سيُطبع؟ (سيُطبع 1 ثم 3 ثم 5: فالعدّاد يقفز بمقدار 2، فلا يصل إلى 6 أو 7 قبل أن يفشل الشرط عند 7.)

وهذه هي النسخة المعدّلة جاهزة للتشغيل. اطبع الأعداد الفردية فقط من 1 إلى 5 بتغيير التحديث وحده:

WhileStep2.java
public class WhileStep2 {    public static void main(String[] args) {        int count = 1;        while (count <= 5) {            System.out.println(count);            count += 2;        }    }}

تتبّع الحلقة خطوة بخطوة

أفضل طريقة لفهم أي حلقة أن تتبعها كما يفعل المترجم: جدول تكتب فيه قيمة العدّاد ونتيجة الشرط وما يُطبع في كل دورة. نتتبع هنا حلقة مختصرة تعدّ حتى 3. اضغط «التالي» وتوقّع الصف قبل أن يظهر:

count = 1; while (count <= 3) الدورة count الشرط المطبوع 1 1 1 <= 3 true 1 2 2 2 <= 3 true 2 3 3 3 <= 3 true 3 4 4 4 <= 3 false — count = 1 قبل أول فحص للشرط الشرط false: تنتهي الحلقة ويكمل البرنامج بعدها
قبل الحلقة: count يحمل 1. لم يُطبع شيء بعد. الدورة الأولى: 1 <= 3 صحيح، فيُطبع 1، ثم count++ يجعل count يساوي 2. الدورة الثانية: 2 <= 3 صحيح، فيُطبع 2، ثم يصير count يساوي 3. الدورة الثالثة: 3 <= 3 صحيح (المساواة تكفي)، فيُطبع 3، ثم يصير count يساوي 4. الفحص الرابع: 4 <= 3 خاطئ، فلا يدخل الجسم ولا يُطبع شيء، وتنتهي الحلقة.

توقّع: كم مرة سيُفحص الشرط حتى تنتهي الحلقة، وكم مرة سيُنفَّذ الجسم؟

تذكّرالشرط يُفحص مرة زيادة عن عدد مرات تنفيذ الجسم: ثلاث دورات تحتاج أربعة فحوص، آخرها هو الذي يفشل وينهي الحلقة. وعدد دورات الحلقة ليس بالضرورة آخر قيمة للعدّاد، فهنا انتهى العدّاد عند 4 لا عند 3.

المجموع التراكمي: sum

الحلقة تتألق عندما تجمع شيئًا. نحتاج متغيرًا اسمه sum يبدأ بالصفر ويستقبل شيئًا جديدًا في كل دورة، كأن المضيف يجمع أرقام المحطات التي مرّ بها القطار:

SumStations.java
public class SumStations {    public static void main(String[] args) {        int count = 1;        int sum = 0;        while (count <= 4) {            sum = sum + count;            count++;        }        System.out.println("Sum = " + sum);    }}

تتبع القيم: في الدورة الأولى sum يصير 1، ثم 3، ثم 6، ثم 10. فيُطبع Sum = 10. لاحظ أن sum يبدأ من 0 خارج الحلقة؛ لو وضعنا int sum = 0 داخل الجسم لعاد إلى الصفر في كل دورة ولضاع ما جمعناه.

فخ الصفرالمتغير الذي يتراكم فيه المجموع يُعرَّف ويُهيَّأ قبل الحلقة. وسطر التحديث count++ يجب أن يبقى داخل الجسم، وإلا لن يتقدم العدّاد.

الحلقة قد لا تُنفَّذ أبدًا

بما أن الشرط يُفحص أولًا، فإن كان خاطئًا منذ البداية تُتخطّى الحلقة بالكامل:

ZeroTimes.java
public class ZeroTimes {    public static void main(String[] args) {        int count = 6;        while (count <= 5) {            System.out.println(count);            count++;        }        System.out.println("Done");    }}

العدّاد يبدأ من 6 فالشرط 6 <= 5 خاطئ من أول فحص، فيُطبع Done فقط. وهذه ميزة while التي ستقارنها في الدرس القادم مع do-while.

العدّ التنازلي

العدّاد لا يلزم أن يصعد. قبل انطلاق القطار يعدّ المضيف تنازليًا، فنبدأ من 3 وننقص بـ count--:

Departure.java
public class Departure {    public static void main(String[] args) {        int count = 3;        while (count >= 1) {            System.out.println(count);            count--;        }        System.out.println("The train departs!");    }}

غيّرنا ثلاثة أشياء معًا: بداية كبيرة، وشرطًا بعلامة >=، وتحديثًا بالنقص. الاتجاه الذي يتحرك فيه العدّاد يجب أن يتفق مع الشرط، وإلا نقع في الفخ التالي.

الحلقة اللانهائية

الحلقة التي لا تتوقف أبدًا تسمى حلقة لانهائية (infinite loop)، وسببها أن الشرط لا يصير خاطئًا أبدًا. هذا خطأ منطقي يقع فيه كل مبتدئ. هذا مثال المعمل الثالث: الحلقة صحيحة لأن count++ يقرّب العدّاد من 5:

NoInfinite.java
public class NoInfinite {    public static void main(String[] args) {        int count = 0;        while (count < 5) {            System.out.println(count);            count++;        }    }}

سيطبع الأرقام من 0 إلى 4. والآن جرّب كما يقول المعمل: اضغط «✎ تعديل»، احذف سطر count++، ثم شغّل. العدّاد سيبقى صفرًا إلى الأبد، والشرط 0 < 5 صحيح دائمًا، فلا تنتهي الحلقة. لا تقلق: مشغّل الورشة يوقف الحلقة المنفلتة بعد عدد كبير من الدورات ويعرض رسالة تنبّهك، بخلاف برنامج حقيقي سيبقى يدور حتى توقفه بنفسك. بعد التجربة أعد السطر إلى مكانه.

وهناك طريقة أخرى للوقوع في الفخ ذاته، وهي أن يتحرك العدّاد في الاتجاه المعاكس للشرط:

int count = 0;
while (count < 5) {
    System.out.println(count);
    count--;      // 0, -1, -2, ... never reaches 5
}

العدّاد ينزل إلى -1 ثم -2 وهكذا، فيبقى أصغر من 5 دائمًا (وفي جافا الحقيقية قد يلتف العدّاد بعد نحو ملياري دورة فتنتهي الحلقة، لكننا نعدّها لانهائية عمليًا). القاعدة العملية: عند كتابة أي حلقة اسأل نفسك «أي سطر في الجسم يقرّب الشرط من أن يصير خاطئًا؟».

توقّف وفكّرلو كان المضيف يعدّ int count = 1; while (count <= 5) وكتبنا count += 0 في التحديث، فماذا يحدث؟
اكشف الإجابة حلقة لانهائية؛ لأن العدّاد لا يتغير فلا يصل إلى 6 أبدًا. أي تحديث لا يقرّب العدّاد من حدّ الشرط يصنع الخلل نفسه.

ملخص الدرس

  • حلقة while: تفحص الشرط أولًا، ثم تنفّذ الجسم إن كان صحيحًا، وتكرّر.
  • ثلاثة أسطر تحكم الحلقة: التهيئة قبلها، والشرط في رأسها، والتحديث داخل جسمها.
  • المجموع التراكمي (sum) يبدأ من الصفر قبل الحلقة ويستقبل قيمة في كل دورة.
  • قد تُنفَّذ الحلقة صفر مرة إن كان الشرط خاطئًا من البداية.
  • غياب التحديث، أو تحديثه في الاتجاه الخطأ، يصنع حلقة لانهائية.
اختبر نفسك · +5 نقاط
ما الذي تطبعه هذه الحلقة؟
int n = 1;
while (n <= 3) {
    System.out.print(n + " ");
    n++;
}
اختبر نفسك ٢، حتى +5 نقاط
ماذا يحدث عند تشغيل هذا الكود؟
int count = 0;
while (count < 5) {
    System.out.println(count);
    count--;
}
اختبر نفسك ٣، حتى +5 نقاط
ما قيمة sum المطبوعة؟
int sum = 0;
int i = 1;
while (i <= 4) {
    sum += i;
    i++;
}
System.out.println(sum);
٦٫٢

الحلقة do-while: ماكينة التذاكر

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

قبل الأمثلة، تابع ما يحدث في do-while عندما يكون الشرط خاطئًا من البداية:

int number = 6; do { System.out.println(number); number++; } while (number <= 5) ; number 6 7 المطبوع 6 لم يُفحص الشرط بعد 7 <= 5 false تنتهي الحلقة
number يبدأ بـ 6. في while كان الشرط سيُفحص الآن، أما do-while فتدخل الجسم مباشرة. الجسم يُنفَّذ قبل أي فحص: يُطبع 6، ثم number++ يجعل number يساوي 7. الآن فقط يُفحص الشرط 7 <= 5: خاطئ، فتنتهي الحلقة بعد دورة واحدة. ولاحظ ; بعد الشرط. نسخة while بالبداية نفسها لا تطبع شيئًا.

وصلت إلى المحطة ووقفت أمام ماكينة التذاكر. الماكينة لا تستطيع أن تفحص جوابك قبل أن تسأل، فلا بد أن تعرض السؤال مرة واحدة على الأقل، ثم تقرر: هل الجواب صالح؟ إن لم يكن تعيد السؤال. هذا السلوك لا تعطيه حلقة while لأنها تفحص أولًا. الحل هو حلقة do-while.

بناء حلقة do-while

do {
    statement1;
    statement2;
} while (condition);

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

S1;
while (condition)
    S1;
لا تنسَ الفاصلة المنقوطةفي do-while فقط تُكتب ; بعد while (condition). نسيانها يمنع الترجمة. أما while العادية فلا تُكتب بعد شرطها فاصلة منقوطة أبدًا.
while do-while فحص الشرط الجسم true false خروج الجسم فحص الشرط true false خروج الفحص أولًا: قد لا يُنفَّذ الجسم الجسم أولًا: يُنفَّذ مرة على الأقل
الفرق كله في ترتيب الخطوتين: while تسأل ثم تعمل، وdo-while تعمل ثم تسأل

مثال المعمل: أكمل الشرط

في المعمل برنامج ينقصه الشرط ويطلب منك أن يطبع 1 إلى 5:

int number = 1;
do {
    System.out.println(number);
    number++;
} while (number <= ____ );

الشرط يجب أن يبقى صحيحًا ما دام number لم يتجاوز 5، فالرقم الناقص هو 5:

DoWhileDemo.java
public class DoWhileDemo {    public static void main(String[] args) {        int number = 1;        do {            System.out.println(number);            number++;        } while (number <= 5);    }}

المطبوع هو 1 و2 و3 و4 و5 كل رقم في سطر. تتبع الدورة الأخيرة: يطبع 5، ثم يصير number يساوي 6، فيفشل الشرط 6 <= 5 وتنتهي الحلقة.

الفرق الحقيقي: ابدأ من 6

الآن نفّذ ما طلبه المعمل: ابدأ من 6 وقارن مع while. هذا هو do-while:

DoWhileFrom6.java
public class DoWhileFrom6 {    public static void main(String[] args) {        int number = 6;        do {            System.out.println(number);            number++;        } while (number <= 5);    }}

يطبع 6 مرة واحدة رغم أن الشرط خاطئ من البداية! أما نسخة while بالقيمة نفسها (انظر ZeroTimes في الدرس ٦٫١) فلا تطبع شيئًا.

الميزةwhiledo-while
متى يُفحص الشرط؟قبل الجسمبعد الجسم
أقل عدد دوراتصفرواحدة
الفاصلة المنقوطة بعد الشرطلانعم
الاستعمال المناسبقد لا نحتاج الدورة أصلًانحتاجها مرة على الأقل

++ و -- داخل الحلقات

العدّاد يتغير في كل دورة تقريبًا، وكتابة i = i + 1 طويلة، فلغة جافا تعطينا اختصارات نستعملها داخل الحلقات كل يوم:

الجملةتعنيمثال
i++i = i + 1العدّ التصاعدي بخطوة واحدة
i--i = i - 1العدّ التنازلي
i += 2i = i + 2القفز بمقدار 2 (الأعداد الزوجية)
i -= 3i = i - 3النقصان بمقدار 3

مثال عليها مع do-while: ماكينة التذاكر تعرض المقاعد المتبقية وتنقصها بعد كل تذكرة. نقصان واحد ثلاث مرات:

SeatsLeft.java
public class SeatsLeft {    public static void main(String[] args) {        int seats = 3;        do {            System.out.println("Seats left: " + seats);            seats--;        } while (seats > 0);    }}

المطبوع Seats left: 3 ثم 2 ثم 1. وعندما ينزل العدّاد إلى 0 يفشل الشرط 0 > 0 فتتوقف الحلقة. قارن هذا بتمرين العدّ التنازلي في المعمل، فهو يستعمل البنية نفسها.

ماكينة التذاكر: كرّر السؤال حتى يصح الجواب

هذا هو الاستعمال الذي صُنعت له do-while. الماكينة تطلب عدد التذاكر (من 1 إلى 4) وتعيد الطلب ما دام الجواب خارج هذا المدى. اقرأ الشرط بعناية: نكرر إن كان العدد أقل من 1 أو أكبر من 4:

TicketMachine.java
import java.util.Scanner;public class TicketMachine {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int tickets;        do {            System.out.println("How many tickets (1-4)?");            tickets = sc.nextInt();        } while (tickets < 1 || tickets > 4);        System.out.println("Booked " + tickets + " tickets");    }}

جرّبه بالإدخالات 9 ثم 0 ثم 3: السؤال يُعرض ثلاث مرات؛ الأول والثاني مرفوضان لأنهما خارج المدى، والثالث مقبول فيُطبع Booked 3 tickets. لاحظ أن tickets عُرّف قبل الحلقة لأن الشرط الذي بعد الجسم يحتاج أن يراه (المتغير المعرَّف داخل الأقواس لا يُرى خارجها).

قيمة الحراسة: ادخل أرقامًا حتى الصفر

نوع آخر من التكرار: لا نعرف كم رقمًا سيدخل المستخدم، فنتفق معه على رقم خاص يعني «انتهيت»، ونسميه قيمة الحراسة (sentinel). هنا الصفر. موظف الشباك يسجّل عدد التذاكر المباعة في كل عملية حتى يدخل 0:

TicketSum.java
import java.util.Scanner;public class TicketSum {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        int total = 0;        int n;        do {            System.out.println("Tickets sold (0 to stop):");            n = sc.nextInt();            total += n;        } while (n != 0);        System.out.println("Total = " + total);    }}

الإدخالات 5 و3 و4 ثم 0 تعطي Total = 12. الصفر نفسه يُضاف إلى المجموع لكنه لا يغيّره. وهذه الصورة هي ما يطلبه التحدي الاختياري في المعمل (دون حساب المجموع).

توقّف وفكّرلماذا لا تصلح while العادية هنا دون حيلة إضافية؟
اكشف الإجابة لأن الشرط n != 0 يحتاج قيمة n قبل أول فحص، وقيمتها لا تُقرأ إلا داخل الجسم. do-while تقرأ أولًا ثم تفحص فتحلّ المشكلة بطبيعتها.
متى نستعمل do-while؟فقط عندما تكون متأكدًا أن الجسم يجب أن يُنفَّذ مرة على الأقل مهما كانت المدخلات، كالسؤال الأول للماكينة. وإن كان الجسم قد لا يُنفَّذ أبدًا فاستعمل while أو for.

ملخص الدرس

  • do { ... } while (cond);: الجسم ثم الفحص، فهو يُنفَّذ مرة على الأقل، ولا تنسَ الفاصلة المنقوطة.
  • إذا بدأ الشرط خاطئًا: while لا تدخل أبدًا، وdo-while تدخل مرة واحدة.
  • ++ و-- و+= و-= هي اختصارات التحديث في الحلقات.
  • التحقق من المدخلات وقيمة الحراسة (الصفر) هما أشهر استعمالين لحلقة do-while.
اختبر نفسك · +5 نقاط
ما الذي يطبعه هذا الكود؟
int number = 6;
do {
    System.out.println(number);
    number++;
} while (number <= 5);
اختبر نفسك ٢، حتى +5 نقاط
أي عبارة صحيحة عن حلقة do-while؟
اختبر نفسك ٣، حتى +5 نقاط
ما قيمة total المطبوعة إذا أدخل المستخدم 5 ثم 3 ثم 0؟
int total = 0;
int n;
do {
    n = sc.nextInt();
    total += n;
} while (n != 0);
System.out.println(total);
٦٫٣

الحلقة for: لوحة الرحلات

لوحة الرحلات في محطة قطار الحرمين تعدّد الرحلات واحدة بعد أخرى: الرحلة 1، ثم 2، ثم 3... عدد معروف من المرات وعدّاد يتقدم بانتظام. هذه مهمة الحلقة for.

قبل الأمثلة، هذه أجزاء رأس for وترتيب تنفيذها:

for ( int i = 1 ; i <= 5 ; i++ ) { System.out.println(i); } ١ ٢ ٤ ٣ التهيئة ١ مرة واحدة فقط الشرط ٢ خاطئ؟ نخرج الجسم ٣ إن صحّ الشرط التحديث ٤ ثم نعود إلى ٢ تتكرر الخطوات ٢ و٣ و٤ ما دام الشرط صحيحًا
في ForDemo تجتمع الأجزاء الثلاثة في سطر واحد تفصل بينها ;: التهيئة int i = 1 أولًا ومرة واحدة، ثم الشرط i <= 5، ثم الجسم، ثم التحديث i++ ونعود إلى الشرط. فيُطبع 1 إلى 5.

في الدرسين السابقين وزّعنا حلقة العدّ على ثلاثة أماكن متفرقة: التهيئة قبل الحلقة، والشرط في رأسها، والتحديث في آخر الجسم. وإن نسينا واحدًا منها وقعنا في الفخ. حلقة for تجمع الأجزاء الثلاثة في سطر واحد، فهي الخيار الأول حين نعرف عدد التكرارات مسبقًا أو حين يتغير العدّاد بمقدار منتظم.

بناء حلقة for

for (initialization; condition; update) {
    body statements;
}

الأجزاء الثلاثة بين القوسين تفصل بينها فاصلتان منقوطتان:

  • التهيئة (initialization): تُنفَّذ مرة واحدة في البداية، وغالبًا تعرّف العدّاد: int i = 1.
  • الشرط (condition): يُفحص قبل كل دورة، مثل while تمامًا؛ إن كان خاطئًا انتهت الحلقة.
  • التحديث (update): يُنفَّذ بعد كل دورة وقبل الفحص التالي: i++.

ترتيب التنفيذ: (١) التهيئة مرة واحدة، (٢) فحص الشرط، (٣) إن صح يُنفَّذ الجسم، (٤) ينفَّذ التحديث ثم نعود إلى (٢). وهي تكافئ هذه الحلقة while:

initialization;
while (condition) {
    body statements;
    update;
}

مثال المعمل: العدّ من 1 إلى 5

ForDemo.java
public class ForDemo {    public static void main(String[] args) {        for (int i = 1; i <= 5; i++) {            System.out.println(i);        }    }}

قارنه بحلقة WhileDemo في الدرس ٦٫١: نفس الناتج 1 إلى 5، لكن العدّاد والشرط والتحديث تجتمع في سطر واحد فلا تضيع منها واحدة. يطلب المعمل الآن تعديل الحلقة لتطبع 2 و4 و6 و8 و10. الفكرة: ابدأ من 2 وزِد بمقدار 2:

ForEven.java
public class ForEven {    public static void main(String[] args) {        for (int i = 2; i <= 10; i += 2) {            System.out.println(i);        }    }}
جرّباجعل الحلقة تعدّ تنازليًا من 5 إلى 1 بتغيير الأجزاء الثلاثة: التهيئة int i = 5 والشرط i >= 1 والتحديث i--. الأجزاء الثلاثة تتغير معًا دائمًا.

لوحة الرحلات

لنصنع اللوحة: كل رحلة تغادر بعد الأخرى بساعة. العدّاد trip يمثل رقم الرحلة ويدخل في حساب موعدها:

DepartureBoard.java
public class DepartureBoard {    public static void main(String[] args) {        for (int trip = 1; trip <= 4; trip++) {            System.out.println("Trip " + trip + " departs at " + (5 + trip) + ":00");        }    }}

الرحلة الأولى تغادر في 6:00 والرابعة في 9:00. وإن أردنا لوحة بعشرين رحلة غيّرنا الرقم 4 وحده.

جدول الضرب: ثمن التذاكر

تذكرة القطار في قصتنا بسعر 40 ريالًا (رقم افتراضي للتمرين). نريد جدولًا بسعر 1 إلى 5 تذاكر:

FareTable.java
public class FareTable {    public static void main(String[] args) {        int fare = 40;        for (int tickets = 1; tickets <= 5; tickets++) {            System.out.println(tickets + " x " + fare + " = " + (tickets * fare));        }    }}

هذه هي الفكرة التي يطلبها تمرين جدول الضرب في المعمل، لكن هناك يُقرأ العدد من المستخدم بدل أن يكون 40 ثابتًا.

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

نجمع هنا مربعات الأعداد 1 إلى 5: n * n في كل دورة:

SumSquares.java
public class SumSquares {    public static void main(String[] args) {        int sum = 0;        for (int n = 1; n <= 5; n++) {            sum = sum + n * n;        }        System.out.println("Sum of squares = " + sum);    }}

الناتج Sum of squares = 55 لأن 1 + 4 + 9 + 16 + 25 = 55. ولاحظ الفرق بين المتغيرين: sum عُرّف قبل الحلقة فيعيش بعدها ونطبعه، أما n فعُرّف داخل رأس for فهو محلي للحلقة (local to the loop): يموت مع آخر قوس لها.

for (int i = 0; i < 3; i++) {
    System.out.println(i);
}
System.out.println(i);   // error: i is not defined here

السطر الأخير خطأ في الترجمة لأن i لا وجود له خارج الحلقة. القاعدة: المتغير الذي يخدم الحلقة وحدها نعرّفه في رأس for، وما نريد قراءته بعد الحلقة (مثل المجموع) نعرّفه قبلها.

حذف أجزاء من رأس for

كل جزء من الأجزاء الثلاثة اختياري، فإن حذفنا واحدًا ظل الفاصل ; مكانه وتحمّلنا العاقبة:

الجزء المحذوفالنتيجة
التهيئةقد لا يوجد عدّاد أصلًا؛ إما أن يكون معرّفًا قبل الحلقة أو لا نحتاجه.
الشرطيُعدّ دائمًا صحيحًا، فتصير الحلقة لانهائية ما لم نخرج منها بجملة break.
التحديثالعدّاد يبقى على قيمته؛ نكتب التحديث بأنفسنا داخل الجسم وإلا لانهائية.

مثال على حذف التهيئة والتحديث معًا؛ العدّاد معرَّف قبل الحلقة ويتحدث داخل الجسم، وتصير الحلقة مثل while تمامًا:

OmitParts.java
public class OmitParts {    public static void main(String[] args) {        int i = 1;        for (; i <= 3; ) {            System.out.println("Stop " + i);            i++;        }    }}

أما الشكل for (;;) بلا أي جزء فهو حلقة لانهائية صريحة، ولا نخرج منها إلا بـ break وهو موضوع الدرس ٦٫٤.

خطأ الواحد (off-by-one)من أشهر أخطاء الحلقات أن تدور مرة أكثر أو أقل مما نريد، لأن الفرق بين < و<= هو دورة كاملة. للعدّ من 1 إلى n استعمل i <= n؛ وإن بدأت من 0 فاستعمل i < n. تتبّع آخر دورة بيدك قبل أن تطمئن.
فاصلة منقوطة تقتل الحلقةكتابة ; مباشرة بعد قوس for: for (int i = 1; i <= 3; i++); تجعل جسم الحلقة فارغًا. تدور الحلقة ثلاث دورات دون عمل، ثم يُنفَّذ السطر التالي مرة واحدة فقط، وكأنه خارج الحلقة. ستراه في لعبة «أين الخطأ؟».

أي حلقة أختار؟

الحلقةمتى أستعملها
forنعرف عدد التكرارات أو يتغير العدّاد بمقدار منتظم.
whileنكرر حتى يتحقق شرط، وقد لا نحتاج الدورة أصلًا.
do-whileنحتاج الدورة مرة على الأقل (سؤال أول، تحقق من إدخال).

ملخص الدرس

  • for (init; cond; update): التهيئة مرة واحدة، ثم الشرط قبل كل دورة، والتحديث بعد كل دورة.
  • تكافئ حلقة while: التهيئة قبلها، والتحديث في آخر جسمها.
  • متغير العدّاد المعرَّف في رأس for لا يُرى خارج الحلقة.
  • حذف الشرط يصنع حلقة لانهائية، وحذف التحديث يجمّد العدّاد.
  • فاصلة منقوطة بعد قوس for تفرّغ الجسم من محتواه.
اختبر نفسك · +5 نقاط
ما الذي تطبعه هذه الحلقة؟
for (int i = 1; i <= 10; i += 3) {
    System.out.print(i + " ");
}
اختبر نفسك ٢، حتى +5 نقاط
ماذا يحدث عند ترجمة هذا الكود؟
for (int i = 0; i < 3; i++) {
    System.out.println(i);
}
System.out.println(i);
اختبر نفسك ٣، حتى +5 نقاط
ما قيمة sum المطبوعة؟
int sum = 0;
for (int n = 1; n <= 3; n++) {
    sum = sum + n * n;
}
System.out.println(sum);
٦٫٤

الحلقات المتداخلة وbreak وcontinue: العربات والمقاعد

في القطار عربات، وفي كل عربة صفوف من المقاعد. للمرور على كل المقاعد نحتاج حلقة داخل حلقة. ثم نتعلم كيف نوقف البحث عند أول مقعد فارغ (break) وكيف نتخطى المقاعد المحجوزة (continue).

قبل الأمثلة، هذه فكرة الحلقة داخل الحلقة في صورة:

for (int carriage = 1; carriage <= 2; carriage++) { for (int seat = 1; seat <= 3; seat++) { System.out.print("C" + carriage + "-S" + seat + " "); } System.out.println(); } الخارجية الداخلية seat = 1 seat = 2 seat = 3 carriage = 1 C1-S1 C1-S2 C1-S3 carriage = 2 C2-S1 C2-S2 C2-S3 كل دورة من الخارجية عربة، وفيها تدور الداخلية ٣ دورات: ٢ × ٣ = ٦ مقاعد
في Seats: الحلقة الخارجية تعدّ العربات (carriage) والداخلية تعدّ المقاعد (seat). في كل عربة تكمل الداخلية مقاعدها الثلاثة ثم ينزل println() إلى سطر جديد.

وهذا الفرق بين break وcontinue في صورة:

break أول مقعد فارغ يكفي: نتوقف عن البحث 1 محجوز 2 محجوز 3 محجوز 4 فارغ 5 6 7 8 break لا تُفحص أبدًا continue نتخطى المقعدين ٣ و٦ ونكمل 1 2 3 تُتخطّى 4 5 6 تُتخطّى 7 S1 S2 S4 S5 S7 المطبوع
في FirstEmptySeat تُنهي break الحلقة كلها عند أول مقعد فارغ (4)، فلا تُفحص المقاعد بعده. وفي SkipReserved تتخطى continue الدورة الحالية فقط (المقعدان 3 و6) وتكمل الحلقة.

حلقة داخل حلقة

جسم الحلقة يمكن أن يحتوي أي جمل، ومنها حلقة أخرى. تسمى الحلقة الموجودة في الداخل الحلقة الداخلية (inner loop)، والتي تحتويها الحلقة الخارجية (outer loop). القاعدة الذهبية: الداخلية تكمل دورتها كاملة في كل دورة واحدة من الخارجية. فالمضيف الذي يمر على 3 عربات، وفي كل عربة يفحص 4 مقاعد، يفحص 12 مقعدًا في المجموع.

for (outer init; outer condition; outer update) {
    for (inner init; inner condition; inner update) {
        inner body;
    }
}

مثال المعمل: مستطيل من النجوم

الحلقة الخارجية تعدّ الصفوف، والداخلية تعدّ الأعمدة في كل صف. بعد انتهاء الداخلية نطبع println() فارغة للانتقال إلى سطر جديد:

NestedLoopDemo.java
public class NestedLoopDemo {    public static void main(String[] args) {        for (int row = 1; row <= 3; row++) {            for (int col = 1; col <= 4; col++) {                System.out.print("* ");            }            System.out.println();        }    }}

الناتج ثلاثة أسطر، في كل سطر أربع نجمات. تتبّعه في الشكل التالي لترى كيف تمتلئ الشبكة صفًّا صفًّا:

for row for col print * col = 1 col = 2 col = 3 col = 4 row = 1 row = 2 row = 3 * * * * * * * * * * * * 12 خلية = 3 صفوف × 4 أعمدة
الحلقة الخارجية تبدأ بـ row = 1، والداخلية تبدأ بـ col = 1 فتطبع أول نجمة. الداخلية تكمل دورتها كلها (col من 1 إلى 4) قبل أن يتحرك الصف: أربع نجمات، ثم println() تنزل إلى سطر جديد. الخارجية تتقدم إلى row = 2، والداخلية تبدأ من جديد من col = 1. الصف الثاني امتلأ بأعمدته الأربعة بالطريقة نفسها. الصف الثالث يمتلئ، ثم يفشل شرط الخارجية row <= 3 وينتهي البرنامج. عدد مرات تنفيذ الجسم الداخلي = 3 × 4.

توقّع: كم مرة يُنفَّذ سطر الطباعة System.out.print("* ") في المجموع؟

يطلب المعمل بعدها تغيير الصفوف إلى 2 والأعمدة إلى 5. نغيّر الحدّين في الشرطين فقط:

NestedLoop2x5.java
public class NestedLoop2x5 {    public static void main(String[] args) {        for (int row = 1; row <= 2; row++) {            for (int col = 1; col <= 5; col++) {                System.out.print("* ");            }            System.out.println();        }    }}

مثلث الأرقام: الداخلية تعتمد على الخارجية

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

NumberTriangle.java
public class NumberTriangle {    public static void main(String[] args) {        for (int row = 1; row <= 4; row++) {            for (int col = 1; col <= row; col++) {                System.out.print(row + " ");            }            System.out.println();        }    }}

الناتج: سطر فيه 1، ثم 2 2، ثم 3 3 3، ثم 4 4 4 4. في الصف 1 تدور الداخلية مرة واحدة لأن col <= 1، وفي الصف 4 تدور أربع مرات.

عربات ومقاعد: ترقيم المقاعد

متغيرا الحلقتين معًا يعطيان «عنوان» كل مقعد: رقم العربة ورقم المقعد داخلها:

Seats.java
public class Seats {    public static void main(String[] args) {        for (int carriage = 1; carriage <= 2; carriage++) {            for (int seat = 1; seat <= 3; seat++) {                System.out.print("C" + carriage + "-S" + seat + " ");            }            System.out.println();        }    }}

التداخل مع while و do-while

التداخل ليس حكرًا على for؛ أي حلقتين تتداخلان. الشرط الذي يجب أن تتذكره مع while: عدّاد الداخلية يُعاد تهيئته (col = 1) داخل الخارجية في كل دورة، وإلا بقي من الدورة السابقة وفشلت الداخلية في الصف الثاني:

NestedWhile.java
public class NestedWhile {    public static void main(String[] args) {        int row = 1;        while (row <= 2) {            int col = 1;            while (col <= 3) {                System.out.print(row * col + " ");                col++;            }            System.out.println();            row++;        }    }}

وهذه الفكرة نفسها بحلقة do-while داخلية، مع ملاحظة الفاصلة المنقوطة بعد شرطها:

NestedDoWhile.java
public class NestedDoWhile {    public static void main(String[] args) {        for (int row = 1; row <= 2; row++) {            int col = 1;            do {                System.out.print(row * col + " ");                col++;            } while (col <= 3);            System.out.println();        }    }}
عدّادان لا عدّاد واحدلكل حلقة متغيرها الخاص: row وcol. لو استعملت اسمًا واحدًا للاثنتين لأفسدت إحداهما عدّاد الأخرى.

break: أوقف الحلقة فورًا

الجملة break تنهي الحلقة التي هي فيها مباشرة، ويكمل البرنامج بما بعد الحلقة. تذكّر أنها تنهي الحلقة الأقرب (الداخلية) فقط. أول سطر في مثال المعمل الثالث يعدّ من 0 لكنه يتوقف عند 4:

BreakContinue.java
public class BreakContinue {    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            if (i == 4)                break;            System.out.print(i + " ");        }        System.out.println();        for (int i = 0; i < 6; i++) {            if (i == 2)                continue;            System.out.print(i + " ");        }    }}

قبل أن تشغّل توقّع السطرين، ثم اكشف الناتج لتقارن:

اكشف الناتج الأول: عندما يصير i يساوي 4 تُنفَّذ break قبل الطباعة فتنتهي الحلقة، فيُطبع 0 1 2 3. الثاني: continue تنهي الدورة الحالية فقط وتنتقل إلى الدورة التالية، فيُتخطى الرقم 2 ويُطبع 0 1 3 4 5.

وbreak تعمل في أي حلقة، ومنها while:

WhileBreak.java
public class WhileBreak {    public static void main(String[] args) {        int count = 0;        while (count < 10) {            if (count == 4)                break;            System.out.print(count + " ");            count++;        }    }}

يُطبع 0 1 2 3 وتنتهي الحلقة عند 4 رغم أن الشرط count < 10 ما زال صحيحًا.

في القطار: أمين العربة يمرّ على المقاعد وأول مقعد فارغ يجده يكفيه، فيتوقف عن البحث. نفترض أن المقاعد 1 إلى 3 محجوزة:

FirstEmptySeat.java
public class FirstEmptySeat {    public static void main(String[] args) {        for (int seat = 1; seat <= 8; seat++) {            boolean booked = seat < 4;            if (booked) {                System.out.println("Seat " + seat + " is taken");            } else {                System.out.println("Seat " + seat + " is free");                break;            }        }    }}

يفحص المقاعد 1 و2 و3 (محجوزة) ثم يجد المقعد 4 فارغًا فيطبع ذلك ويخرج، فلا يفحص المقاعد 5 إلى 8 أبدًا.

continue: تخطَّ هذه الدورة فقط

بعض المقاعد محجوزة مسبقًا لكبار الشخصيات (المقعدان 3 و6) ونريد طباعة بقية المقاعد المتاحة. نتخطى المحجوز ونكمل:

SkipReserved.java
public class SkipReserved {    public static void main(String[] args) {        for (int seat = 1; seat <= 7; seat++) {            if (seat == 3 || seat == 6)                continue;            System.out.print("S" + seat + " ");        }    }}

المطبوع S1 S2 S4 S5 S7. في حلقة for ينفَّذ التحديث seat++ بعد continue تلقائيًا فلا خطر. أما في while فيجب الحذر:

WhileContinue.java
public class WhileContinue {    public static void main(String[] args) {        int count = 0;        while (count < 6) {            count++;            if (count % 3 == 0)                continue;            System.out.print(count + " ");        }    }}

نقلنا count++ إلى أول الجسم، فيُطبع 1 2 4 5 (يُتخطى 3 و6). لو تركناه في آخر الجسم لتخطّته continue هو أيضًا، ولبقي العدّاد عند 3 للأبد.

continue وwhileفي حلقة while جملة continue تقفز إلى فحص الشرط مباشرة متخطيةً ما بعدها في الجسم، ومنه سطر التحديث إن كان في آخر الجسم. ضع التحديث قبل continue دائمًا.

break داخل حلقة متداخلة

لأن break تنهي الحلقة الأقرب فقط، فهي في الداخلية لا توقف الخارجية:

InnerBreak.java
public class InnerBreak {    public static void main(String[] args) {        for (int row = 1; row <= 3; row++) {            for (int col = 1; col <= 4; col++) {                if (col == 3)                    break;                System.out.print(col + " ");            }            System.out.println();        }    }}

كل صف يطبع 1 2 فقط ثم تُنهى الداخلية، لكن الخارجية تكمل الصفوف الثلاثة.

توقّف وفكّرفي InnerBreak، كم مرة تُنفَّذ الجملة break في المجموع؟
اكشف الإجابة ثلاث مرات: مرة واحدة في كل صف (عند col = 3)، لأن الحلقة الخارجية لم تتوقف وأعادت تشغيل الداخلية ثلاث مرات.

ملخص الدرس

  • الحلقة الداخلية تكمل دورتها كلها في كل دورة من الخارجية، وعدد مرات تنفيذ الجسم الداخلي هو حاصل ضرب الحدّين.
  • لكل حلقة متغيرها، وعدّاد الداخلية يُعاد تهيئته مع كل دورة جديدة من الخارجية.
  • break تنهي الحلقة الأقرب فورًا؛ وcontinue تتخطى بقية الدورة الحالية فقط.
  • في while ضع تحديث العدّاد قبل continue حتى لا تتحول الحلقة إلى لانهائية.
اختبر نفسك · +5 نقاط
كم نجمة يطبع هذا الكود في المجموع؟
for (int i = 1; i <= 2; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.print("*");
    }
}
اختبر نفسك ٢، حتى +5 نقاط
ما الذي يُطبع هنا؟
for (int i = 1; i <= 5; i++) {
    if (i == 3)
        continue;
    System.out.print(i + " ");
}
اختبر نفسك ٣، حتى +5 نقاط
كم سطرًا يطبع هذا الكود، وماذا في كل سطر؟
for (int row = 1; row <= 2; row++) {
    for (int col = 1; col <= 3; col++) {
        if (col == 2)
            break;
        System.out.print(col + " ");
    }
    System.out.println();
}
★

تحدي: أين الخطأ؟

ثلاثة برامج عن الحلقات: أحدها لا ينتهي أبدًا، والثاني يعدّ أقل مما نريد، والثالث ينفّذ الحلقة بلا عمل. اقرأ الكود وتتبّعه ثم اضغط على السطر المخالف.

المقطع ١: نريد أن يعدّ البرنامج المحطات 1 و2 و3 ثم يتوقف، لكنه لا ينتهي أبدًا؛ فالمشغّل يوقفه بعد عدد هائل من الدورات ويعرض رسالة «الحلقة تجاوزت الحد الأقصى للتكرارات». أين الخطأ؟

public class Trap1 { public static void main(String[] args) { int count = 1; while (count <= 3) { System.out.println(count); count--; } } }

اسأل نفسك: أي اتجاه يتحرك فيه العدّاد، وهل يقرّبه من أن يصير الشرط خاطئًا؟ (فخ اتجاه التحديث في الدرس ٦٫١)

المقطع ٢: للقطار ثلاث رحلات، ويجب أن يطبع البرنامج Trip 1 وTrip 2 وTrip 3، لكنه يطبع رحلتين فقط. أين الخطأ؟

public class Trap2 { public static void main(String[] args) { int trips = 3; for (int i = 1; i < trips; i++) { System.out.println("Trip " + i); } } }

تتبّع قيمة i: عندما تصل إلى 3 هل يصح الشرط i < 3؟ ما الفرق بين < و<= في آخر دورة؟

المقطع ٣: نريد ترحيبًا واحدًا لكل واحد من ثلاثة ركاب (ثلاث مرات)، لكن البرنامج يطبع Welcome aboard مرة واحدة فقط. أين الخطأ؟

public class Trap3 { public static void main(String[] args) { for (int i = 1; i <= 3; i++); System.out.println("Welcome aboard"); } }

ماذا يعني وجود ; مباشرة بعد القوس الذي يغلق رأس for؟ ما الذي بقي جسمًا للحلقة، وأين صار سطر الطباعة؟

لماذا هذا التحدي مهم؟هذه الأخطاء الثلاثة من أكثر ما يقع فيه المبتدئ في الحلقات: تحديث بالاتجاه الخطأ، وخطأ الواحد بين < و<=، وفاصلة منقوطة بعد رأس الحلقة. انسخ كل مقطع إلى المحرر وصحّحه وشغّله.
✎

تمارين الوحدة ٦

اثنا عشر تمرينًا هي تمارين معمل الحلقات (المعمل ٦: الجزءان ١ و٢) كما هي، بالمطلوب نفسه. كل تمرين أمامه كود ناقص: اضغط «✎ تعديل»، اكتب الكود المطلوب مكان التعليقات، اضغط «✔ حفظ» ثم «▶ تشغيل» وقارن النتيجة بالمخرجات المتوقعة. حيث يُطلب إدخال استعمل القيم الاختبارية المكتوبة في التمرين حتى يطابق إخراجك المخرجات المتوقعة.

تمارين المعمل — الجزء ١

الحلقتان while وdo-while.

معمل ٦ الجزء ١، تمرين ١.

المطلوباطبع الأعداد من 1 إلى 10، كل عدد في سطر مستقل.
المدخلاتلا يوجد.
الأداةحلقة while.
قيمة countماذا يحدث؟
1الشرط صحيح: يُطبع 1 ثم يصير 2
2الشرط صحيح: يُطبع 2 ثم يصير 3
…نفس الشيء مع كل عدد
10الشرط ما زال صحيحًا (المساواة تكفي): يُطبع 10 ثم يصير 11
11الشرط خاطئ: تتوقف الحلقة ولا يُطبع 11
  1. جهّز عدّادًا يبدأ من أول عدد مطلوب طباعته.
  2. اكتب الشرط الذي يُبقي الحلقة تدور حتى يصل العدّاد إلى 10 ويشمله.
  3. داخل الحلقة اطبع قيمة العدّاد الحالية في سطر مستقل.
  4. في آخر الجسم زِد العدّاد بمقدار 1، وإلا لن تنتهي الحلقة أبدًا.

ما آخر عدد يجب أن يظهر في الناتج؟

CountToTen.java
public class CountToTen {    public static void main(String[] args) {        // 1) declare the counter count and start it at 1        // 2) while: as long as count is less than or equal to 10        //    print count (with println) and then increase it by 1    }}
المخرجات المتوقعة
1
2
3
4
5
6
7
8
9
10
تلميحالشرط count <= 10 يشمل 10 لأن المساواة تكفي، وcount++ داخل الجسم حتى لا تصير الحلقة لانهائية.

معمل ٦ الجزء ١، تمرين ٢.

المطلوباطبع الأعداد الزوجية 2 و4 و6 و8 و10، كل عدد في سطر مستقل.
المدخلاتلا يوجد.
الأداةحلقة while، والعدّاد يتحدّث بمقدار 2 في كل دورة.
قيمة countماذا يحدث؟
2يُطبع 2 ثم يصير 4
4يُطبع 4 ثم يصير 6
10يُطبع 10 ثم يصير 12
12الشرط خاطئ: تتوقف الحلقة
  1. ابدأ العدّاد من أول عدد زوجي مطلوب، لا من 1.
  2. اكتب الشرط الذي يُبقي الحلقة تدور حتى يصل العدّاد إلى 10 ويشمله.
  3. داخل الحلقة اطبع قيمة العدّاد في سطر مستقل.
  4. زِد العدّاد بمقدار 2 (لا 1) ليقفز إلى الزوجي التالي.

كم سطرًا سيطبع البرنامج؟

EvenNumbers.java
public class EvenNumbers {    public static void main(String[] args) {        // 1) declare the counter count and start it at 2        // 2) while: as long as count is less than or equal to 10        //    print count (with println) and then increase it by 2 with +=    }}
المخرجات المتوقعة
2
4
6
8
10
تلميحابدأ من 2 لا من 1، والتحديث count += 2 يقفز بالعدّاد من زوجي إلى الزوجي التالي.

معمل ٦ الجزء ١، تمرين ٣.

المطلوبعُدّ تنازليًا من 5 إلى 1 واطبع الأعداد في سطر واحد تفصل بينها مسافة.
المدخلاتلا يوجد.
الأداةحلقة do-while، والعدّاد يبدأ من 5 وينقص بمقدار 1 بعامل النقصان --.
قيمة countماذا يحدث؟
5يُطبع «5 » (مع مسافة) ثم يصير 4
4يُطبع «4 » ثم يصير 3
1يُطبع «1 » ثم يصير 0
0الشرط (أكبر من 0) خاطئ: تتوقف الحلقة
  1. ابدأ العدّاد من 5.
  2. داخل جسم do اطبع العدّاد ومعه مسافة دون الانتقال إلى سطر جديد.
  3. أنقص العدّاد بمقدار 1 بعامل النقصان.
  4. بعد الجسم اكتب شرط while الذي يُبقي الحلقة تدور ما دام العدّاد أكبر من 0، ولا تنسَ الفاصلة المنقوطة بعده.

ما الذي يميز شكل الناتج هنا عن تمرين ١؟

Countdown.java
public class Countdown {    public static void main(String[] args) {        // 1) declare the counter count and start it at 5        // 2) do: print count followed by a space (with print) and then decrease it with --        //    while: continue as long as count is greater than 0    }}
المخرجات المتوقعة
5 4 3 2 1
تلميحلا تنسَ الفاصلة المنقوطة بعد while (count > 0). وللمسافة بين الأعداد اطبع count + " " بـ print لا println.

معمل ٦ الجزء ١، تمرين ٤.

المطلوباحسب 1 + 2 + 3 + 4 + 5 في متغير sum ثم اطبع المجموع (يُقبل Sum = 15 أو 15 وحده).
المدخلاتلا يوجد.
الأداةحلقة while ومتغير sum يبدأ من 0.
countsum بعد إضافة count
10 + 1 = 1
21 + 2 = 3
33 + 3 = 6
46 + 4 = 10
510 + 5 = 15
  1. جهّز عدّادًا يبدأ من 1 ومتغير مجموع يبدأ من 0 (قبل الحلقة).
  2. اكتب شرط الحلقة بحيث يشمل العدّاد 5.
  3. داخل الحلقة أضف قيمة العدّاد إلى المجموع ثم زِد العدّاد بمقدار 1.
  4. بعد انتهاء الحلقة (لا داخلها) اطبع المجموع.

ما قيمة sum عند انتهاء الحلقة؟

SumToFive.java
public class SumToFive {    public static void main(String[] args) {        // 1) declare the counter count with the value 1 and the total sum with the value 0        // 2) while: as long as count is less than or equal to 5        //    add count to sum and then increase count by 1        // 3) print (with println) the value of sum (for example: "Sum = " followed by it)    }}
المخرجات المتوقعة
Sum = 15
تلميحعرّف sum بالصفر قبل الحلقة، وضع sum = sum + count داخلها، واطبع المجموع بعدها.

معمل ٦ الجزء ١، تمرين ٥.

المطلوباقرأ العدد n من المستخدم بـ Scanner، ثم اطبع الرسالة Welcome to Java بعدد n من المرات. اطبع أولًا سطر الطلب Enter a positive integer n: قبل القراءة.
المدخلاتعدد صحيح موجب n يُقرأ بـ Scanner وnextInt() (القيمة الاختبارية: 3).
الأداةحلقة while يتحكم فيها المتغير n.
المستخدم يدخل nماذا يُطبع؟
3Welcome to Java ثلاث مرات
1Welcome to Java مرة واحدة
5Welcome to Java خمس مرات
  1. اطبع رسالة الطلب في سطر مستقل ثم اقرأ العدد n من المستخدم.
  2. جهّز عدّادًا يبدأ من 1.
  3. اجعل الحلقة تدور ما دام العدّاد أصغر من n أو يساويه (حدّها هو n لا رقم ثابت).
  4. داخل الحلقة اطبع الرسالة ثم زِد العدّاد بمقدار 1.

إذا أدخل المستخدم 4، كم مرة تُطبع الرسالة Welcome to Java؟

RepeatMessage.java
import java.util.Scanner;public class RepeatMessage {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // 1) print (with println on its own line) "Enter a positive integer n:" and then read the number into n with nextInt        // 2) declare a counter count that starts at 1        //    while: as long as count is less than or equal to n, print Welcome to Java and then increase count    }}
المخرجات المتوقعة — بالقيمة الاختبارية 3
Enter a positive integer n:
Welcome to Java
Welcome to Java
Welcome to Java
تلميححدّ الحلقة هو المتغير n لا رقم ثابت: العدّاد يبدأ من 1 والشرط count <= n يجعل الجسم يُنفَّذ n مرة بالضبط.

معمل ٦ الجزء ١، التحدي الاختياري.

المطلوباطلب من المستخدم إدخال أعداد صحيحة بشكل متكرر باستخدام Scanner، وتوقف عندما يدخل 0 (لا حاجة لحساب المجموع). اطبع سطر الطلب Enter an integer (0 to stop): قبل كل قراءة.
المدخلاتأعداد صحيحة تُقرأ بـ Scanner وnextInt() حتى الصفر (القيم الاختبارية: 4 ثم 9 ثم 0).
الأداةحلقة do-while، لأن الطلب يجب أن يظهر مرة واحدة على الأقل.
المستخدم يدخلماذا يحدث؟
4n لا تساوي 0: يُطلب عدد جديد
9n لا تساوي 0: يُطلب عدد جديد
0n تساوي 0: تتوقف الحلقة
  1. عرّف المتغير n قبل الحلقة (بلا قيمة) ليراه شرط while بعد الجسم.
  2. داخل جسم do اطبع رسالة الطلب ثم اقرأ العدد في n.
  3. بعد الجسم اكتب الشرط: استمر ما دام n لا يساوي 0.

إذا أدخل المستخدم 0 في أول مرة، كم مرة تُطبع رسالة الطلب؟

InputUntilZero.java
import java.util.Scanner;public class InputUntilZero {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // 1) declare the variable n before the loop (with no value)        // 2) do: print (with println) "Enter an integer (0 to stop):" and then read the number into n with nextInt        //    while: continue as long as n is not equal to 0    }}
المخرجات المتوقعة — بالقيم الاختبارية 4 و9 و0
Enter an integer (0 to stop):
Enter an integer (0 to stop):
Enter an integer (0 to stop):
تلميحعرّف n قبل الحلقة لأن الشرط الذي بعد الجسم يحتاج أن يراه. الشرط n != 0 يعني «استمر حتى يدخل المستخدم صفرًا»، والصفر يُقرأ ثم تنتهي الحلقة (قيمة الحراسة في الدرس ٦٫٢).

تمارين المعمل — الجزء ٢

الحلقة for والحلقات المتداخلة وجملتا break وcontinue.

معمل ٦ الجزء ٢، تمرين ١.

المطلوباطبع الأعداد من 1 إلى 10، كل عدد في سطر مستقل.
المدخلاتلا يوجد.
الأداةحلقة for (العدّاد والشرط والتحديث في رأس الحلقة).
قيمة iماذا يحدث؟
1الشرط صحيح: يُطبع 1 ثم يصير 2
2الشرط صحيح: يُطبع 2 ثم يصير 3
10الشرط ما زال صحيحًا: يُطبع 10 ثم يصير 11
11الشرط خاطئ: تتوقف الحلقة
  1. في رأس الحلقة ضع ثلاثة أجزاء تفصل بينها فاصلتان منقوطتان: البداية، ثم الشرط، ثم التحديث.
  2. ابدأ العدّاد i من 1 واجعل الشرط يشمل 10.
  3. داخل الحلقة اطبع i في سطر مستقل (لا تزِد i بيدك، فرأس الحلقة يتولى ذلك).

ما الفرق بين هذا التمرين وتمرين ١؟

CountWithFor.java
public class CountWithFor {    public static void main(String[] args) {        // for: declare the counter i in the loop header and start it at 1,        //      continue as long as i is less than or equal to 10, and increase i with ++        //      and print i (with println) inside the loop    }}
المخرجات المتوقعة
1
2
3
4
5
6
7
8
9
10
تلميحالأجزاء الثلاثة بالترتيب: int i = 1 ثم i <= 10 ثم i++، تفصل بينها فاصلتان منقوطتان.

معمل ٦ الجزء ٢، تمرين ٢.

المطلوباقرأ عددًا من المستخدم بـ Scanner، ثم اعرض جدول ضربه من 1 إلى 10 بالصيغة 7 x 1 = 7. اطبع أولًا سطر الطلب Enter an integer: قبل القراءة.
المدخلاتعدد صحيح n يُقرأ بـ Scanner وnextInt() (القيمة الاختبارية: 7).
الأداةحلقة for يتغير عدّادها من 1 إلى 10.
iالسطر المطبوع
17 x 1 = 7
27 x 2 = 14
37 x 3 = 21
107 x 10 = 70
  1. اطبع رسالة الطلب في سطر مستقل ثم اقرأ العدد n.
  2. اجعل العدّاد i يمر على الأعداد من 1 إلى 10.
  3. في كل دورة اطبع سطرًا واحدًا على الصيغة: n ثم x ثم i ثم = ثم حاصل الضرب.
  4. احسب حاصل الضرب من n و i، ولا تكتب النتيجة جاهزة.

إذا أدخل المستخدم 3، ما آخر سطر في الجدول؟

MultiplicationTable.java
import java.util.Scanner;public class MultiplicationTable {    public static void main(String[] args) {        Scanner sc = new Scanner(System.in);        // 1) print (with println on its own line) "Enter an integer:" and then read the number into n with nextInt        // 2) for: i from 1 to 10        //    print (with println) in the form: n x i = the product    }}
المخرجات المتوقعة — بالقيمة الاختبارية 7
Enter an integer:
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70
تلميحاجمع النصوص والأرقام بـ +، والأقواس حول (n * i) للوضوح فقط (فالضرب يسبق الجمع أصلًا)، لكنها تصير ضرورية لو أردت جمعًا مثل (n + i) داخل النص. قارن مع مثال «جدول الضرب: ثمن التذاكر» في الدرس ٦٫٣.

معمل ٦ الجزء ٢، تمرين ٣.

المطلوباطبع ٣ صفوف، في كل صف ٥ نجمات تتبع كل منها مسافة ("* ").
المدخلاتلا يوجد.
الأداةحلقتا for متداخلتان: خارجية للصفوف وداخلية للأعمدة.
row (الصف)ماذا يُطبع؟
1خمس نجمات ثم سطر جديد
2خمس نجمات ثم سطر جديد
3خمس نجمات ثم سطر جديد
  1. الحلقة الخارجية تدور ٣ مرات: مرة لكل صف.
  2. داخلها حلقة داخلية تدور ٥ مرات: مرة لكل نجمة، وتطبع النجمة مع مسافة دون سطر جديد.
  3. بعد انتهاء الداخلية وما زلنا داخل الخارجية، انتقل إلى سطر جديد.

كم نجمة يطبعها البرنامج في المجموع؟

SimpleRectangle.java
public class SimpleRectangle {    public static void main(String[] args) {        // outer for: row from 1 to 3        //     inner for: col from 1 to 5, and print "* " (a star and a space, with print) inside it        //     after the inner loop: move to a new line with println()    }}
المخرجات المتوقعة
* * * * *
* * * * *
* * * * *
تلميحالحلقة الخارجية للصفوف والداخلية للأعمدة. println() الفارغة تأتي بعد الداخلية وداخل الخارجية، وإلا خرجت النجوم كلها في سطر واحد.

معمل ٦ الجزء ٢، تمرين ٤.

المطلوباطبع الأعداد من 1 إلى 10 (كل عدد في سطر) لكن أوقف الحلقة عندما يصير العدّاد 5، قبل طباعته.
المدخلاتلا يوجد.
الأداةحلقة for مع جملة break.
قيمة iماذا يحدث؟
1لا تساوي 5: يُطبع 1
4لا تساوي 5: يُطبع 4
5تساوي 5: تنتهي الحلقة ولا يُطبع 5
6 إلى 10لا تُنفَّذ أبدًا
  1. اجعل الحلقة تمر على الأعداد من 1 إلى 10.
  2. في بداية الجسم افحص: هل العدّاد يساوي 5؟ إن كان كذلك أوقف الحلقة كلها.
  3. بعد الفحص اطبع العدّاد؛ فلن يصل 5 إلى سطر الطباعة.

ما آخر عدد يظهر في الناتج؟

StopAtFive.java
public class StopAtFive {    public static void main(String[] args) {        // for: i from 1 to 10        //     if: if i equals 5, run break        //     then print i (with println)    }}
المخرجات المتوقعة
1
2
3
4
تلميحضع فحص i == 5 قبل سطر الطباعة؛ فعندما يصل العدّاد إلى 5 تنتهي الحلقة دون أن تطبعه.

معمل ٦ الجزء ٢، تمرين ٥.

المطلوباطبع الأعداد من 1 إلى 10 (كل عدد في سطر) مع تخطّي الرقم 5 فقط.
المدخلاتلا يوجد.
الأداةحلقة for مع جملة continue.
قيمة iماذا يحدث؟
4لا تساوي 5: يُطبع 4
5تساوي 5: تُتخطى هذه الدورة فقط ولا يُطبع 5
6لا تساوي 5: تكمل الحلقة ويُطبع 6
  1. اجعل الحلقة تمر على الأعداد من 1 إلى 10.
  2. في بداية الجسم افحص: هل العدّاد يساوي 5؟ إن كان كذلك تخطَّ بقية هذه الدورة فقط.
  3. بعد الفحص اطبع العدّاد في سطر مستقل.

كم سطرًا في الناتج؟

SkipFive.java
public class SkipFive {    public static void main(String[] args) {        // for: i from 1 to 10        //     if: if i equals 5, run continue        //     then print i (with println)    }}
المخرجات المتوقعة
1
2
3
4
6
7
8
9
10
تلميحcontinue تتخطى بقية الدورة الحالية فقط ثم تكمل الحلقة بـ 6 و7 وهكذا؛ بخلاف break التي تنهي الحلقة كلها.

معمل ٦ الجزء ٢، التحدي الاختياري.

المطلوباطبع ثلاثة صفوف: الأول 1، والثاني 1 2، والثالث 1 2 3.
المدخلاتلا يوجد.
الأداةحلقتا for متداخلتان، وحدّ الداخلية هو متغير الخارجية.
row (الصف)ما يُطبع في الصف
11
21 2
31 2 3
  1. الحلقة الخارجية تدور ٣ مرات: مرة لكل صف.
  2. الحلقة الداخلية تعدّ من 1 إلى رقم الصف الحالي، فيزداد طول الصف مع كل صف.
  3. داخل الداخلية اطبع رقم العمود نفسه (لا رقم الصف) مع مسافة بعده.
  4. بعد الداخلية انتقل إلى سطر جديد.

كم رقمًا يظهر في الصف الثالث؟

NumberPattern.java
public class NumberPattern {    public static void main(String[] args) {        // outer for: row from 1 to 3        //     inner for: col from 1 to row (its limit is the outer variable!)        //                 and print col followed by a space (with print)        //     after the inner loop: println() for a new line    }}
المخرجات المتوقعة
1
1 2
1 2 3
تلميححدّ الداخلية col <= row: في الصف الأول تدور مرة واحدة، وفي الثاني مرتين، وفي الثالث ثلاث مرات. وهنا نطبع col لا row (قارن مع مثلث الأرقام في الدرس ٦٫٤).