الحلقة while: عدّ المحطات
تركب قطار الحرمين من المدينة المنورة، والمضيف يعلن اسم كل محطة تمرّ بها: نفس الإعلان يتكرر في كل محطة. كيف نقول لجافا «كرّر هذا العمل» بدل أن نكتبه عشرات المرات؟
قبل الأمثلة، هذه دورة حلقة while في صورة واحدة:
انطلق القطار من محطة المدينة المنورة متجهًا إلى مكة المكرمة، ومضيف الرحلة يمسك الميكروفون: «وصلنا إلى محطة جديدة». سيعيد هذه الجملة في كل محطة. لو كتبنا البرنامج الذي يعلن خمس محطات بالطريقة التي نعرفها لكتبنا السطر نفسه خمس مرات:
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:
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 كلٌّ في سطر.
وهذه هي النسخة المعدّلة جاهزة للتشغيل. اطبع الأعداد الفردية فقط من 1 إلى 5 بتغيير التحديث وحده:
public class WhileStep2 { public static void main(String[] args) { int count = 1; while (count <= 5) { System.out.println(count); count += 2; } }}
تتبّع الحلقة خطوة بخطوة
أفضل طريقة لفهم أي حلقة أن تتبعها كما يفعل المترجم: جدول تكتب فيه قيمة العدّاد ونتيجة الشرط وما يُطبع في كل دورة. نتتبع هنا حلقة مختصرة تعدّ حتى 3. اضغط «التالي» وتوقّع الصف قبل أن يظهر:
توقّع: كم مرة سيُفحص الشرط حتى تنتهي الحلقة، وكم مرة سيُنفَّذ الجسم؟
المجموع التراكمي: sum
الحلقة تتألق عندما تجمع شيئًا. نحتاج متغيرًا اسمه sum يبدأ بالصفر ويستقبل شيئًا جديدًا في كل دورة، كأن المضيف يجمع أرقام المحطات التي مرّ بها القطار:
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 داخل الجسم لعاد إلى الصفر في كل دورة ولضاع ما جمعناه.
الحلقة قد لا تُنفَّذ أبدًا
بما أن الشرط يُفحص أولًا، فإن كان خاطئًا منذ البداية تُتخطّى الحلقة بالكامل:
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--:
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:
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 دائمًا (وفي جافا الحقيقية قد يلتف العدّاد بعد نحو ملياري دورة فتنتهي الحلقة، لكننا نعدّها لانهائية عمليًا). القاعدة العملية: عند كتابة أي حلقة اسأل نفسك «أي سطر في الجسم يقرّب الشرط من أن يصير خاطئًا؟».
اكشف الإجابة
حلقة لانهائية؛ لأن العدّاد لا يتغير فلا يصل إلى 6 أبدًا. أي تحديث لا يقرّب العدّاد من حدّ الشرط يصنع الخلل نفسه.ملخص الدرس
- حلقة while: تفحص الشرط أولًا، ثم تنفّذ الجسم إن كان صحيحًا، وتكرّر.
- ثلاثة أسطر تحكم الحلقة: التهيئة قبلها، والشرط في رأسها، والتحديث داخل جسمها.
- المجموع التراكمي (sum) يبدأ من الصفر قبل الحلقة ويستقبل قيمة في كل دورة.
- قد تُنفَّذ الحلقة صفر مرة إن كان الشرط خاطئًا من البداية.
- غياب التحديث، أو تحديثه في الاتجاه الخطأ، يصنع حلقة لانهائية.
int n = 1;
while (n <= 3) {
System.out.print(n + " ");
n++;
}int count = 0;
while (count < 5) {
System.out.println(count);
count--;
}int sum = 0;
int i = 1;
while (i <= 4) {
sum += i;
i++;
}
System.out.println(sum);الحلقة do-while: ماكينة التذاكر
في محطة القطار تقف أمام ماكينة التذاكر: لا تعرف ماذا تريد حتى تسألك أول مرة، ثم تعيد السؤال إن كان جوابك غير صالح. حلقة تعمل أولًا ثم تفحص.
قبل الأمثلة، تابع ما يحدث في do-while عندما يكون الشرط خاطئًا من البداية:
وصلت إلى المحطة ووقفت أمام ماكينة التذاكر. الماكينة لا تستطيع أن تفحص جوابك قبل أن تسأل، فلا بد أن تعرض السؤال مرة واحدة على الأقل، ثم تقرر: هل الجواب صالح؟ إن لم يكن تعيد السؤال. هذا السلوك لا تعطيه حلقة while لأنها تفحص أولًا. الحل هو حلقة do-while.
بناء حلقة do-while
do {
statement1;
statement2;
} while (condition);
الجسم يأتي أولًا ثم الشرط بعده. تنفَّذ الدورة الأولى دون أي فحص، وبعدها يُفحص الشرط: إن كان true تعاد الدورة، وإن كان false تنتهي الحلقة. وهي تكافئ نسخ الجسم مرة قبل حلقة while عادية:
S1;
while (condition)
S1;
مثال المعمل: أكمل الشرط
في المعمل برنامج ينقصه الشرط ويطلب منك أن يطبع 1 إلى 5:
int number = 1;
do {
System.out.println(number);
number++;
} while (number <= ____ );
الشرط يجب أن يبقى صحيحًا ما دام number لم يتجاوز 5، فالرقم الناقص هو 5:
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:
public class DoWhileFrom6 { public static void main(String[] args) { int number = 6; do { System.out.println(number); number++; } while (number <= 5); }}
يطبع 6 مرة واحدة رغم أن الشرط خاطئ من البداية! أما نسخة while بالقيمة نفسها (انظر ZeroTimes في الدرس ٦٫١) فلا تطبع شيئًا.
| الميزة | while | do-while |
|---|---|---|
| متى يُفحص الشرط؟ | قبل الجسم | بعد الجسم |
| أقل عدد دورات | صفر | واحدة |
| الفاصلة المنقوطة بعد الشرط | لا | نعم |
| الاستعمال المناسب | قد لا نحتاج الدورة أصلًا | نحتاجها مرة على الأقل |
++ و -- داخل الحلقات
العدّاد يتغير في كل دورة تقريبًا، وكتابة i = i + 1 طويلة، فلغة جافا تعطينا اختصارات نستعملها داخل الحلقات كل يوم:
| الجملة | تعني | مثال |
|---|---|---|
| i++ | i = i + 1 | العدّ التصاعدي بخطوة واحدة |
| i-- | i = i - 1 | العدّ التنازلي |
| i += 2 | i = i + 2 | القفز بمقدار 2 (الأعداد الزوجية) |
| i -= 3 | i = i - 3 | النقصان بمقدار 3 |
مثال عليها مع do-while: ماكينة التذاكر تعرض المقاعد المتبقية وتنقصها بعد كل تذكرة. نقصان واحد ثلاث مرات:
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:
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:
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. الصفر نفسه يُضاف إلى المجموع لكنه لا يغيّره. وهذه الصورة هي ما يطلبه التحدي الاختياري في المعمل (دون حساب المجموع).
اكشف الإجابة
لأن الشرط n != 0 يحتاج قيمة n قبل أول فحص، وقيمتها لا تُقرأ إلا داخل الجسم. do-while تقرأ أولًا ثم تفحص فتحلّ المشكلة بطبيعتها.ملخص الدرس
- do { ... } while (cond);: الجسم ثم الفحص، فهو يُنفَّذ مرة على الأقل، ولا تنسَ الفاصلة المنقوطة.
- إذا بدأ الشرط خاطئًا: while لا تدخل أبدًا، وdo-while تدخل مرة واحدة.
- ++ و-- و+= و-= هي اختصارات التحديث في الحلقات.
- التحقق من المدخلات وقيمة الحراسة (الصفر) هما أشهر استعمالين لحلقة do-while.
int number = 6;
do {
System.out.println(number);
number++;
} while (number <= 5);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 تجمع الأجزاء الثلاثة في سطر واحد، فهي الخيار الأول حين نعرف عدد التكرارات مسبقًا أو حين يتغير العدّاد بمقدار منتظم.
بناء حلقة for
for (initialization; condition; update) {
body statements;
}
الأجزاء الثلاثة بين القوسين تفصل بينها فاصلتان منقوطتان:
- التهيئة (initialization): تُنفَّذ مرة واحدة في البداية، وغالبًا تعرّف العدّاد: int i = 1.
- الشرط (condition): يُفحص قبل كل دورة، مثل while تمامًا؛ إن كان خاطئًا انتهت الحلقة.
- التحديث (update): يُنفَّذ بعد كل دورة وقبل الفحص التالي: i++.
ترتيب التنفيذ: (١) التهيئة مرة واحدة، (٢) فحص الشرط، (٣) إن صح يُنفَّذ الجسم، (٤) ينفَّذ التحديث ثم نعود إلى (٢). وهي تكافئ هذه الحلقة while:
initialization;
while (condition) {
body statements;
update;
}
مثال المعمل: العدّ من 1 إلى 5
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:
public class ForEven { public static void main(String[] args) { for (int i = 2; i <= 10; i += 2) { System.out.println(i); } }}
لوحة الرحلات
لنصنع اللوحة: كل رحلة تغادر بعد الأخرى بساعة. العدّاد trip يمثل رقم الرحلة ويدخل في حساب موعدها:
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 تذاكر:
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 في كل دورة:
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 تمامًا:
public class OmitParts { public static void main(String[] args) { int i = 1; for (; i <= 3; ) { System.out.println("Stop " + i); i++; } }}
أما الشكل for (;;) بلا أي جزء فهو حلقة لانهائية صريحة، ولا نخرج منها إلا بـ break وهو موضوع الدرس ٦٫٤.
أي حلقة أختار؟
| الحلقة | متى أستعملها |
|---|---|
| for | نعرف عدد التكرارات أو يتغير العدّاد بمقدار منتظم. |
| while | نكرر حتى يتحقق شرط، وقد لا نحتاج الدورة أصلًا. |
| do-while | نحتاج الدورة مرة على الأقل (سؤال أول، تحقق من إدخال). |
ملخص الدرس
- for (init; cond; update): التهيئة مرة واحدة، ثم الشرط قبل كل دورة، والتحديث بعد كل دورة.
- تكافئ حلقة while: التهيئة قبلها، والتحديث في آخر جسمها.
- متغير العدّاد المعرَّف في رأس for لا يُرى خارج الحلقة.
- حذف الشرط يصنع حلقة لانهائية، وحذف التحديث يجمّد العدّاد.
- فاصلة منقوطة بعد قوس for تفرّغ الجسم من محتواه.
for (int i = 1; i <= 10; i += 3) {
System.out.print(i + " ");
}for (int i = 0; i < 3; i++) {
System.out.println(i);
}
System.out.println(i);int sum = 0;
for (int n = 1; n <= 3; n++) {
sum = sum + n * n;
}
System.out.println(sum);الحلقات المتداخلة وbreak وcontinue: العربات والمقاعد
في القطار عربات، وفي كل عربة صفوف من المقاعد. للمرور على كل المقاعد نحتاج حلقة داخل حلقة. ثم نتعلم كيف نوقف البحث عند أول مقعد فارغ (break) وكيف نتخطى المقاعد المحجوزة (continue).
قبل الأمثلة، هذه فكرة الحلقة داخل الحلقة في صورة:
وهذا الفرق بين break وcontinue في صورة:
حلقة داخل حلقة
جسم الحلقة يمكن أن يحتوي أي جمل، ومنها حلقة أخرى. تسمى الحلقة الموجودة في الداخل الحلقة الداخلية (inner loop)، والتي تحتويها الحلقة الخارجية (outer loop). القاعدة الذهبية: الداخلية تكمل دورتها كاملة في كل دورة واحدة من الخارجية. فالمضيف الذي يمر على 3 عربات، وفي كل عربة يفحص 4 مقاعد، يفحص 12 مقعدًا في المجموع.
for (outer init; outer condition; outer update) {
for (inner init; inner condition; inner update) {
inner body;
}
}
مثال المعمل: مستطيل من النجوم
الحلقة الخارجية تعدّ الصفوف، والداخلية تعدّ الأعمدة في كل صف. بعد انتهاء الداخلية نطبع println() فارغة للانتقال إلى سطر جديد:
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(); } }}
الناتج ثلاثة أسطر، في كل سطر أربع نجمات. تتبّعه في الشكل التالي لترى كيف تمتلئ الشبكة صفًّا صفًّا:
توقّع: كم مرة يُنفَّذ سطر الطباعة System.out.print("* ") في المجموع؟
يطلب المعمل بعدها تغيير الصفوف إلى 2 والأعمدة إلى 5. نغيّر الحدّين في الشرطين فقط:
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 من المرات:
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 تدور أربع مرات.
عربات ومقاعد: ترقيم المقاعد
متغيرا الحلقتين معًا يعطيان «عنوان» كل مقعد: رقم العربة ورقم المقعد داخلها:
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) داخل الخارجية في كل دورة، وإلا بقي من الدورة السابقة وفشلت الداخلية في الصف الثاني:
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 داخلية، مع ملاحظة الفاصلة المنقوطة بعد شرطها:
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(); } }}
break: أوقف الحلقة فورًا
الجملة break تنهي الحلقة التي هي فيها مباشرة، ويكمل البرنامج بما بعد الحلقة. تذكّر أنها تنهي الحلقة الأقرب (الداخلية) فقط. أول سطر في مثال المعمل الثالث يعدّ من 0 لكنه يتوقف عند 4:
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:
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 محجوزة:
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) ونريد طباعة بقية المقاعد المتاحة. نتخطى المحجوز ونكمل:
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 فيجب الحذر:
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 للأبد.
break داخل حلقة متداخلة
لأن break تنهي الحلقة الأقرب فقط، فهي في الداخلية لا توقف الخارجية:
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 فقط ثم تُنهى الداخلية، لكن الخارجية تكمل الصفوف الثلاثة.
اكشف الإجابة
ثلاث مرات: مرة واحدة في كل صف (عند col = 3)، لأن الحلقة الخارجية لم تتوقف وأعادت تشغيل الداخلية ثلاث مرات.ملخص الدرس
- الحلقة الداخلية تكمل دورتها كلها في كل دورة من الخارجية، وعدد مرات تنفيذ الجسم الداخلي هو حاصل ضرب الحدّين.
- لكل حلقة متغيرها، وعدّاد الداخلية يُعاد تهيئته مع كل دورة جديدة من الخارجية.
- break تنهي الحلقة الأقرب فورًا؛ وcontinue تتخطى بقية الدورة الحالية فقط.
- في while ضع تحديث العدّاد قبل continue حتى لا تتحول الحلقة إلى لانهائية.
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= 3; j++) {
System.out.print("*");
}
}for (int i = 1; i <= 5; i++) {
if (i == 3)
continue;
System.out.print(i + " ");
}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 ثم يتوقف، لكنه لا ينتهي أبدًا؛ فالمشغّل يوقفه بعد عدد هائل من الدورات ويعرض رسالة «الحلقة تجاوزت الحد الأقصى للتكرارات». أين الخطأ؟
اسأل نفسك: أي اتجاه يتحرك فيه العدّاد، وهل يقرّبه من أن يصير الشرط خاطئًا؟ (فخ اتجاه التحديث في الدرس ٦٫١)
المقطع ٢: للقطار ثلاث رحلات، ويجب أن يطبع البرنامج Trip 1 وTrip 2 وTrip 3، لكنه يطبع رحلتين فقط. أين الخطأ؟
تتبّع قيمة i: عندما تصل إلى 3 هل يصح الشرط i < 3؟ ما الفرق بين < و<= في آخر دورة؟
المقطع ٣: نريد ترحيبًا واحدًا لكل واحد من ثلاثة ركاب (ثلاث مرات)، لكن البرنامج يطبع Welcome aboard مرة واحدة فقط. أين الخطأ؟
ماذا يعني وجود ; مباشرة بعد القوس الذي يغلق رأس for؟ ما الذي بقي جسمًا للحلقة، وأين صار سطر الطباعة؟
تمارين الوحدة ٦
اثنا عشر تمرينًا هي تمارين معمل الحلقات (المعمل ٦: الجزءان ١ و٢) كما هي، بالمطلوب نفسه. كل تمرين أمامه كود ناقص: اضغط «✎ تعديل»، اكتب الكود المطلوب مكان التعليقات، اضغط «✔ حفظ» ثم «▶ تشغيل» وقارن النتيجة بالمخرجات المتوقعة. حيث يُطلب إدخال استعمل القيم الاختبارية المكتوبة في التمرين حتى يطابق إخراجك المخرجات المتوقعة.
تمارين المعمل — الجزء ١
الحلقتان while وdo-while.
معمل ٦ الجزء ١، تمرين ١.
| قيمة count | ماذا يحدث؟ |
|---|---|
| 1 | الشرط صحيح: يُطبع 1 ثم يصير 2 |
| 2 | الشرط صحيح: يُطبع 2 ثم يصير 3 |
| … | نفس الشيء مع كل عدد |
| 10 | الشرط ما زال صحيحًا (المساواة تكفي): يُطبع 10 ثم يصير 11 |
| 11 | الشرط خاطئ: تتوقف الحلقة ولا يُطبع 11 |
- جهّز عدّادًا يبدأ من أول عدد مطلوب طباعته.
- اكتب الشرط الذي يُبقي الحلقة تدور حتى يصل العدّاد إلى 10 ويشمله.
- داخل الحلقة اطبع قيمة العدّاد الحالية في سطر مستقل.
- في آخر الجسم زِد العدّاد بمقدار 1، وإلا لن تنتهي الحلقة أبدًا.
ما آخر عدد يجب أن يظهر في الناتج؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class PageNumbers { public static void main(String[] args) { // 1) declare the counter page and start it at 21 // 2) while: as long as page is less than or equal to 28 // print "Page " followed by page (with println) and then increase page by 1 }}
Page 21 Page 22 Page 23 Page 24 Page 25 Page 26 Page 27 Page 28
معمل ٦ الجزء ١، تمرين ٢.
| قيمة count | ماذا يحدث؟ |
|---|---|
| 2 | يُطبع 2 ثم يصير 4 |
| 4 | يُطبع 4 ثم يصير 6 |
| 10 | يُطبع 10 ثم يصير 12 |
| 12 | الشرط خاطئ: تتوقف الحلقة |
- ابدأ العدّاد من أول عدد زوجي مطلوب، لا من 1.
- اكتب الشرط الذي يُبقي الحلقة تدور حتى يصل العدّاد إلى 10 ويشمله.
- داخل الحلقة اطبع قيمة العدّاد في سطر مستقل.
- زِد العدّاد بمقدار 2 (لا 1) ليقفز إلى الزوجي التالي.
كم سطرًا سيطبع البرنامج؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class BusTimes { public static void main(String[] args) { // 1) declare the counter minute and start it at 10 // 2) while: as long as minute is less than or equal to 70 // print "Bus at minute " followed by minute (with println) and then increase it by 15 with += }}
Bus at minute 10 Bus at minute 25 Bus at minute 40 Bus at minute 55 Bus at minute 70
معمل ٦ الجزء ١، تمرين ٣.
| قيمة count | ماذا يحدث؟ |
|---|---|
| 5 | يُطبع «5 » (مع مسافة) ثم يصير 4 |
| 4 | يُطبع «4 » ثم يصير 3 |
| 1 | يُطبع «1 » ثم يصير 0 |
| 0 | الشرط (أكبر من 0) خاطئ: تتوقف الحلقة |
- ابدأ العدّاد من 5.
- داخل جسم do اطبع العدّاد ومعه مسافة دون الانتقال إلى سطر جديد.
- أنقص العدّاد بمقدار 1 بعامل النقصان.
- بعد الجسم اكتب شرط while الذي يُبقي الحلقة تدور ما دام العدّاد أكبر من 0، ولا تنسَ الفاصلة المنقوطة بعده.
ما الذي يميز شكل الناتج هنا عن تمرين ١؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class Launch { public static void main(String[] args) { // 1) declare the counter count and start it at 12 // 2) do: print count followed by a space (with print) and then decrease it by 3 with -= // while: continue as long as count is greater than or equal to 0 // 3) after the loop print Liftoff! (with println) }}
12 9 6 3 0 Liftoff!
معمل ٦ الجزء ١، تمرين ٤.
| count | sum بعد إضافة count |
|---|---|
| 1 | 0 + 1 = 1 |
| 2 | 1 + 2 = 3 |
| 3 | 3 + 3 = 6 |
| 4 | 6 + 4 = 10 |
| 5 | 10 + 5 = 15 |
- جهّز عدّادًا يبدأ من 1 ومتغير مجموع يبدأ من 0 (قبل الحلقة).
- اكتب شرط الحلقة بحيث يشمل العدّاد 5.
- داخل الحلقة أضف قيمة العدّاد إلى المجموع ثم زِد العدّاد بمقدار 1.
- بعد انتهاء الحلقة (لا داخلها) اطبع المجموع.
ما قيمة sum عند انتهاء الحلقة؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class DonationTotal { public static void main(String[] args) { // 1) declare the counter amount with the value 5 and the total total with the value 0 // 2) while: as long as amount is less than or equal to 50 // add amount to total and then increase amount by 5 // 3) print (with println) the value of total (for example: "Total = " followed by it) }}
Total = 275
معمل ٦ الجزء ١، تمرين ٥.
| المستخدم يدخل n | ماذا يُطبع؟ |
|---|---|
| 3 | Welcome to Java ثلاث مرات |
| 1 | Welcome to Java مرة واحدة |
| 5 | Welcome to Java خمس مرات |
- اطبع رسالة الطلب في سطر مستقل ثم اقرأ العدد n من المستخدم.
- جهّز عدّادًا يبدأ من 1.
- اجعل الحلقة تدور ما دام العدّاد أصغر من n أو يساويه (حدّها هو n لا رقم ثابت).
- داخل الحلقة اطبع الرسالة ثم زِد العدّاد بمقدار 1.
إذا أدخل المستخدم 4، كم مرة تُطبع الرسالة Welcome to 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 }}
Enter a positive integer n: Welcome to Java Welcome to Java Welcome to Java
تمرين إضافي على تمرين الوحدة ٦.
import java.util.Scanner;public class ExamSheet { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 1) print (with println on its own line) "Enter the number of questions:" 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 "Question " followed by count and a colon, then increase count }}
Enter the number of questions: Question 1: Question 2: Question 3: Question 4:
معمل ٦ الجزء ١، التحدي الاختياري.
| المستخدم يدخل | ماذا يحدث؟ |
|---|---|
| 4 | n لا تساوي 0: يُطلب عدد جديد |
| 9 | n لا تساوي 0: يُطلب عدد جديد |
| 0 | n تساوي 0: تتوقف الحلقة |
- عرّف المتغير n قبل الحلقة (بلا قيمة) ليراه شرط while بعد الجسم.
- داخل جسم do اطبع رسالة الطلب ثم اقرأ العدد في n.
- بعد الجسم اكتب الشرط: استمر ما دام n لا يساوي 0.
إذا أدخل المستخدم 0 في أول مرة، كم مرة تُطبع رسالة الطلب؟
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 }}
Enter an integer (0 to stop): Enter an integer (0 to stop): Enter an integer (0 to stop):
تمرين إضافي على تمرين الوحدة ٦.
import java.util.Scanner;public class PinCheck { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 1) declare the variable pin before the loop (with no value) // 2) do: print (with println) "Enter your PIN:" and then read the number into pin with nextInt // while: continue as long as pin is not equal to 1234 // 3) after the loop print Welcome! (with println) }}
Enter your PIN: Enter your PIN: Enter your PIN: Welcome!
تمارين المعمل — الجزء ٢
الحلقة for والحلقات المتداخلة وجملتا break وcontinue.
معمل ٦ الجزء ٢، تمرين ١.
| قيمة i | ماذا يحدث؟ |
|---|---|
| 1 | الشرط صحيح: يُطبع 1 ثم يصير 2 |
| 2 | الشرط صحيح: يُطبع 2 ثم يصير 3 |
| 10 | الشرط ما زال صحيحًا: يُطبع 10 ثم يصير 11 |
| 11 | الشرط خاطئ: تتوقف الحلقة |
- في رأس الحلقة ضع ثلاثة أجزاء تفصل بينها فاصلتان منقوطتان: البداية، ثم الشرط، ثم التحديث.
- ابدأ العدّاد i من 1 واجعل الشرط يشمل 10.
- داخل الحلقة اطبع i في سطر مستقل (لا تزِد i بيدك، فرأس الحلقة يتولى ذلك).
ما الفرق بين هذا التمرين وتمرين ١؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class SeatsLeft { public static void main(String[] args) { // for: declare the counter i in the loop header and start it at 8, // continue as long as i is greater than or equal to 1, and decrease i with -- // and print "Seats left: " followed by i (with println) inside the loop }}
Seats left: 8 Seats left: 7 Seats left: 6 Seats left: 5 Seats left: 4 Seats left: 3 Seats left: 2 Seats left: 1
معمل ٦ الجزء ٢، تمرين ٢.
| i | السطر المطبوع |
|---|---|
| 1 | 7 x 1 = 7 |
| 2 | 7 x 2 = 14 |
| 3 | 7 x 3 = 21 |
| 10 | 7 x 10 = 70 |
- اطبع رسالة الطلب في سطر مستقل ثم اقرأ العدد n.
- اجعل العدّاد i يمر على الأعداد من 1 إلى 10.
- في كل دورة اطبع سطرًا واحدًا على الصيغة: n ثم x ثم i ثم = ثم حاصل الضرب.
- احسب حاصل الضرب من n و i، ولا تكتب النتيجة جاهزة.
إذا أدخل المستخدم 3، ما آخر سطر في الجدول؟
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 }}
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
تمرين إضافي على تمرين الوحدة ٦.
import java.util.Scanner;public class PriceList { public static void main(String[] args) { Scanner sc = new Scanner(System.in); // 1) print (with println on its own line) "Enter the price of one item:" and then read the number into price with nextInt // 2) for: i from 1 to 8 // print (with println) in the form: Qty i: the cost SAR }}
Enter the price of one item: Qty 1: 15 SAR Qty 2: 30 SAR Qty 3: 45 SAR Qty 4: 60 SAR Qty 5: 75 SAR Qty 6: 90 SAR Qty 7: 105 SAR Qty 8: 120 SAR
معمل ٦ الجزء ٢، تمرين ٣.
| row (الصف) | ماذا يُطبع؟ |
|---|---|
| 1 | خمس نجمات ثم سطر جديد |
| 2 | خمس نجمات ثم سطر جديد |
| 3 | خمس نجمات ثم سطر جديد |
- الحلقة الخارجية تدور ٣ مرات: مرة لكل صف.
- داخلها حلقة داخلية تدور ٥ مرات: مرة لكل نجمة، وتطبع النجمة مع مسافة دون سطر جديد.
- بعد انتهاء الداخلية وما زلنا داخل الخارجية، انتقل إلى سطر جديد.
كم نجمة يطبعها البرنامج في المجموع؟
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() }}
* * * * * * * * * * * * * * *
تمرين إضافي على تمرين الوحدة ٦.
public class SeatingPlan { public static void main(String[] args) { // outer for: row from 1 to 4 // print "Row " followed by row and ": " (with print) // inner for: col from 1 to 6, and print "O " (a letter and a space, with print) inside it // after the inner loop: move to a new line with println() }}
Row 1: O O O O O O Row 2: O O O O O O Row 3: O O O O O O Row 4: O O O O O O
معمل ٦ الجزء ٢، تمرين ٤.
| قيمة i | ماذا يحدث؟ |
|---|---|
| 1 | لا تساوي 5: يُطبع 1 |
| 4 | لا تساوي 5: يُطبع 4 |
| 5 | تساوي 5: تنتهي الحلقة ولا يُطبع 5 |
| 6 إلى 10 | لا تُنفَّذ أبدًا |
- اجعل الحلقة تمر على الأعداد من 1 إلى 10.
- في بداية الجسم افحص: هل العدّاد يساوي 5؟ إن كان كذلك أوقف الحلقة كلها.
- بعد الفحص اطبع العدّاد؛ فلن يصل 5 إلى سطر الطباعة.
ما آخر عدد يظهر في الناتج؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class SquaresLimit { public static void main(String[] args) { // for: i from 1 to 10 // declare square and set it to i * i // if: if square is greater than 50, run break // then print (with println) in the form: 3 squared = 9 }}
1 squared = 1 2 squared = 4 3 squared = 9 4 squared = 16 5 squared = 25 6 squared = 36 7 squared = 49
معمل ٦ الجزء ٢، تمرين ٥.
| قيمة i | ماذا يحدث؟ |
|---|---|
| 4 | لا تساوي 5: يُطبع 4 |
| 5 | تساوي 5: تُتخطى هذه الدورة فقط ولا يُطبع 5 |
| 6 | لا تساوي 5: تكمل الحلقة ويُطبع 6 |
- اجعل الحلقة تمر على الأعداد من 1 إلى 10.
- في بداية الجسم افحص: هل العدّاد يساوي 5؟ إن كان كذلك تخطَّ بقية هذه الدورة فقط.
- بعد الفحص اطبع العدّاد في سطر مستقل.
كم سطرًا في الناتج؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class Lockers { public static void main(String[] args) { // for: i from 1 to 12 // if: if i is a multiple of 3 (the remainder of i % 3 equals 0), run continue // then print (with println) in the form: Locker 1 }}
Locker 1 Locker 2 Locker 4 Locker 5 Locker 7 Locker 8 Locker 10 Locker 11
معمل ٦ الجزء ٢، التحدي الاختياري.
| row (الصف) | ما يُطبع في الصف |
|---|---|
| 1 | 1 |
| 2 | 1 2 |
| 3 | 1 2 3 |
- الحلقة الخارجية تدور ٣ مرات: مرة لكل صف.
- الحلقة الداخلية تعدّ من 1 إلى رقم الصف الحالي، فيزداد طول الصف مع كل صف.
- داخل الداخلية اطبع رقم العمود نفسه (لا رقم الصف) مع مسافة بعده.
- بعد الداخلية انتقل إلى سطر جديد.
كم رقمًا يظهر في الصف الثالث؟
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
تمرين إضافي على تمرين الوحدة ٦.
public class StarTriangle { public static void main(String[] args) { // outer for: row from 1 to 4 // inner for: col from 1 to a limit that depends on row // (4 stars in the first row, then 3, then 2, then 1) // and print "* " (a star and a space, with print) // after the inner loop: println() for a new line }}
* * * * * * * * * *