آشنایی با ساختار حلقه‌هایی از جنس do ... while در زبان برنامه‌نویسی جاوا

پس از آشنایی با نحوۀ عملکرد حلقه‌هایی از جنس for و while در دو آموزش پیشین، حال در این آموزش به معرفی نوع دیگری از حلقه‌ها تحت عنوان do ... while می‌پردازیم. به طور کلی، وجه تمایز حلقه‌ای از جنس do ... while با حلقه‌ای از جنس while در این است که در حلقه‌های do ... while حتی اگر جواب به شرط تعریف‌شده معادل با false ارزیابی شود، باز هم دستورات داخلی آن مابین علائم {  } حداقل یک مرتبه اجرا می‌شوند و این در حالی است که در حلقه‌های while چنانچه پاسخ به شرط تعیین‌شده در حلقه معادل با مقدار false ارزیابی شود، هیچ گونه دستوری در برنامۀ مورد نظر اجرا نمی‌گردد.

در واقع، ساختار حلقه‌های do ... while به گونه‌ای طراحی شده است که شرط تعیین‌شده برای حلقه پس از علائم { } سنجیده می‌شود و از همین روی ابتدا دستورات داخلی مرتبط با حلقۀ مذکور اجرا شده و سپس شرط مد نظر بررسی می‌شود و بدین ترتیب می‌توان گفت که صرف‌نظر از true یا false بودن شرط مذکور، دستورات داخلی حلقه حداقل یک مرتبه اجرا می‌شوند. حال برای روشن‌تر شدن وجه تمایز حلقه‌های while و do ... while پروژه‌ای جدید تحت عنوان DoWhileLoop به همراه کلاسی به همین نام ایجاد کرده و در آن ساختار حلقۀ while را به صورت زیر پیاده‌سازی می‌نماییم:

public class DoWhileLoop {
    public static void main(String[] args) {
        int number = 12;
        while (number <= 10) {
            System.out.println("My Number Is: " + number);
            number++;
        }
    }
}

در کد فوق، مشابه آنچه که در آموزش پیشین توضیح دادیم، با استفاده از دیتا تایپ int متغیری به نام number تعریف کرده و در حلقۀ while گفته‌ایم چنانچه مقدار متغیر number کوچک‌تر از 10 یا مساوی با آن باشد، حلقۀ مذکور تکرار شده و دستورات داخلی آن اجرا شوند اما نکتۀ قابل‌توجه در ارتباط با کد فوق این است که مقدار اولیۀ number را برابر با 12 در نظر گرفته‌ایم و بدین ترتیب شرط حلقۀ while هرگز true نمی‌شود و از همین روی با اجرای برنامۀ فوق هیچ دستوری اجرا نشده و چیزی در کنسول چاپ نمی‌گردد. حال اگر بخواهیم تا کد فوق را با استفاده از ساختار حلقۀ do ... while پیاده‌سازی نماییم، کدی به صورت زیر خواهیم داشت:

public class DoWhileLoop {
    public static void main(String[] args) {
        int number = 1;
        do {
            System.out.println("My Number Is:" + number);
            number++;
        } while (number <= 10);
    }
}

در کد فوق، با استفاده از دیتا تایپ int متغیری به نام number تعریف کرده و مقدار اولیۀ آن را برابر با عدد 1 قرار داده‌ایم سپس کیورد do را نوشته و در ادامه علائم { } را به منظور نوشتن دستورات داخلی مقابل آن درج کرده‌ایم. در ادامه، دستورات مد نظر به منظور تکرار در برنامه را داخل علائم { } بدین صورت می‌نویسیم که در هر بار تکرار حلقه ابتدا دستوری مبنی بر چاپ مقدار منتسب به متغیر number به همراه استرینگ «:My Number Is» اجرا شده سپس یک واحد به مقدار قبلیِ اختصاص‌یافته به متغیر number افزوده شده و مقدار جدید بدان اختصاص داده شود. پس از پایان بلوک مربوط به حلقۀ do ... while نیز شرط حلقه را بدین صورت تعریف کرده‌ایم که تا وقتی مقدار اختصاص‌یافته به متغیر number کوچک‌تر از 10 یا مساوی با آن است، دستورات داخلی اجرا شده و استرینگ مربوطه در کنسول چاپ گردد به طوری که با اجرای برنامۀ فوق در خروجی داریم:

My Number Is:1
My Number Is:2
My Number Is:3
My Number Is:4
My Number Is:5
My Number Is:6
My Number Is:7
My Number Is:8
My Number Is:9
My Number Is:10

همان‌طور که می‌بینیم، خروجی حاصل از اجرای برنامۀ فوق مشابه خروجی حاصل از اجرای برنامۀ مربوط به حلقۀ while می‌باشد بدین معنی که دو حلقه عملکردی مشابه ارائه داده‌اند اما با اِعمال تغییری در کد فوق، وجه تمایز این دو نوع حلقه به خوبی مشخص می‌شود که برای این منظور کد فوق را به شکل زیر بازنویسی می‌کنیم:

public class DoWhileLoop {
	public static void main(String[] args) {
		int number = 12;
		do {
			System.out.println("My Number Is:" + number);
			number++;
		} while (number <= 10);
	}
}

در واقع، تنها تغییر اِعمال‌شده در سورس‌کد فوق مربوط به مقدار اولیۀ متغیر number است که آن را برابر با عدد 12 قرار داده‌ایم. حال برنامه را اجرا می‌کنیم به طوری که در خروجی خواهیم داشت:

My Number Is:12

همان‌طور که می‌بینیم، خروجی حاصل از اجرای کد فوق برابر با عدد 12 است که به همراه استرینگ مورد نظر در کنسول چاپ شده است در حالی که اگر برنامۀ مذکور را با استفاده از حلقۀ while پیاده‌سازی می‌کردیم، هیچ مقداری در کنسول نمایش داده نمی‌شد.

در واقع، نحوۀ اجرای حلقۀ do ... while در کد فوق بدین صورت است که مقدار 12 به متغیر number منتسب شده و دستورات مرتبط با حلقۀ do اجرا می‌شود که بدین ترتیب مقدار منتسب به متغیر number معادل عدد 12 به همراه استرینگ «:My Number Is» در کنسول چاپ شده سپس یک واحد به مقدار قبلیِ منتسب به متغیر مذکور افزوده شده و در ادامه شرط حلقه بررسی می‌شود و از آنجایی که مقدار جدید متغیر number برابر با عدد 13 می‌باشد، شرط حلقه برقرار نبوده و از همین روی اجرای حلقۀ do ... while متوقف می‌گردد.

به‌کارگیری دستور break در حلقۀ while

به طور معمول، زمانی که شرط تعریف‌شده در حلقه برابر با false ارزیابی می‌شود، مفسر به طور خودکار از حلقۀ مربوطه خارج می‌گردد اما در برخی مواقع بر اساس نیاز اپلیکیشن خود قصد داریم تا برنامه‌ای را پیاده‌سازی کنیم که در صورت برقرار بودن برخی شرایط خاص، اجرای حلقه متوقف شده و مفسر از آن خارج شود که در چنین شرایطی می‌توانیم از دستور break استفاده ‌کنیم.

برای درک بهتر نحوۀ به‌کارگیری دستور break در چنین حلقه‌هایی، مجدداً پروژه قبل را مد نظر قرار داده و داخل آن کلاس جدیدی به نام ExitALoop ایجاد می‌کنیم که در ابتدا برنامۀ پیاده‌سازی شده با به‌کارگیری حلقۀ while به صورت زیر می‌باشد:

public class ExitALoop {
    public static void main(String[] args) {
        int number = 0;
        while (number < 1000) {
            number += 100;
            System.out.println("My Number Is: " + number);
        }
    }
}

در کد فوق، با اجرای حلقۀ while مادامی که مقدار متغیر number کوچک‌تر از 1000 است، هر یک از اعداد منتسب به متغیر مذکور با شروع از عدد 100 و به همراه استرینگ فوق در کنسول چاپ شده و در هر بار تکرار حلقه نیز به تعداد 100 واحد به مقدار قبلیِ منتسب به متغیر number افزوده می‌شود. بنابراین با اجرای برنامۀ فوق در خروجی خواهیم داشت:

My Number Is: 100
My Number Is: 200
My Number Is: 300
My Number Is: 400
My Number Is: 500
My Number Is: 600
My Number Is: 700
My Number Is: 800
My Number Is: 900
My Number Is: 1000

همان‌طور که مشاهده می‌کنیم، با اجرای برنامۀ فوق ابتدا صد واحد به مقدار اولیۀ متغیر number افزوده شده و به همراه استرینگ مذکور در کنسول چاپ می‌شود سپس شرط حلقه چک می‌شود که برابر با true بوده و از همین روی حلقۀ مد نظر تکرار می‌شود و این تکرار تا زمانی ادامه می‌یابد که مقدار متغیر number کوچک‌تر از 100 می‌باشد. حال فرض کنیم که می‌خواهیم حلقۀ مد نظر پس از رسیدن مقدار متغیر number به عدد 700 متوقف شده و مفسر از حلقه خارج شود که برای این منظور کد فوق را به شکل زیر تکمیل می‌کنیم:

public class ExitALoop {
    public static void main(String[] args) {
        int number = 0;
        while (number < 1000) {
            number += 100;
            System.out.println("My Number Is: " + number);
            if (number == 700) {
                break;
            }
        }
    }
} 

کاری که در کد فوق انجام داده‌ایم این است که یک دستور if داخل بلوک مرتبط با حلقۀ while تعریف کرده‌ایم مبنی بر اینکه چنانچه مقدار متغیر number معادل با عدد 700 بود، دستور break اجرا شده و مفسر از حلقه خارج شود که بالتبع در چنین شرایطی اجرای حلقه ادامه نمی‌یابد.

در واقع، مقادیر منتسب به متغیر number با شروع از عدد 100 در خروجی چاپ شده و در هر بار تکرار حلقه نیز صد واحد به مقدار قبلیِ منتسب به آن افزوده می‌شود و در هر مرتبه شرط if چک می‌کند که مقدار متغیر number برابر با عدد 700 است یا خیر که این شرط در شش مرتبۀ اول از تکرار حلقه false ارزیابی شده و دستورات داخلی آن اجرا نمی‌شوند اما با رسیدن مقدار منتسب به متغیر number به عدد 700 دستور if برابر با مقدار بولین true ارزیابی شده و از همین روی دستور داخلی آن اجرا شده و مفسر به طور کامل از حلقه خارج می‌گردد.

My Number Is: 100
My Number Is: 200
My Number Is: 300
My Number Is: 400
My Number Is: 500
My Number Is: 600
My Number Is: 700

همان‌طور که می‌بینیم، مقادیر منتسب به متغیر number تنها تا عدد 700 در کنسول چاپ شده و با رسیدن به این مقدار اجرای حلقه متوقف شده است.

به‌کارگیری دستور continue در حلقۀ while

در زبان برنامه‌نویسی جاوا دستور continue بدین منظور مورد استفاده قرار می‌گیرد که برنامه‌ای را پیاده‌سازی کنیم تا در صورت برقرار بودن برخی شرایط خاص دستوراتی در برنامه اجرا نشده و در سایر موارد دستورات مذکور به درستی اجرا گردند. به عبارت بهتر، با استفاده از دستور continue می‌توان گفت که در صورت برقرار بودن برخی شرایط، مفسر اجرای سایر دستورات برنامه را نادیده گرفته و از آن‌ها عبور می‌کند و اجرای برنامه را از ابتدا آغاز می‌کند. حال برای درک بهتر مفهوم دستور continue کد فوق را به شکل زیر بازنویسی می‌کنیم:

public class ExitALoop {
    public static void main(String[] args) {
        int number = 0;
        while (number < 1000) {
            number += 100;
            if (number == 700) {
                continue;
            }
            System.out.println("My Number Is: " + number);
        }
    }
}

در کد فوق، گفته‌ایم مادامی که مقدار متغیر number کوچک‌تر از 1000 است، تعداد صد واحد به مقدار قبلیِ منتسب به متغیر اضافه شده و به همراه استرینگ فوق در بخش کنسول چاپ شود. به علاوه، یک دستور شرطی if در کد فوق تعریف کرده‌ایم که در آن گفته‌ایم چنانچه مقدار متغیر number برابر با عدد 700 شد، اجرای دستورات بعدی نادیده گرفته شده و برنامه از ابتدا اجرا شود؛ به عبارت دیگر، زمانی که در اجرای حلقۀ فوق مقدار منتسب به متغیر number به عدد 700 رسید، اجرای سایر دستورات برنامه نادیده گرفته می‌شود و از همین روی استرینگ «My Number Is: 700» هرگز در پنجرۀ کنسول نمایش داده نمی‌شود و مفسر به ابتدای حلقه رفته و اجرای آن را از ابتدا آغاز می‌کند. بنابراین خروجی حاصل از اجرای برنامۀ فوق به صورت زیر خواهد بود:

My Number Is: 100
My Number Is: 200
My Number Is: 300
My Number Is: 400
My Number Is: 500
My Number Is: 600
My Number Is: 800
My Number Is: 900
My Number Is: 1000

همان‌طور که مشاهده می‌کنیم، استرینگی مبنی بر نمایش عدد 700 در کنسول چاپ نشده است چرا که با استفاده از دستور continue گفته‌ایم مفسر با رسیدن مقدار متغیر number به عدد 700 سایر دستورات برنامه را نادیده گرفته و از ابتدا برنامه را اجرا نماید.

در این آموزش به معرفی حلقۀ do ... while پرداخته و تفاوت‌های آن با ساختار حلقه‌هایی از جنس while را بیان کردیم و گفتیم که صرف‌نظر از true یا false بودن شرط تعیین‌شدۀ برنامه دستورات داخلی حلقه حداقل یک مرتبه اجرا می‌شوند. در ادامه، به بررسی کاربرد دستور break پرداختیم تا ببینیم چگونه می‌توان در صورت برقرار بودن برخی شرایط خاص اجرای حلقه را متوقف کرد و در نهایت هم دستور continue را معرفی کرده و کاربرد آن در اجرای دستورات داخلی حلقۀ while را با ذکر مثالی تشریح نمودیم.