آموزش جاوا (فصل 1)

ساخت اولین پروژه در زبان برنامه‌نویسی جاوا


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

در آموزش‌های گذشته اشاره‌ای به مفهوم کامپایل در برنامه‌نویسی داشتیم اما به منظور درک بهتر این موضوع، پیش از ادامۀ آموزش نیاز است تا به بررسی بیشتر مفهوم Compile در برنامه‌نویسی بپردازیم چرا که در طول آموزش‌ها از این واژه بسیار استفاده خواهیم کرد.

معنای لغوی واژۀ فوق‌الذکر در زبان فارسی «جمع‌آوری» می‌باشد. به طور مثال، نویسنده‌ای که برای تألیف یک کتاب از منابع مختلف استفاده می‌کند و از جاهای گوناگون مطالب کتابش را تهیه می‌کند، در واقع این کتاب را اصطلاحاً کامپایل نموده است. در برنامه‌نویسی نیز این واژه به مفهومی اطلاق می‌شود که در آن دولوپرها تعدادی Statement (دستور) را نوشته و قصد دارند تا سورس‌کد خود را به زبانی قابل‌فهم برای ماشین (صفر و یک) مبدل سازند. به عبارت دیگر، در حین کامپایل شدن برنامه، دستورات نوشته‌شده به دستوراتی تبدیل می‌شوند که برای کامپیوتر قابل‌فهم بوده و در نهایت برنامه اجرا می‌گردد. 

در ابتدا به منظور ایجاد یک پروژۀ جدید در نرم‌افزار اکلیپس، از منوی File گزینۀ New سپس Java Project را انتخاب می‌کنیم (در صورت عدم مشاهدۀ گزینه‌ای تحت عنوان Java Project می‌توانيد روی گزینۀ Project کلیک کرده و در پنجرۀ بازشده آیتم Java Project را انتخاب نمایید.) سپس در بخش Project Name نامی دلخواه برای پروژۀ خود در نظر می‌گیریم که در این آموزش نام پیشنهادی Hello World می‌باشد سپس در بخش JRE نسخۀ مد نظر برای اجرای کدهای جاوای خود را مشخص ساخته و گزینۀ Use an execution environment JRE را انتخاب می‌کنیم. در بخش Project Layout گزینۀ Create separate folders for sources and class files را انتخاب کرده و مابقی گزینه‌ها را در حالت دیفالت (پیش‌فرض) گذاشته و تغییری در آن‌ها ایجاد نمی‌کنیم و در نهایت گزینۀ Finish را می‌زنیم (اگر به خاطر داشته باشید در آموزش ابزارهای برنامه‌نویسی با زبان جاوا، نحوۀ نصب JDK و فعال‌سازی آن در محیط برنامه‌نویسی اکلیپس را آموزش دادیم. در واقع، با نصب JDK به JRE نیز دسترسی خواهیم داشت که برای اجرای برنامه‌های جاوا ضروری است.)

تا اینجا اولین گام برای ساخت یک پروژۀ جاوا را برداشته‌ایم که در این مرحله در محیط اکلیپس و در بخش Package Explorer می‌باید فولدر پروژه‌ای تحت عنوان Hello World را داشته باشیم. اکنون با کلیک راست بر روی پروژه‌ای که جدیداً ساخته‌ایم، گزینۀ New را انتخاب کرده سپس از میان گزینه‌های موجود روی گزینۀ Class کلیک می‌کنیم که در نتیجه پنجره‌ای تحت عنوان New Java Class باز می‌شود (همچنین به منظور دسترسی به این پنجره می‌توان از منوی اصلی گزینۀ File را انتخاب نموده سپس روی گزینۀ New کلیک کرد و در نهایت گزینۀ Class را انتخاب کرد.) در پنجرۀ مربوط به ساخت یک کلاس جدید و در بخش Name نامی را برای کلاس مد نظر انتخاب می‌کنیم که در اینجا ما نام HelloWorld را انتخاب کرده‌ایم (این نام می‌باید با نام فایلی که در این مرحله با پسوند java. ایجاد می‌گردد، یکسان باشد که اکلیپس این کار را به صورت خودکار برای ما انجام می‌دهد.) هشدارچنانچه نام کلاس با نام فایل دارای پسوند java. یکی نباشد، در حین کامپایل شدن برنامه و بسته به اینکه کلاس ایجادشده در کجای برنامه مورد استفاده قرار ‌می‌گیرد کامپایل سورس‌کد با ارور مواجه می‌گردد و از همین روی در صورتی که نامی غیر از نام مشابه با برنامۀ اصلی انتخاب کرده‌اید، می‌توانید روی فایل مد نظر کلیک راست نموده و از بخش Refactor گزینۀ Rename را انتخاب نمایید و نام فایل خود را تغییر دهید.

در ادامۀ ساخت اولین پروژۀ جاوای خود، لازم به یادآوری است که نام انتخابی برای کلاس‌مان بهتر است تا با حرف بزرگ شروع شود. در حقیقت، برای نام‌گذاری یک کلاس نمی‌توان از علائمی همچون , و - استفاده کرد و تنها مجاز به استفاده از علامت _ در نام‌گذاری هستیم (همچنین مجاز به استفاده از اِسپیس نیز در نام‌گذاری نیستیم.)

در ادامه، تیک آیتم (public static void main(String[] args را می‌زنیم و دیگر گزینه‌ها را در حالت پیش‌فرض قرار داده و دکمۀ Finish را انتخاب می‌کنیم. اکنون درون کلاس HelloWorld خود می‌باید کدهایی به شکل زیر مشاهده کنیم:

public class HelloWorld {
    /**
     * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    }
}

در کد فوق، دستور مربوط به سطر پنجم به مفسر جاوا می‌گوید که این نقطه به منزلۀ نقطۀ آغازین برنامه است (در حقیقت، کلیدواژۀ main مشخص‌کنندۀ نقطۀ آغازین برنامۀ مد نظر می‌باشد.) به علاوه اینکه همان‌طور که ما در نگارش از پرانتز برای تبدیل تعدادی واژه به یک گروه استفاده می‌کنیم همچون واژگان (جاوا، زبان برنامه‌نویسی و اکلیپس)، در زبان برنامه‌نویسی جاوا نیز به منظور نشان دادن عناصری که به یک گروه تعلق دارند از علائم { } استفاده می‌کنیم. به عبارت دیگر، هر آنچه که مابین علائم { } قرار می‌گیرد متعلق به یک گروه می‌باشند که به این گروه از دستورات در زبان‌های برنامه‌نویسی اصطلاحاً Block گفته می‌شود.

در کد فوق، پس از واژۀ HelloWorld علائم { } نشانگر یک بلوک کد می‌باشند که کل برنامه جاوای فوق را شامل می‌شوند. نکته‌ای که در اینجا می‌باید مد نظر قرار داد این است که بلوک‌های کد را می‌توان درون دیگر بلوک‌ها نیز تعریف کرد و همان‌طور که در کد فوق می‌بینیم، یک بلوک کد دیگر از انتهای سطر پنجم تا ششم مشاهده می‌شود که در برگیرندۀ متدی به نام main است (در بخش‌های آتی به توضیح مفهوم متد و نحوۀ تعریف آن در زبان برنامه‌نویسی جاوا می‌پردازیم.)

در این مرحله اولین برنامۀ جاوای خود را با موفقیت نوشته‌ایم اما چنانچه از منوی اصلی گزینۀ Run و مجدداً گزینۀ Run را انتخاب کنیم هیچ خروجی خاصی را مشاهده نخواهیم کرد چرا که در بخش main که به منزلۀ نقطۀ آغازین برنامه است، هیچ چیزی به جز یک خط کامنت نوشته نشده است که آن هم از دید کامپایلر مخفی می‌ماند (در آموزش‌های آینده با تک‌تک کلیدواژه‌های سطر پنجم و کارکرد آن‌ها در زبان برنامه‌نویسی جاوا آشنا خواهیم شد.)

آشنایی با مفهوم کامنت در برنامه‌نویسی

در خط ششم از کد فوق علائم // را می‌بینیم که برای اصطلاحاً Comment کردن بخشی از کد مورد استفاده قرار می‌گیرند. در حقیقت، کامنت‌ها در زبان‌های برنامه‌نویسی صرفاً جهت خوانایی کد و به منظور استفادۀ خود برنامه‌نویس به کار گرفته می‌شوند و کامپایلر/مفسر قادر به اجرای آن‌ها نمی‌باشد. به عبارت دیگر، چنانچه بخواهیم نکته‌ای را درون سورس‌کد خود بنویسیم که از یکسو در حین اجرا از دید کامپایلر مخفی بماند و از سوی دیگر مسئله‌ای را به خودمان و احتمالاً سایر دولوپرها در آینده یادآوری کنیم، از کامنت‌‌‌ها استفاده می‌کنیم (در زبان برنامه‌نویسی جاوا سه روش کامنت‌گذاری داریم که در ادامه به تفصیل در مورد آن‌ها توضیح می‌دهیم.)

در واقع، نحوۀ استفاده از کامنت خطی بدین صورت است که در ابتدای سمت چپ از سطر مد نظر خود علائم // را قرار می‌دهیم و بدین ترتیب آن سطر از دید کامپایلر مخفی می‌ماند (توجه داشته باشیم که به محض اینکه علائم فوق را تایپ کنیم، سطر مربوط به کد به خاکستری تغییر رنگ می‌دهد بدین معنی که سطر مذکور به یک کامنت تبدیل شده است و از این پس در تمامی سورس‌کدهای نوشته‌شده به این زبان، خاکستری بودن سطر یا سطرهایی از کد به معنای کامنت بودن آن‌ها می‌باشد.) روش دیگری که برای کامنت کردن سطری از کد پیشنهاد می‌شود این است که نشانگر ماوس خود را روی آن سطر قرار داده و کلیدهای Ctrl و علامت / را به صورت هم‌زمان فشار دهیم (چنانچه این روش را روی خطی از کد اِعمال کنید که از قبل کامنت شده است، کامنت مربوطه از بین خواهد رفت.)

آشنایی با مفهوم متغیر در زبان برنامه‌نویسی جاوا


در فرآیند توسعهٔ نرم‌افزار، دولوپرها نیاز دارند تا اطلاعات مورد نظر خود را در جایی ذخیره سازند که برای این منظور می‌توان داده‌ها را بسته به نوع‌شان در یک Variable (متغیر) ذخیره کرد. به عبارتی، هر متغیری همچون ظرفی است که نوع خاصی از دیتا یا داده را در خود ذخیره می‌سازد (در طول آموزش‌ها با انواع متغیرها، نحوۀ به‌کارگیری، اختصاص مقدار، انجام محاسبات ریاضیاتی همچون جمع، تفریق و سایر عملیاتی از این دست میان آن‌ها آشنا خواهیم شد.)

حال مثال مربوط به آموزش گذشته را مد نظر قرار می‌دهیم که در آن قصد داشتیم تا استرینگ «In the Name of God» را در خروجی نمایش دهیم و از همین روی نیاز به متغیری داریم تا مقداری از جنس کلمه، جمله یا پاراگراف را در آن نگهداری کنیم که برای این منظور می‌توانیم از کلاسی تحت عنوان String در زبان برنامه‌نویسی جاوا استفاده کنیم. همچنین توجه داشته باشیم که هر متغیر از دو بخش تشکیل می‌شود که بخش اول تایپ (نوع) خودِ متغیر است که در این جا شیئ ساخته‌شده از روی کلاس String می‌باشد و بخش دوم مربوط به نام متغیر است که کاملاً اختیاری می‌باشد اما در عین حال اصول نام‌گذاری در زبان جاوا در حین انتخاب نام باید رعایت شوند. نکتهاسامی مربوط به نام کلاس‌ها بهتر است تا با حرف اول بزرگ نوشته شده و این در حالی است که نام متغیرها نیز به منظور افزایش خوانایی کد و همچنین تشخیص آن‌ها از متدهای تعریف‌شده در برنامه با حرف اول کوچک نوشته می‌شوند.

در همین راستا، به منظور نگهداری استرینگ فوق‌الذکر متغیری از جنس کلاس String تحت عنوان text تعریف می‌کنیم که مقدار منتسب به آن را نیز می‌باید مابین علائم " " قرار دهیم. همچنین به منظور اختصاص مقدار به هر یک از متغیرها، پس از نام متغیر علامت = را قرار داده و در نهایت یک ; تایپ می‌کنیم (در واقع، در زبان برنامه‌نویسی جاوا و همچنین برخی دیگر از زبان‌های برنامه‌نویسی علامت ; عملکردی همچون نقطه در حین نگارش متون فارسی دارا است. به عبارت دیگر، با قرار دادن یک ; در انتهای دستورها، به مفسر جاوا می‌گوییم که به پایان دستور مد نظر رسیده است.) در نهایت، متغیر text را به صورت زیر تعریف می‌کنیم:

String text = "In the name of God";

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

public class HelloWorld {
    public static void main(String[] args) {
        String text = "In the name of God";
    }
}

در واقع، در سطر سوم از کد فوق متغیری تعریف کرده‌ایم که استرینگ «In the Name of God» را نگهداری می‌کند و برای اینکه بتوانیم استرینگ ذخیره‌شده در این متغیر را در خروجی چاپ کنیم نیاز به ساختاری داریم تا آن را به کامپایلر فرستاده و نهایتاً در خروجی نمایش دهد که در ادامه به توضیح نحوۀ پیاده‌سازی این ساختار می‌پردازیم.

در حقیقت، ;()System.out.println دستوری که می‌تواند این کار را برای‌مان انجام دهد و نحوۀ کارکرد این دستور بدین صورت است که هر آنچه مابین دو پرانتز قرار دارد را در خروجی چاپ می‌کند و سپس نشانگر به سطر بعدی می‌رود (در محیط برنامه‌نویسی اکلیپس، خروجی حاصل از اجرای دستور فوق در قسمت کنسول نمایش داده می‌شود.) بنابراین در ادامه نیاز است تا نام متغیر text را داخل پرانتزهای ()println بنویسیم.به خاطر داشته باشیدیکی از ویژگی‌های اکثر زبان‌های برنامه‌نویسی Case Sensitive بودن آن‌ها است بدین معنی که به بزرگ و کوچک بودن حروف حساس هستند. برای مثال، چنانچه کلمۀ System با حرف کوچک به صورت system نوشته شود، اجرای برنامه با مشکل مواجه می‌شود چرا که System جزو کیوردهای زبان جاوا می‌باشد که فقط با حرف اول بزرگ برای این زبان قابل‌فهم است.

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

public class HelloWorld {
    public static void main(String[] args) {
        String text = "In the name of God";
        System.out.println(text);
    }
}

پیش از اجرای برنامه نیاز داریم تا ابتدا سورس‌کد بالا را کامپایل نماییم؛ به عبارتی، کدها را به دستوراتی قابل‌فهم برای سیستم خود مبدل سازیم که برای این منظور از منوی اصلی گزینۀ Run و مجدداً گزینۀ Run را انتخاب کرده و بدین ترتیب برنامه پس از کامپایل شدن به صورت خودکار توسط اکلیپس اجرا می‌شود و در بخش کنسول نرم‌افزار اکلیپس در قسمت پایین مقدار منتسب به متغیر text را نمایش می‌دهد.

همچنین در صورتی که مقدار مرتبط با متغیر text را تغییر دهیم و استرینگ دیگری را داخل علائم " " بنویسیم، این متغیر مقدار قبلی خود را از دست داده و مقدار جدید را در خود ذخیره می‌سازد و از همین روی در صورت اجرای مجدد برنامه، مقدار جدید منتسب به متغیر text در کنسول نمایش داده خواهد شد.

آشنایی با مفهوم کلیدواژه در زبان برنامه‌نویسی جاوا


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

در واقع، زبانی که بدان تکلم می‌کنیم از دستور زبانی شامل یکسری قاعده و قانون و همچنین تعدادی واژه تشکیل شده است که این واژگان بر اساس قواعد خاصی در کنار یکدیگر قرار می‌گیرند تا بدین ترتیب با به‌کارگیری آن‌ها بتوانیم با یکدیگر ارتباط برقرار سازیم. زبان برنامه‌نویسی جاوا نیز همچون زبان فارسی از یکسری قواعد، اسامی و غیره تشکیل شده و برای آنکه بخش‌های مختلف برنامه‌های نوشته‌شده با زبان جاوا با یکدیگر ارتباط برقرار سازند، می‌باید اصول مربوطه را در کدنویسی با این زبان کاملاً رعایت کرد.

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

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

به طور کلی، بخش‌های تشکیل‌دهندۀ زبان جاوا به سه دسته تقسیم می‌شوند که عبارتند از:

– Keyword: در حقیقت، کیورد به واژه‌ای در زبان برنامه‌نویسی جاوا اطلاق می‌شود که همواره دارای معنایی ثابت است و هیچ فرقی هم نمی‌کند که آن را در کجای برنامۀ خود مورد استفاده قرار دهیم. به طور مثال، واژۀ میز در زبان فارسی همواره دارای معنای ثابتی است و اینکه چه کسی آن را به کار می‌برد تفاوتی در معنا و کاربرد آن ایجاد نمی‌کند. در زبان برنامه‌نویسی جاوا نیز واژه‌ای همچون boolean یک کیورد است و همواره داری معنای ثابتی می‌باشد و از جمله دیگر کیوردهای این زبان می‌توان به if و else یا char اشاره کرد.

– Identifier: در زبان برنامه‌نویسی جاوا Identifier به واژه‌ای اطلاق می‌شود که برای نامیدن چیزی مورد استفاده قرار می‌گیرد. در واقع، در آموزش آشنایی با مفهوم متغیرها در زبان برنامه‌نویسی جاوا، برای متغیر خود نامی همچون text را در نظر گرفتیم که در اینجا text یک واژه از نوع Identifier (شناسه) می‌باشد و این در حالی است که ما می‌توانستیم به جای این واژه از واژگان دیگری همچون myString یا stringOfGod و یا هر چیز دیگری استفاده کنیم (چنانچه بخواهیم زبان برنامه‌نویسی جاوا را با زبان فارسی مقایسه کنیم، می‌توان گفت که واژگانی از قبیل اشکان، کیانا، احسان و غیره نیز از نوع شناسه می‌باشند.)

– API Identifier: در زبان فارسی واژه‌هایی داریم که از نوع Identifier می‌باشند؛ به عبارتی، یکسری نام هستند که به چیز خاصی اطلاق می‌شوند اما این گروه از واژگان در طول زمان نهادینه شده و پس از مدتی صرفاً به منظور اشاره به چیزی خاص مورد استفاده قرار می‌گیرند همچون واژۀ مولوی که در ابتدا یک واژه از نوع شناسه بوده اما پس از گذشت زمان به یک شناسۀ خاص تبدیل شده است که فقط به شاعر بزرگ ایرانی اشاره می‌کند (توجه داشته باشیم که API مخفف واژگانApplication Programming Interface است.) در زبان برنامه‌نویسی جاوا نیز تعدادی واژه وجود دارند که اصطلاحاً به آن‌ها API Identifier گفته می‌شود که این گروه از واژگان یکسری واژۀ معمولی هستند اما در عین حال از آنجایی که طراحان و توسعه‌دهندگان این زبان به کرات از آن‌ها استفاده کرده‌اند، تبدیل به واژگانی شده‌اند که صرفاً به یک چیز خاص اشاره کرده و عملکردی همانند واژۀ مولوی دارند که از آن جمله می‌توان به واژگانی همچون println ،out و Stringیا سایر واژگانی مانند main و System اشاره کرد.

آشنایی با مفهوم متد در زبان برنامه نویسی جاوا


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

public class HelloWorld {
    public static void main(String[] args) {
        String text = "In the name of God";
        System.out.println(text);
    }
}

کد فوق، مربوط به اولین پروژۀ جاوایی است که در آموزش‌های گذشته آن را پیاده سازی کردیم و در تفسیر آن باید گفت که در سطر اول با به‌کارگیری کیورد class کلاسی به نام HelloWorld نوشته‌ایم که در آن هر یک از علائم { } پس از نام کلاس و در انتهای سطر ششم تشکیل‌دهندۀ یک بلوک هستند و کل برنامۀ فوق را شامل می‌شوند و در سطر دوم متدی به نام ()main تعریف کرده‌ایم که در آموزش‌های آتی به تشریح هر یک از کیوردهای مربوط نحوۀ تعریف این متد خواهیم پرداخت. به خاطر داشته باشیدذکر کیورد public پیش از نام کلاس منجر بدین می‌شود تا کلاس مد نظر از طریق سایر کلاس‌های تعریف‌شده در تمامی پکیج‌های اپلیکشن قابل‌دسترسی باشد و در غیر این صورت نیز زبان برنامه‌نویسی جاوا به صورت دیفالت سطح دسترسی به اصطلاح package را برای کلاس در نظر می‌گیرد و بدین ترتیب تنها از کلاس‌های تعریف‌شده در پکیج مرتبط با کلاس مد نظر می‌توان به آن دسترسی داشت.

اما در ارتباط با نحوۀ عملکرد متد ()main باید گفت که با تعریف این متد، به کامپایلر جاوا دستور داده می‌شود که نقطۀ آغازین برنامه از سطر مربوط به تعریف این متد بوده و در حین اجرا نیز سیستم به صورت خودکار برنامه نوشته‌شده را از متد ()main به بعد اجرا می‌نماید. در خطوط سوم و چهارم یکسری دستورات مبنی بر چاپ استرینگ «In the name of God» در کنسول را نوشته‌ایم که در ادامه هر یک از این دستورات را مورد بررسی قرار می‌دهیم.

در متد ()main ابتدا یک آبجکت از نوع استرینگ متعلق به کلاس String تحت عنوان text ساخته‌ایم و استرینگ «In the name of God» را بدان منتسب کرده‌ایم که در این دستور کیورد String یک به اصطلاح API Identifier است و واژۀ text نیز یک Identifier می‌باشد (جهت کسب اطلاعات بیشتر در رابطه با هر یک از این مفاهیم به آموزش آشنایی با مفهوم کلیدواژه در زبان برنامه‌نویسی جاوا مراجعه نمایید.) دستور سطر چهارم نیز متشکل از سه کیورد out ،printlnو System می‌باشد که همگی یکسری API Identifier در زبان برنامه‌نویسی جاوا می‌باشند که این وظیفه را دارند تا متغیرtext از نوع استرینگ را در کنسول چاپ کنند.

به طور کلی، می‌توان گفت که متدها مجموعه‌ای از دستورات هستند که به منظور انجام تَسکی خاص نوشته شده‌اند که در صورت فراخوانی فانکشن مد نظر تَسک‌ مربوطه اجرا شده و نتیجۀ حاصل از اجرا را ریترن می‌کند (همچنین توجه داشته باشیم که برخی از متدها به منظور انجام یکسری کارهای خاص پیاده‌سازی شده و چیزی را در خروجی ریترن نمی‌کنند.) همچنین برخی زبان‌های برنامه‌نویسی از دو مفهوم تحت عنوان Method و Function برخوردار هستند که در ادامه قصد داریم تا به تشریح تفاوت آن‌ها بپردازیم.

آشنایی با تفاوت‌های مابین متد و فانکشن

در حالت کلی، متدها و فانکشن‌ها کاربردی یکسان داشته و هر دو به منظور تعریف یکسری بلوک کد سپس فراخوانی آن‌ها جهت انجام برخی دستورات مورد استفاده قرار می‌گیرند مضاف بر اینکه هر دو می‌توانند با اجرای یکسری دستورات داخلی نتیجه‌ای را در خروجی ریترن کنند اما در عین حال برخی تفاوت‌هایی با یگدیگر دارند مثلاً اینکه متدها صرفاً در داخل کلاس تعریف شده و از همین روی به منظور فراخوانی آن‌ها نیاز به ساخت آبجکت از روی کلاس مربوطه داریم تا بدین وسیله متد مد نظر خود را بر روی آبجکت ساخته‌شده از روی آن کلاس فراخوانی کنیم در حالی فانکشن‌ها را می‌توان در تمامی نقاط برنامه تعریف کرده و به منظور فراخوانی نیازی به ساخت آبجکت ندارند به طوری که با به‌کارگیری نام‌شان می‌توان آن‌ها را کال (فراخوانی) کرد.

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

بررسی انواع ارورها در زبان برنامه‌نویسی جاوا


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

ارورهای Compile-time

گروه اول ارورهایی هستند که از نوع اصطلاحاً Compile-time می‌باشند. به طور مثال، دستور;()system.out.println در مقایسه با دستور ;()System.out.println اشتباه است چرا که در آموزش‌های گذشته اشاره کردیم که زبان برنامه‌نویسی جاوا نسبت به بزرگ و کوچک بودن حروف حساس بوده و در این مثال نیز حرف اول از کیورد System به صورت کوچک نوشته شده است که همین مسئله منجر به بروز مشکل در فرآیند کامپایل برنامه می‌گردد. به علاوه، مجموعۀ ارورهای Compile-time از جمله ارورهایی هستند که توسط محیط‌های برنامه‌نویسی همچون نرم‌افزار اکلیپس تشخیص داده شده و به برنامه‌نویس اخطار داده می‌شوند که از همین روی به سادگی می‌توان آن‌ها را رفع نمود که جهت درک بهتر مطلب فوق چند مثال کاربردی را در ادامه مورد بررسی قرار می‌دهیم.

در ابتدا بر اساس آنچه که در آموزش‌های پیشین آموختیم، پروژه‌ای در محیط برنامه‌نویسی اکلیپس ایجاد کرده و یک کلاس با نام دلخواهی همچون CompileTimeErrors تعریف می‌کنیم (توجه داشته باشیم که نام کلاس می‌باید دقیقاً مشابه نام فایل ساخته‌شده در طی ایجاد پروژه با پسوند java. باشد که در غیر این صورت اجرای برنامه با مشکل مواجه خواهد شد.) و پس از ایجاد پروژه باید کدی مشابه زیر داشته باشیم:

public class CompileTimeErrors {
    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    }
}

حال قصد داریم تا استرینگ «.This is a compile time error» را در کنسول نمایش دهیم که از همین روی نیاز است تا کد فوق را به شکل زیر تکمیل نماییم:

public class CompileTimeErrors {
    public static void main(String[] args) {
        System.out.println("This is a compile time error.");
    }
}

کد فوق یک برنامۀ کامل و صحیح در زبان برنامه‌نویسی جاوا است که بدون هیچ مشکلی اجرا می‌شود و لازم به یادآوری است که دستورهای کامنت‌شده را حذف نموده‌ایم چرا که هیچ تأثیری در نحوۀ اجرای برنامه نداشتند. حال در این مرحله قصد داریم تا عمداً تغییری در سورس‌کد ایجاد کنیم تا کامپایل برنامه منجر به بروز ارور شده و ببینیم که محیط برنامه‌نویسی اکلیپس چگونه ارور مربوطه را مشخص می‌سازد. برای این منظور، کیورد out که می‌باید حتماً با حروف کوچک نوشته شود را با حروف بزرگ و به صورت OUT می‌نویسیم که به محض تغییر واژۀ out به OUT و کامپایل مجدد سورس‌کد، آی‌دی‌ای اکلیپس دور واژۀ «OUT» یک خط‌چین قرار می‌دهد.

در واقع، در آی‌دی‌ای اکلیپس از روی دو مورد به راحتی می‌توان واژگانی را تشخیص داد که در حین کامپایل برنامه منجر به بروز ارور شده‌اند که عبارتند از:

– مورد اول که در بالا بدان اشاره کردیم این است که آی‌دی‌ای اکلیپس کلمه‌ای که منجر به بروز ارور شده است را با خط‌چین مشخص می‌کند و با قرار دادن نشانگر ماوس خود روی واژۀ مشکل‌زا می‌توانیم متوجه اروری شویم که نرم‌افزار اکلیپس آن را شناسایی کرده است بدین صورت که پیامی مبنی بر علت بروز مشکل مربوطه قابل‌مشاهده می‌باشد که در این مثال با نگاه داشتن نشانگر ماوس روی واژۀ OUT شاهد پیغامی در قالب عبارت «OUT cannot be resolved or is not a field» خواهیم بود به علاوه اینکه آی‌دی‌ای اکلیپس یکسری پیشنهاد نیز به منظور رفع ارور مربوطه ارائه می‌دهد که برای مثال در مورد واژۀ OUT پیشنهاد تغییر آن به out را شاهد هستیم.

– در مورد دوم نیز کنار نام فایل مربوط به پروژه که در اینجا CompileTimeError.java است، علامت هشداری مشاهده می‌شود که نشان‌دهندۀ وجود مشکلی در برنامه می‌باشد. 

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

ارورهای Unchecked Runtime Exception

همچنین نوع دیگری از ارورها تحت عنوان Unchecked Runtime Exception شناخته می‌شوند که در صورت بروز چنین ارورهایی برنامه‌نویسان متوجه هیچ گونه اخطاری در سورس‌کد مبنی بر وجود مشکل در حین کامپایل برنامه نمی‌شوند اما این در حالی است که روند اجرای برنامه هم به صورت کامل انجام نمی‌شود که در چنین شرایطی می‌توان گفت که کامپایلر جاوا توان اجرای دستورات نوشته‌شده در سورس‌کد را ندارد.

به طور مثال، فرض کنیم که یک متغیر از جنس int یا عدد صحیح داریم که مقدار اختصاص داده‌شده به آن معادل1،000،000 است که در این صورت در حین نوشتن برنامه با هیچ گونه مشکلی مواجه نخواهیم شد اما به محض کامپایل سورس‌کد با ارور مواجه خواهیم شد. در حقیقت، اِشکال کار مربوط به قرار دادن علامت کاما مابین ارقام عدد است و از همین روی کامپایلر جاوا قادر بر کامپایل برنامه نخواهد بود که به منظور رفع این مشکل می‌باید عدد فوق را به شکل1000000 تغییر دهیم. به طور کلی، لازم به یادآوری است که نرم‌افزار اکلیپس توانایی تشخیص چنین مشکلاتی که ممکن است موجب ایجاد مشکل در حین کامپایل برنامه شوند را ندارد.به خاطر داشته باشیدارورهای ایجادشده در برنامه‌نویسی اصطلاحاً Bug نامیده می‌شوند که به فرآیند مشکل‌یابی و رفع آن‌ها نیز Debugging گفته می‌شود و تسلط به نحوۀ دیباگ کردن ارورهای اپلیکیشن از جمله مهارت‌هایی است که هر برنامه‌نویسی می‌باید از آن برخوردار باشد.

برای روشن‌تر شدن مسئلۀ فوق مثالی از دنیای واقعی می‌زنیم که در آن آدرس مکانی را از شخصی سؤال می‌کنیم و پاسخی بدین صورت دریافت می‌کنیم که می‌باید مستقیم برویم تا به یک چهارراه رسیده سپس به سمت راست حرکت کنیم که در این مرحله به سینمایی در خیابان روبه‌روی خود خواهیم رسید. حال فرض می‌کنیم که مسیر پیش روی خود را طبق آدرس داده‌شده طی کنیم و در نهایت به جای مشاهدۀ سینمایی در خیابان روبه‌روی خود به یک دیوار سیمانی برسیم! در چنین شرایطی ما در ابتدا از نادرست بودن آدرس مذکور اطلاع نداشتیم بلکه با طی مسیر متوجه آن شدیم که در مورد بروز ارورهای به اصطلاح Unchecked Runtime Exception نیز قضیه به همین شکل است به طوری که از بدو امر کامپایلر جاوا از وجود مشکل در برنامه ناآگاه بوده و نمی‌تواند بروز خطا در حین کامپایل برنامه را پیش‌بینی کند.

ارورهای Logical

دستۀ دیگرِ ارورها به اصطلاح Logical یا «منطقی» هستند که در صورت بروز چنین ارورهایی نرم‌افزار اکلیپس هیچ گونه خطایی را در معرض دید برنامه‌نویس قرار نمی‌دهد و برنامه هم به طور کامل اجرا می‌شود اما این در حالی است که پاسخ دریافت‌شده در نتیجۀ اجرای سورس‌کد صحیح نمی‌باشد. به منظور درک بهتر این موضوع به مثال فوق باز می‌گردیم که در آن آدرس داده‌شده بدین صورت است که به جای حرکت به سمت راست باید به سمت چپ برویم!

در واقع، ارورهای منطقی جزو چالش‌برانگیزترین ارورهای موجود در برنامه‌نویسی می‌باشند و بالتبع رفع آن‌ها نیز در مقایسه با سایر ارورها دشوارتر است مضاف بر اینکه برنامه‌نویسان در اکثر مواقع متوجه ارورهای منطقی برنامه نمی‌شوند که در آینده و با پیشرفت توسعۀ نرم‌افزار مد نظر مشکلات فراوانی را برای ایشان به وجود می‌آورند. برای درک بهتر ماهیت ارورهای منطقی در زبان جاوا و به عنوان یک مثال ساده از این دست ارورها، کد زیر را مد نظر قرار می‌دهیم:

public class HelloWorld {
    public static void main(String[] args) {
        int numA = 4;
        int numB = 20;
        System.out.println("The sum is " + numA + numB);
    }
}

در کد فوق، دو متغیر از جنس int یا عدد صحیح تحت عناوین numA و numB تعریف کرده و به ترتیب اعداد 4 و 20 را به هر یک اختصاص داده‌ایم و در دستور سطر پنجم نیز گفته‌ایم مقدار حاصل از جمع دو عدد منتسب به هر یک از دو متغیر مذکور را با استرینگ «The sum is» کانکت کرده و در کنسول چاپ کند. حال کد فوق را اجرا می‌کنیم که خروجی حاصل از آن به صورت زیر می‌باشد:

The sum is 420

در واقع، نتیجۀ حاصل از اجرای کد فوق با نتیجۀ مورد انتظار از آن متفاوت است و در چنین شرایطی می‌توان گفت که سورس‌کد مد نظر دارای ارور منطقی می‌باشد. در توضیح علت بروز چنین خطایی باید گفت که در زبان برنامه‌نویسی جاوا چنانچه بخواهیم مقادیری از جنس عدد صحیح و استرینگ را با به‌کارگیری عملگر + جمع کنیم، مقدارهای عددی به صورت خودکار از جنس استرینگ شناسایی شده و با سایر استرینگ‌ها کانکت می‌شوند و بدین ترتیب اعداد منتسب به دو متغیر numA و numB در قالب دو مقدار از جنس استرینگ با استرینگ «The sum is» کانکت می‌شوند (در آموزش‌های آتی با انواع عملگرها و نحوۀ به‌کارگیری آن‌ها در زبان برنامه‌نویسی جاوا آشنا می‌شویم.)

حال به منظور رفع چنین اروری در برنامۀ فوق، دستور numA + numB را داخل علائم () قرار می‌دهیم که در این صورت مفسر جاوا با رسیدن به سطر پنجم ابتدا محاسبات مربوط به دستورات داخل علائم () را انجام می‌دهد و بدین ترتیب دو مقدار از جنس عدد را با یکدیگر جمع کرده و در ادامه مقدار حاصل را با استرینگ «The sum is» کانکت کرده و در کنسول چاپ می‌کند که برای این منظور نیاز است تا کد فوق را به صورت زیر تغییر دهیم:

public class HelloWorld {
    public static void main(String[] args) {
        int numA = 4;
        int numB = 20;
        System.out.println("The sum is " + (numA + numB));
    }
}

همان‌طور که پیش‌تر اشاره کردیم، در سطر پنجم ابتدا دستور  numA + numB اجرا شده و دو عدد 4 و 20 با یکدیگر جمع می‌شوند و در ادامه مقدار حاصل از جمع آن‌ها که معادل عدد 24 است با استرینگ «The sum is» کانکت می‌‌شود که بدین ترتیب خروجی زیر در کنسول نمایش داده می‌شود:

The sum is 24

همچنین می‌توانیم به صورت جداگانه مقدار حاصل از جمع دو عدد را محاسبه کرده و آن را به متغیری اختصاص دهیم سپس متغیر مذکور را به عنوان آرگومان ورودی به متد ()println از دستور ;()System.out.println بدهیم که برای این منظور کدی مانند زیر خواهیم داشت:

public class HelloWorld {
    public static void main(String[] args) {
        int numA = 4;
        int numB = 20;
        int total = numA + numB;
        System.out.println("The sum is " + total);
    }
}

همان‌طور که ملاحظه می‌شود، متغیری از جنس int تحت عنوان total تعریف کرده و مقدار حاصل از جمع اعداد منتسب به دو متغیر numA و numB را به آن اختصاص داده‌ایم و بدین ترتیب دو عدد با هم جمع شده و در سطر پنجم نیز با استرینگ مربوطه کانکت شده و در کنسول نمایش داده می‌شوند که خروجی حاصل از اجرای کد فوق نیز مشابه مثال پیشین می‌باشد.

هشدارهای Compile-time

در نهایت هم هشدارها را داریم که تحت عنوان Compile-time Warning شناخته می‌شوند. به طور کلی، اهمیت این دسته از هشدارها به اندازۀ ارورها نبوده و زمانی رخ می‌دهند که محیط برنامه‌نویسی اکلیپس مسئله‌ای مشکوک را در سورس‌کد شناسایی کند و بدین ترتیب سطری از کد را با آیکانی به رنگ زرد با علامت تعجب مشخص می‌سازد که احتمالاً در آینده موجب ایجاد مشکل در طی توسعۀ اپلیکیشن خواهد شد.

در همین راستا، مثالی را مد نظر قرار می‌دهیم که در آن یک متغیر از جنس عدد صحیح یا int تحت عنوانtest تعریف کرده و مقداری معادل با عدد 100 را بدان اختصاص داده‌ایم. حال چنانچه نرم‌افزار اکلیپس سطر مربوط به تعریف متغیر test را با علامت زرد مشخص کند، این بدان معنا است که متغیر مذکور در هیچ نقطه‌ای از برنامه مورد استفاده قرار نگرفته است. همچنین می‌توان نشانگر ماوس خود را روی علامت زرد رنگ نگاه داشته و پیشنهاد نرم‌افزار به منظور رفع هشدار را مشاهده کرد که در این مثال پیامی در قالب عبارت «The value of the local variable test is not used» نمایش داده خواهد شد.

نگاهی به کامنت‌گذاری در زبان برنامه‌نویسی جاوا


در آموزش‌های گذشته به بررسی انواع روش‌های کامنت‌گذاری در برنامه‌نویسی و به خصوص زبان جاوا پرداختیم و گفتیم که کامنت‌ها هیچ تأثیری در روند اجرای برنامه ندارند که در این آموزش قصد داریم تا به صورت دقیق‌تر با روش‌های مختلف کامنت‌گذاری آشنا شده و برخی مزایای استفاده از کامنت در کدنویسی را بیان کنیم.

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

آشنایی با کامنت‌گذاری چندخطی

روش اول تحت عنوان کامنت‌گذاری چندخطی شناخته می‌شود بدین صورت که چنانچه بخواهیم چند خط از کد خود را از دید کامپایلر پنهان سازیم، در ابتدای خط اول از کد مد نظر خود علائم */ و در انتهای خط آخر از آن هم علائم /* را قرار می‌دهیم و بدین ترتیب هر آنچه که مابین این علائم قرار گیرد جزو کامنت‌ها محسوب می‌شود: 

public class HelloWorld {
    /*
    * This is a multi-line comment for you!
    */
    public static void main(String[] args) {
        String text = "In the name of God";
        System.out.println(text);
    }
}

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

آشنایی با کامنت‌های پایان خط

روش دوم به منظور کامنت‌گذاری مربوط به کامنت‌های پایان خط می‌باشد و در صورتی از این روش جهت کامنت گذاشتن در کدنویسی استفاده می‌شود که بخواهیم در انتهای خطی از سورس‌کد خود مطلبی را به منظور یادآوری بنویسیم که برای این منظور نیز از علائم // استفاده می‌کنیم. مثالی از این نوع کامنت‌گذاری را در کد زیر مشاهده می‌کنیم:

public class HelloWorld {
    public static void main(String[] args) {  // This is a method
        String text = "In the name of God";
        System.out.println(text);
    }
}

روش کامنت‌گذاری با استفاده از علائم // را می‌توانیم در پروسۀ دیباگ کردن سورس‌کد نیز به کار بگیریم بدین صورت که نشانگر ماوس خود را روی بخشی از سورس‌کد قرار می‌دهیم که به نظر می‌رسد موجب ایجاد مشکل در حین اجرای برنامه شده است سپس دکمه‌های / + Ctrl را فشار می‌دهیم و در ادامه می‌بینیم که بخش مورد نظر از سورس‌کد کامنت شده و به رنگ متفاوتی در می‌آید. حال برنامه را مجدد کامپایل می‌کنیم تا ببینیم ارور آن رفع شده است یا خیر که در صورت برطرف شدن مشکل می‌توان گفت که ارور مربوطه در بخش کامنت‌شده از سورس‌کد می‌باشد و در غیر این صورت مجدد کلیدهای / + Ctrl را فشار می‌دهیم تا کد مد نظر از حالت کامنت خارج شود. در ادامه، فرآیند فوق‌الذکر را برای بخش دیگری از سورس‌کد تکرار می‌کنیم تا زمانی که ارور موجود را شناسایی کنیم (اگر چه این نوع کامنت‌ها به کامنت‌های پایان خط معروف هستند، اما می‌توان آن‌ها را در ابتدای یک خط از کد نیز مورد استفاده قرار داد.)

آشنایی با کامنت‌هایی از جنس javadoc

روش سوم کامنت‌گذاری از نوع کامنت‌های javadoc می‌باشد بدین صورت که در ابتدا و انتهای خطوط مورد نظر از سورس‌کد خود به ترتیب علائم **/ و /* را درج کرده و توضیحاتی را داخل این بخش از سورس‌کد یادداشت می‌کنیم. در واقع، چنین کامنت‌هایی برای کسانی مفید خواهند بود که در آینده کامنت‌های درج‌شده به روش javadoc را مطالعه می‌کنند و از قضا دانش کمی در رابطه با زبان برنامه‌نویسی جاوا دارند که برای این منظور نیز از کلیۀ کامنت‌های javadoc خروجی اچ‌تی‌ام‌ال گرفته شده و در قالب یک صفحۀ وب در اختیار علاقه‌مندان قرار می‌گیرد (نحوۀ ایجاد خروجیِ اچ‌تی‌ام‌ال از کامنت‌های javadoc خارج از حوصلۀ این آموزش بوده لذا از توضیح در این باره خودداری می‌کنیم.) در ادامه به منظور درک بهتر نحوۀ کامنت‌گذاری از نوع کامنت‌های javadoc کد زیر را مد نظر قرار می‌دهیم:

public class HelloWorld{
    /**
    * This is a javadoc comment for you!
    */
    public static void main(String[] args) {
        String text = "In the name of God";
        System.out.println(text);
    }
}

همان‌طور که در کد فوق می‌بینید، بخش مورد نظر از سورس‌کد را با علائمی به صورت **/ و /* کامنت کرده‌ایم که منجر به تغییر رنگ آن‌ها گردیده است. 

مطالب مرتبط

پاسخی بگذارید

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *