قسمت پنجم - برنامه  Eclipse


در این جلسه از آموزش می‌خواهیم از برنامه‌ی اکلیپس یا به عبارتی از IDE اکلیپس برای نوشتن برنامه‌های جاوا استفاده کنیم. IDE مخفف: Integrated Development Environment است. در واقع IDE‌ ها تمام ابزارهای مورد نیاز برای برنامه نویسان را به طور منظم فراهم می‌کنند تا برنامه نویسان فقط روی نوشتن و طراحی برنامه تمرکز کنند و خود را درگیر مسائل جزئی مثل کامپایل کردن برنامه نکنند.

 برای هریک از زبان‌های برنامه نویسی، IDE های بسیار زیادی وجود دارد و می‌توان با همه‌ی آن‌ها برنامه را به درستی نوشت و اجرا کرد. اما از میان تمام IDE ها معمولا همیشه یک IDE از بقیه سرتر و بهتر است. به عنوان مثال برای زبان برنامه نویسی #C (سی شارپ) بهترین IDE، ویژوآل استودیو است. برای زبان جاوا هم IDE های زیادی وجود دارد که معروف‌ترین و محبوب‌ترین آن‌ها عبارت اند از:

• اکلیپس (eclipse)
  
• اوراکل نِت بینز (Oracle NetBeans)
  
• جِت برینز اینتلیج آی دیا (Jetbrains Intellij Idea)
  

اکلیپس یک IDE اُپن سورس (Open Source) و مبتنی بر پلاگین (Plug-in)، و بسیار مناسب برای تولید برنامه‌های مدرن جاوا (JavaEE) است. زیرا از آنجایی که جاوا ای ای مجموعه‌ای از تکنولوژی ها است، بنابراین پلاگین‌های مختلفی برای تکنولوژی‌های مختلف تولید شده است و به راحتی می‌توان آن‌ها را از اینترنت دانلود و به اکلیپس اضافه کرد.
ممکن است در ذهن شما این سوال به‌وجود بیاید که پلاگین چیست!؟
 پلاگین‌ها (افزونه‌ها) برنامه‌های کوچکی هستند که توسط شرکت‌های مختلف تولید می‌شوند و با نصب آن‌ها روی یک برنامه، می‌توان قابلیت‌های جدیدی را به آن برنامه اضافه کرد. به عنوان مثال، ADT یکی از پلاگین‌های معروف برای توسعه‌ی اندروید روی اکلیپس است. متاسفانه اکلیپس دارای باگ‌های فراوانی است و علت آن هم هسته اکلیپس نیست، بلکه باگ‌هایی است که در پلاگین‌های آن موجود است. بنابراین تا می‌توان باید سعی کرد از پلاگین‌هایی که توسط شرکت‌های معتبر تولید شده‌اند استفاده کرد.

 نت بینز یک IDE حرفه‌ای و به اصطلاح همه فن حریف است. این IDE توسط شرکت اوراکل نوشته شده است و می‌توان به جز جاوا، برای زبان‌های برنامه‌نویسی دیگری هم مثل: PHP, C++, Groovy و ... نیز استفاده کرد. در این IDE هم مانند اکلیپس می‌توان پلاگین‌هایی را اضافه کرد. اما بسیاری از سرویس‌ها به صورت داخلی در این IDE پیاده‌سازی شده‌اند. به عنوان مثال وب سرور Apache Tomcat (آپاچی تامکت) به صورت داخلی در این IDE پیاده‌سازی شده است و دیگر نیازی نیست تا به صورت جدا گانه این وب سرور را دانلود و نصب کنیم. اما یکی از ویژگی‌های مهم این IDE، این است که ابزارهای بسیار حرفه‌ای برای طراحی رابط گرافیکی کاربر دارد و یکی از مشکلات بزرگ برنامه نویسان جاوا را حل کرده است.
 آخرین IDE‌  که در مورد آن صحبت می‌کنیم، Jetbrains Intellij Idea است، که معنی "تند مغزها؛ ایده هوشمند" را دارد. این IDE یکی از بهترین ویرایشگر‌ها برای زبان برنامه نویسی جاوا است که دارای هوش فوق العاده‌ای است. اما با توجه به تجربیات شخصی و مطالعاتی که بنده در این زمینه داشتم، این IDE اصلا مناسب برای برنامه‌های مدرن جاوا (JavaEE) نیست و صرفا برای برنامه نویسی جاوا نسخه‌ی استاندارد آن و برنامه نویسی وب در جاوا می‌توان از آن استفاده کرد. همچنین این IDE همانند اکلیپس و نت بینز امکان اضافه کردن پلاگین را دارد.
باتوجه به بررسی‌های فوق، ما برای این دوره‌ی آموزشی، بهترین، محبوب‌ترین و ساده‌ترین IDE، یعنی اکلیپس را انتخاب می‌کنیم. در ادامه‌ی این آموزش، ما نحوه‌ی دانلود این IDE را آموزش می‌دهیم.

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


همانطور که در تصویر فوق با یک بیضی سبز رنگ مشخص شده است، بر روی دکمه DOWNLOAD کلیک کنید تا وارد صفحه‌ی زیر شوید:


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


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


همانطور که در تصویر فوق با یک بیضی سبز رنگ مشخص شده است، بر روی دکمه‌ی دانلود کنید تا وارد صفخه‌ی زیر شوید:


در صفحه فوق، کمی منتظر بمانید تا دانلود شروع شود. پیشنهاد می‌شود که از نرم افزار‌های مدیریت دانلود مثل IDM برای دانلود استفاده کنید.


در جلسه‌ی بعدی ما نحوه‌ی استفاده از اکلیپس را آموزش می‌دهیم.

قسمت ششم : راه اندازی اکلیپس



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

بعد از اینکه دانلود برنامه‌ی اکلیپس به پایان رسید، ابتدا باید فایل را از حالت فشرده خارج کنید. برای این کار می‌توان از اپلیکیشن‌هایی که در این زمینه تولید شده‌اند استفاده کرد یا می‌توان از ابزار‌های خوده سیستم عامل استفاده کرد. بنده از اپلیکیشن WinRAR برای این کار استفاده می‌کنم. بهتر است که فایل اکلیپس را در محلی از هارد دیسک قرار دهیم که دسترسی به آن آسان باشد. Desktop را به شما پیشنهاد می‌کنم. بعد از اینکه فایل اکلیپس را به دسکتاپ انتقال دادیم، بر روی فایل کلیک راست کرده و گزینه‌ی Extract Here را انتخاب می‌کنیم تا در همان دسکتاپ از حالت فشرده خارج شود. (تصویر زیر):




بعد از اینکه فایل ZIP را از حالت فشرده خارج کردید، فایلی ایجاد می‌شود با نام eclipse. وارد این فایل شوید. برنامه‌‌ی اکلیپس نیازی به نصب ندارد و برای اجرا، شما باید فایل eclipse.exe را اجرا کنید. (در تصویر زیر با یک بیضی سبز رنگ مشخص شده است):




بعد از اینکه بر روی فایل اجرایی اکلیپس کلیک کردید، با اولین پنجره‌ای که مواجه می‌شوید، پنجره‌ی زیر است.




این پنجره Workspace Launcher نام دارد. همانطور که از نامش پیداست، مسیره ذخیره‌سازی پروژه‌هایی که ما ایجاد می‌کنیم را در هارد دیسک مشخص می‌کند. بنابراین بهتر است که مسیر Workspace را همان دسکتاپ قرار دهیم. اما قبل از مشخص کردن مسیر، ابتدا در دسکتاپ فولدری با نام workspace ایجاد کنید و سپس با استفاده از دکمه‌ی Browse مسیر workspace در دسکتاپ را انتخاب کنید. اما قبل از OK کردن، به CheckBox (چک باکس) که در تصویر بالا با یک فلش قرمز رنگ مشخص شده است توجه کنید. اگر این گزینه فعال نباشد، با هر بار بستن اکلیپس و اجرای مجدد آن، این پنجره نمایش داده می‌شود و از شما درخواست مجدد مشخص کردن Workspace را می‌کند. بنابراین، این گزینه را انتخاب کنید و بعد بر روی دکمه‌ی OK کلیک کنید تا برنامه اکلیپس اجرا شود. (بعد از اجرا با تصویر زیر مواجه می‌شوید):




همانطور که مشاهده می‌کنید اکلیپس به شما خوش آمد می‌گوید. با این صفحه کاری نداریم. بنابراین همانطور که در گوشه بالا، سمت راست تصویر با یک فلش سبز رنگ مشخص شده است، بر روی دکمه‌ی Worckbench کلیک کنید تا وارد صفحه‌ی اصلی برنامه شوید. (تصویر زیر):




حالا وقت آن است که اولین پروژه‌ی جاوایی خودمان را ایجاد کنیم. برای ساختن پروژه، ابتدا از منوی File گزینه‌ی New را انتخاب کنید و بعد اولین گزینه، یعنی Java Project را انتخاب کنید. (تصویر زیر):




بعد از انتخاب گزینه Java Project، با پنجره‌ی زیر مواجه می‌شوید:




همانطور که در تصویر فوق مشاهده می‌کنید، پنجره‌ای برای ساختن پروژه ظاهر شده است. ابتدا یک نام برای پروژه‌ی خود انتخاب می‌کنیم. ما در این آموزش نام: FirstJavaProgrm را نوشته‌ایم. به بقیه‌ی گزینه‌های این صفحه کاری نداشته باشید. بنابراین بر روی دکمه‌ی Finish کلیک کنید. بعد از ساخته شدن پروژه، باید یک کلاس بسازیم.
نکته: در برنامه‌های بزرگ جاوا، ممکن است بیش از هزار کلاس وجود داشته باشد. اما این نکته را به خاطر بسپارید که هر برنامه‌ی جاوا کم کم یک کلاس و یک مِتُد دارد.
در مورد کلاس‌ها و متدها در آموزش‌های مربوط به فصل شی گرایی به طور مفصل صحبت خواهیم کرد و کاربرد اصلی آن‌ها را یاد خواهیم گرفت.
برای ساختن کلاس ابتدا پروژه‌ی خودتان را انتخاب کنید و بعد کلیک راست کنید. منویی باز می‌شود که به آن منوی پاپ آپ (Pop-up) گفته می‌شود. اولین گزینه از این منو که New است را انتخاب کنید و بعد گزینه Class را انتخاب کنید. (تصویر زیر):




درضمن، در بالای همین عکس، قسمتی که با یک فلش قرمز رنگ مشخص شده است را Package Explorer می نامند. تمام پروژه‌هایی که ما ایجاد می‌کنیم در این قسمت (Package Explorer) قرار می‌گیرند.
بعد از کلیک کردن بر روی دکمه‌ی Class، با پنجره‌ی زیر مواجه می‌شویم:




در مورد قسمت‌های مشخص شده در تصویر بالا کمی توضیح می‌دهم:
بیضی سبز رنگ اولی مربوط به پکیج است. این که پکیج چیست و چه کاربردی دارد، در آموزش‌های بعدی در مورد آن صحبت می‌کنیم. بنابراین در این آموزش برای پکیج چیزی نمی‌نویسیم.
قسمت بعدی که Name است، باید نامی برای کلاس خودمان انتخاب کنیم. نامی که برای کلاسمان انتخاب می‌کنیم بسیار مهم است. باید نامی انتخاب کنیم که نشان دهنده‌ی کاری باشد که آن کلاس قرار است انجام بدهد. همانطور که در آموزش قبلی گفته شد، هر برنامه‌ی جاوا دارای یک متد اصلی به نام متد main است که نقطه شروع هر برنامه‌ی جاوا است. بنابراین چون در این کلاس متد main را قرار است پیاده‌سازی کنیم، کلاسمان، کلاس اصلی است. بنابراین نامی که برای کلاس انتخاب می‌کنیم، MainClass است.
آخرین قسمت که با یک مستطیل قرمز رنگ مشخص شده است، یک چک باکس دارد. که اگر این چک باکس را انتخاب کنیم، اکلیپس به صورت خودکار متد main را در کلاس ما پیاده‌سازی می‌کند و دیگر نیازی نیست که ما به صورت دستی متد main را خودمان بنویسیم و این یکی از مزایای IDE ها است. چون IDE زحمت نوشتن کد را به گردن می‌گیرد و کار ما را به عنوان برنامه نویس راحت تر می‌کند. درضمن IDE ها در نوشتن کدها به هیچ عنوان اشتباه نمی‌کنند. بنابراین خیال ما از درست نوشته شدن کدها راحت است. بنابراین، این گزینه را انتخاب کنید و بعد بر روی دکمه‌ی Finish کلیک کنید.
 
نکته: در مورد انتخاب نام برای متغیرها، متدها، پکیج‌ها و کلاس ها نکاتی هست که در هر آموزش مربوطه توضیح داده می‌شود. در این آموزش در مورد نام گذاری کلاس‌ها توضیح می‌دهیم. البته یک سری قوانین کلی در جاوا برای نام گذاری وجود دارد و شامل همه‌ی موارد می‌شود. اما برای نام گذاری بخش‌های مختلف جاوا تفاوت‌های کوچکی هست که ما در هر مبحث به صورت جداگانه به آن ها اشاره می‌کنیم. نکته‌ای که باید بسیار به آن توجه کنید این است که نام کلاس باید با حرف بزرگ انگلیسی شروع شود. البته اگر با حرف کوچک هم شروع شود مشکلی نیست. اما یک قانون نانوشته در بین برنامه نویسان است که نام تمام کلاس‌های خود را با حرف بزرگ شروع می‌کنند و اگر نام کلاس از دو بخش تشکیل شده بود، مثلا در همین آموزش نام کلاس ما MainClass است، باید حرف دوم بخش بعدی نام نیز با حرف بزرگ شروع شود. در این آموزش بخش اول نام کلاس ما Main است که با حرف بزرگ انگلیسی شروع شده و بخش دوم Class است که باز هم با حرف بزرگ شروع شده است. بنابراین اگر ما نام کلاس را به صورت Mainclass بنویسیم، غلط نیست! اما قشنگ هم نیست. نکته‌ای دیگر که باید به آن توجه کنیم این است که نمی‌توانیم نام کلاس خود را با اعداد شروع کنیم. مثلا 2MainClass کاملا غلط است یا نمی‌توانیم در بین کارکترهای نام کلاس، از کارکترهای خاص مثل ستاره (*)، هش مارک (#)، درصد (%) و ... استفاده کرد. اما در میان کارکترهای خاص می توان از علامت دولار ($) استفاده کرد یا می‌توان از خط زیر یا Underscore (_) نیز استفاده کرد. اما باز هم تاکید می شود که به هیچ عنوان از این نام‌ها استفاده نکنید. به عنوان مثال این نام: Main_Class کاملا صحیح است، اما خوب نیست که استفاده کنیم. همچنین از کلمات کلیدی جاوا هم نمی‌توانیم استفاده کنیم. در هر زبان برنامه نویسی یک سری کلمات، از قبل رزرو شده است که نمی‌توان از آن‌ها برای نام گذاری استفاده کرد. به عنوان مثال کلمه‌ی کلید class، یک کلمه‌ی رزرو شده است که برای ساختن یک کلاس در جاوا استفاده می‌شود.بنابراین ما نمی‌توانیم از این نام استفاده کنیم و در آخر اینکه تمام کلمات کلیدی با حروف کوچک انگلیسی نوشته می‌شوند.


 دیدن لینک ها برای شما امکان پذیر نیست. لطفا ثبت نام کنید یا وارد حساب خود شوید تا بتوانید لینک ها را ببینید.



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




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




حالا می‌خواهیم وقتی برنامه اجرا شد، عبارت: Welcome to Java Programming نمایش داده شود. بنابراین باید از جمله‌ی: ;()System.out.print استفاده کنیم. اما بجای نوشتن کامل این جمله، عبارت مقابل را بنویسید: sysout و سپس دکمه های ترکیبی CTRL + SPACE را فشار دهید تا کد کامل شود. در بین پرانتزهای ایجاد شده، یک جفت کوتیشن قرار دهید و سپس عبارت فوق را بنویسید. به شکل زیر:




حالا با نگه داشتن دکمه‌های ترکیبی CTRL + S برنامه را Save کنید. بعد از Save کردن، دکمه‌های ترکیبی CTRL + F11 را نگه دارید تا برنامه اجرا شود.




همانطور که مشاهده می‌کنید، عبارت مورد نظر ما در خروجی استاندارد یا همان کنسول برنامه چاپ شد.

مفاهیم پایه در زبان جاوا (قسمت ۱)

در جلسات قبلی با مقدمات زبان جاوا آشنا شدیم. ابزار‌های لازم را روی سیستم نصب کردیم و ساده‌ترین برنامه‌ی جاوای خود را با نام Hello World، هم به صورت دستی (یعنی با استفاده از اپلیکیشن نُت پد) و هم با استفاده از IDE اکلیپس نوشتیم. از این آموزش تا چند آموزش بعدی، قصد داریم مفاهیم پایه در برنامه نویسی جاوا را آموزش دهیم. بنابراین آموزش‌ها کمی حجیم‌تر و سخت‌تر می‌شوند.

قبل از شروع آموزش ابتدا نحوه‌ی بزرگ کردن فونت در اکلیپس را به شما آموزش می‌دهم تا هم تصویر کدهایی که در این آموزش‌ها قرار می‌دهیم خوانا‌تر باشد و هم شما هنگام برنامه نویسی دچاره ضعیفی چشم نشوید.
ابتدا برنامه‌ی اکلیپس را اجرا کنید و بعد از منوی Window گزینه‌ی Preferences را انتخاب کنید. وارده پنجره‌ی زیر می‌شوید:


همانطور که در تصویر بالا مشاهده می‌کنید وارد پنجره‌ی Preferences شده‌اید. روی اولین گزینه که General است کلیک کنید و به ترتیبی که در عکس زیر مشاهده می‌کنید، گزینه‌های مشخص شده را انتخاب کنید:


به ترتیب شماره‌هایی که در تصویر بالا مشخص شده است پیش بروید. در قسمت چهار (4) وقتی روی گزینه‌ی Basic کلیک می‌کنید، زیر مجموعه‌های آن نمایش داده می‌شود. شما کمی به پایین اسکرول کنید و آخرین گزینه یعنی Text Font را انتخاب کنید. همانطور که در تصویر زیر مشاهده می‌کنید، بعد از انتخاب کردن Text Font روی دکمه‌ی ...Edit کلیک کنید. پنجره‌ی Font باز می‌شود:


همانطور که در تصویر مشخص شده از پنجره‌ی Font، سایز مورد نظر خود را انتخاب کنید. من سایز 12 را به شما پیشنهاد می‌کنم. بعد از انتخاب، تمام پنجره‌های باز را OK کنید تا بسته شوند.
حالا در اکلیپس یک پروژه‌ی جاوایی بسازید. سپس یک کلاس جاوا با نام MainClass ایجاد کنید. توجه داشته باشید که در هنگام ساختن کلاس، روی دکمه‌ی: public static void main(String[] args)  کلیک نکنید. کلاس ساخته شده‌ی شما باید به شکل زیر باشد:

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

اولین کلمه در کلاس بالا public است که ما با این کلمه‌ی کلیدی در فصل شی‌گرایی آشنا می‌شویم. بنابراین می‌توانیم یا آن را پاک کنیم یا اینکه فعلا کاری با این کلمه‌ی کلیدی نداشته باشیم و اجازه دهیم که همانجا باشد. بد نیست بدانید که در IDE اکلیپس کلمات کلیدی با رنگ بنفش مشخص می‌شوند. بنابراین نیازی به حفظ کردن کلمات کلیدی نیست.
برای ساختن هر کلاس در جاوا باید از کلمه‌ی کلیدی class استفاده کرد. (تمام کلمات کلیدی در جاوا با حروف کوچک انگلیسی هستند). بعد از نوشتن کلمه‌ی class باید نامی را برای کلاس خود انتخاب کنیم که در این آموزش نام MainClass انتخاب شده است. بعد از انتخاب نام کلاس، باید یک بلاک برای کلاسمان مشخص کنیم که این کار را با علامت‌های باز و بسته‌ی آکولاد انجام می‌دهیم.

همانطور که مشاهده کردید اکلیپس به صورت خودکار تمام این کارها را انجام داده است و نیازی نیست که ما آن‌ها را انجام دهیم. اما باید بفهمیم که هر کد به چه معنی است. در ادامه می‌خواهیم متد main را به برنامه اضافه کنیم. در مورد متد‌ها چند نکته وجود دارد که باید بدانید:
ابتدا اینکه متدها دو نوع هستند. یا مقداره برگشتی ندارند (یعنی از نوع void هستند) یا مقداره برگشتی دارند. (نگران نفهمیدن مقادیر برگشتی و غیر برگشتی در متدها نباشید. در ادامه‌ی آموزش‌ها با این نوع متد‌ها آشنا می‌شوید). متد main از نوع void است.
در مورد انتخاب نام برای متدها، باید از قوانین نام گذاری در جاوا پیروی کنیم. در آموزش قبلی برای نام گذاری کلاس‌ها تمام قوانین نام گذاری گفته شد و در این آموزش فقط نکاتی را که برای نام گذاری متدها باید رعایت کنیم، می‌گوییم.
نام تمام متدها با حرف کوچک انگلیسی شروع می‌شود. اگر به متد main هم توجه کنید با حرف کوچک انگلیسی نوشته شده است. اگر هم نام متد چند بخشی بود، به جز اولین حرف بخش اول نام متد که باید با حرف کوچک باشد، حرف‌های اول بخش‌های دیگر متد با حرف بزرگ نوشته می‌شوند. (کمی پیچیده شد!؟). به مثال زیر توجه کنید:

نام یک بخشی یک متد: print: همانطور که مشاهده می‌کنید نام متد با حرف کوچک انگلیسی شروع شده است.
نام دو بخشی یک متد: printSomething: همانطور که مشاهده می‌کنید نام بخش دوم متد که Something است با حرف بزرگ انگلیسی شروع شده است.
این شکل نام گذاری متد، در نام گذاری کلاس‌ها هم رعایت می‌شود. فقط تفاوتی که با آن دارد نام تمام کلاس‌ها با حرف بزرگ شروع می‌شود.
نامی که برای تمام متدها انتخاب می‌کنیم باید نامی باشد متناسب با کاری که قرار است آن متد انجام دهد. مثلا فرض کنید می‌خواهیم متدی بنویسیم که آن متد دو عدد را با هم جمع کند. بنابراین sum نام مناسبی است.
حالا می‌خواهیم متد main را در کلاسمان پیاده‌سازی کنیم. برای این کار سه راه وجود دارد. اولین راه این است که  هنگام ساختن کلاس، تیک گزینه‌ی:public static void main(String[] args) را فعال کنیم. راه دیگر نوشتن متد به صورت دستی است و راه دیگر آن نوشتن کلمه‌ی main در بدنه‌ی کلاس و بعد از آن گرفتن دکمه‌های ترکیبی: CTRL + SPACE که توسط اکلیپس متد main نوشته می‌شود. تصویر زیر:


برای اینکه متدی را بسازیم ابتدا باید نوع برگشتی یا غیر برگشتی آن متد را مشخص کنیم. (البته باید سطح دسترسی اون متد را هم مشخص کنیم که در این آموزش این کار را انجام نمی‌دهیم). متد مد نظر ما از نوع void است.
بعد نام متد را مشخص می‌کنیم. نامی که در نظر می‌گیریم printSomething است. فقط ما در این متد از کلمه‌ی کلیدی static هم استفاده می‌کنیم. در آموزش‌های بعدی کاربرد این کلمه‌ی کلیدی توضیح داده خواهد شد.

توجه داشته باشید که این متد را خارج از  بدنه‌ی متد اصلی (main) و داخل بدنه‌ی کلاس بنویسید. به شکل زیر:


متد ما همانطور که گفته شد، نوشته شد. (تصویر بالا):
حالا می‌خواهیم هر موقع که این متد را فراخوانی یا Call می‌کنیم، متنی را در خروجی استاندارد یا همان کنسول چاپ کند.
در فصل سیستم فایل با معنی و مفهوم استریم (Stream) آشنا خواهید شد. اما این را بدانید که در جاوا و در کلاس java.lang.System دو نوع استریم برای ورودی و خروجی استاندارد تعریف شده است. یکی System.out و دیگری System.in که همانطور که از نام‌هایشان معلوم است به ترتیب برای ارسال داده‌ها به خروجی استاندارد و دریافت داده از وردی استاندارد است.
در این آموزش می‌خواهیم داده‌ای را به خروجی استاندارد ارسال کنیم. بنابراین باید از استریم System.out استفاده کنیم. دو متد ()print و ()println برای چاپ داده استفاده می‌شوند. فرق این دو متد در آموزش‌های قبل گفته شده است. ما از متد ()println استفاده می‌کنیم. به تصویر زیر توجه کنید:


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


 
سپس باید برنامه را ذخیره یا Save کنیم. برای این‌کار دکمه‌های ترکیبی CTRL + S را همزمان نگه دارید. سپس برای اجرای برنامه مجددا دکمه‌های ترکیبی CTRL + F11 را نگه دارید تا برنامه اجرا شود. حالا باز هم با اجرای برنامه چیزی در خروجی استاندارد نمایش داده نمی‌شود. زیرا ما در متد ()println هیچ متنی را ننوشته‌ایم. برای این کار ابتدا یک جفت دابل کوتیشن در متد ()println قرار دهید و بعد هر متنی را که می‌خواهید بنویسید. مثلا من متن: welcome to Romaak.ir را می‌نویسم. تصویر زیر:


حالا دوباره برنامه را Save و اجرا کنید. نتیجه‌ی اجرای برنامه:


قسمتی که با یک فلش قرمز رنگ مشخص شده است، خروجی برنامه در کنسول است.

تمرین: در مورد CamelCase تحقیق کنید. این موضوع برای درک بهتر نام‌گذاری کلاس‌ها، متغیر‌ها و متد‌ها در جاوا است.

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

داده‌های پایه به داده‌هایی گفته می‌شوند که داده‌های پیچیده از روی این داده‌ها ساخته می‌شوند. (در فصل شی‌گرایی با چگونگی تعریف داده‌های پیچیده آشنا خواهید شد). همانطور که گفته شد در جاوا هشت نوع داده‌ی اصلی وجود دارد. این هشت نوع در زیر آورده شده‌اند:

1. byte
   
2. short
   
3. int
   
4. long
   
5. boolean
   
6. char
   
7. float
   
8. double
   

داده‌های شماره‌ی 1 تا 4 (byte, short, int, long) داده‌هایی از نوع اعداد صحیح هستند. تفاوتی که بین این داده‌ها است، محدوده‌ای است که این داده‌ها پشتیبانی می‌کنند.

داده‌ی بولی (boolean)، داده‌ای است که مقداره آن "درست" یا "نادرست" است. (true OR false).

داده‌های float و double داده‌های اعداد اعشاری هستند و داده‌ی char نیز یک داده‌ی کارکتری است.

یک نکته که بنده یادگیری آن مطلب را به شما توصیه می‌کنم، تحقیق در مورد اندازه‌ی داده‌های فوق است. یعنی به عنوان مثال اندازه‌ی داده‌‌های int و byte به ترتیب 32 و 8 بیت است.

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

هر متغیر دارای یک نام است که با استفاده از آن نام، می‌توانیم به داده‌ی مورد نظر که در حافظه‌ی کامپیوتر ذخیره شده است دسترسی پیدا کنیم. در زیر چند مثال از تعریف متغیر آورده شده است.

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

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

همانطور که در کد بالا مشاهده می‌کنید ابتدا یک متغیر از نوع int که نام آن num1 است تعریف کرده‌ایم و مقداره 5 را برای آن در نظر گرفته‌ایم. (به نحوه‌ی مقدار دهی متغیر‌ها توجه کنید. ابتدا یک علامت مساوی (=) قرار می‌دهیم و بعد مقداره دلخواه را می‌نویسیم). در خط بعد نیز دوباره متغیری تعریف کردیم که نام آن num2 و مقدار آن 15 است. حالا می‌خواهیم وقتی این دو متغیر را با هم جمع کردیم، نتیجه را در یک متغیر دیگری ذخیره کنیم. برای این کار ما متغیر دیگری با نام result تعریف کرده‌ایم. در خط بعد متغیر result را نوشته‌ایم و این بار بجای اینکه برای مقداردهی متغیر result از مقادیر عددی استفاده کنیم، متغیرهای num1 و num2 را با استفاده از عملگر +، آن دو را با هم جمع کرده‌ایم و نتیجه در result ذخیره شده است. حالا می‌خواهیم نتیجه‌ی مورد نظر را در کنسول نمایش دهیم. بنابراین همانطور که مشاهده می‌کنید از استریم System.out استفاده کرده‌ایم. به آرگومان متد println توجه کنید. ابتدا جمله‌ی Result is را نوشته‌ایم. حالا می‌خواهیم داده‌ی ذخیره شده در result را نمایش دهیم. بنابراین از علامت + استفاده می‌کنیم و بعد result را می‌‌نویسیم. این علامت + داده‌ی متغیر result را از عدد صحیح (int) به رشته (String) تبدیل می‌کند. (در مورد استرینگ‌ها در فصل‌های آینده آشنا می‌شوید). برنامه را اجرا کنید و نتیجه آن 20 خواهد بود.

به عنوان یک تمرین، برنامه را طوری تغییر دهید که نیازی به استفاده از متغیر result نباشد.

به عنوان آخرین مطلب در این آموزش، ما متغیرها را می‌توانیم در یک خط هم تعریف کنیم (داده‌های هم نوع را). به مثال زیر نگاه کنید:

همانطور که مشاهده کردید ما در ابتدای خط نوع متغیر را مشخص کردیم و بعد نام‌های متغیرها را در جلوی آن نوشتیم. برای جدا کردن متغیر‌ها از علامت کاما (,) استفاده کردیم. اما پیشنهاد می‌کنم که متغیرها را به این صورت تعریف نکنید. هر متغیر را در یک خط جداگانه تعریف کنید.

مفاهیم پایه در زبان جاوا (قسمت ۳)

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

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

A + B * C

به ازای مقادیر C=2, B=3, A=5، اگر بخواهیم بدون دخالت تقدم عملگر‌ها عبارت را محاسبه کنیم، جواب 16 خواهد بود. اما این جواب درست نیست. زیرا در ریاضی عملگر ضرب که در جاوا با علامت ستاره (*) مشخص می‌شود، نسبت به جمع و تفریق سطح تقدم بالاتری دارد. بنابراین باید ابتدا ضرب انجام شود و سپس جمع و تفریق. بنابراین جواب عبارت فوق می‌شود 11. یعنی ابتدا B در C ضرب و سپس با A جمع می‌شود.

نکته: در برنامه نویسی از دو مفهوم عملگر و عملوند بسیار استفاده می‌شود. در ریاضیات، یک عملگر تابعی است که بر تابعی دیگر اعمال می‌شود. یک عملگر را یک عمل ریاضی گویند. مانند عمل جمع، ضرب، تقسیم و ... . همچنین واژه‌ی دیگری است با نام عملوند. یک عملوند، هدف یک عملیات ریاضی است. در مثال فوق حروف‌های A, B, C هر کدام یک عملوند هستند.

در زیر فهرست کامل سطوح تقدم عملگر‌های حسابی نشان داده شده است.

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

به عنوان تمرین در مورد علامت منها تحقیق کنید. علامت منها سه کاربرد دارد.

با توجه به توضیحات فوق، ماشین (کامپیوتر) هنگام محاسبه‌ی عبارت‌های محاسباتی از چپ به راست شروع به خواندن عملگر‌ها می‌کند. اگر در عبارت عملگر‌هایی بود که تقدم آن‌ها با هم فرق داشت، خب مسلما کامپیوتر ابتدا عملگر‌هایی که سطح تقدم بالاتری دارند را حساب می‌کند. اما اگر همه‌ی عملگر‌ها سطح تقدم یکسانی داشته باشند، از چپ به راست خوانده و محاسبه می‌شود. اما یک نکته‌ی مهم در این بین وجود دارد که با قرارداد‌های معمولی در ریاضیات مطابقت ندارد. اگر بخواهیم با توجه به جدول بالا عبارت: A^B^C (عملگر ^ نشانگر توان است) را حساب کنیم، کامپیوتر از سمت چپ ابتدا A را به توان B و سپس پاسخ را به توان C می‌رساند. اما در ریاضی قرارداد است که عبارت فوق به صورت:

حساب شود. یعنی ابتدا B به توان C برسد و بعد A به توان جواب آن دو. همانطور که مشاهده کردید ما برای هندل کردن این قضیه از پرانتز‌ها استفاده کردیم. استفاده از پرانتز‌ها باعث می‌شود که کامپیوتر عبارت را طوری که ما می‌خواهیم حساب کند. مثلا در عبارت مقابل: A + B *C، اگر بخواهیم ابتدا A با B جمع شود و سپس در C ضرب شود، باید از پرانتزها استفاده کنیم. به صورت زیر:

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

به عنوان تمرین عبارت زیر را در نظر بگیرید و آن را حل کنید:

جواب تمرین فوق 25- می‌شود.

ساختار‌های کنترلی

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

در جاوا یک ساختار کنترلی‌ وجود دارد که شکل آن به صورت زیر است:

همانطور که مشاهده می‌کنید دستوری بسیار ساده اما در عین حال کاربردی است. ابتدا شرط داخل پرانتز مقابل if بررسی می‌شود. اگر شرط درست یا برقرار بود operations-1 اجرا می‌شود و دیگر operations-2 اجرا نمی‌شود یا برعکس. ممکن است شرط برقرار نباشد، بنابراین operations-2 اجرا می‌شود.

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

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

در جدول زیر فهرستی از عملگر‌های جاوا آمده است:


به جدول بالا با دقت نگاه کنید و کاربرد هرکدام را یاد بگیرید. نکته‌ای که برنامه نویسان تازه وارد ممکن است اشتباه کنند، عملگر انتساب (=) و عملگر برابری (==) است. در ریاضیات برای نشان دادن اینکه یک عدد با یک عدد دیگر برابر است از یک علامت مساوی (=) استفاده می‌کنند. ولی در برنامه نویسی باید برای این کار از دو علامت مساوی (==) استفاده کنید. اشتباه استفاده کردن از این علامت‌ها بروز خطاهای منطقی را در برنامه افزایش می‌دهد.

واسط کاربری

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

به کد زیر دقت کنید:

در خط اول برنامه جمله‌ی import javax.swing.JOptionPane نوشته شده است. (در فصل شی‌گرایی که با مفهوم پکیج آشنا شدید به خوبی این مطلب را درک می‌کنید). اما این را بدانید که وقتی می‌خواهیم در کلاسی که ساخته‌ایم از کلاسی استفاده کنیم که آن کلاس در یک پکیج دیگر قرار دارد، باید آن کلاس را اصطلاحا import کنیم. با import کردن، ما مسیر کلاس را مشخص می‌کنیم. یعنی در این برنامه می‌خواهیم از کلاسی استفاده کنیم که نام آن JOptionPane است و این کلاس در پکیجی قرار دارد که نام آن پکیج javax.swing است. نکته‌ای که باید به آن توجه کنید این است که اصلا خودتان را درگیر حفظ کردن نام پکیج‌ها نکنید و اصلا هم نیازی نیست که شما این کلاس‌ها را import کنید. زیرا اگر از قابلیت‌های تکمیل خودکار IDE ها استفاده کنید، خود IDE به صورت خودکار کلاس مورد نظر را import می‌کند. برای استفاده از قابلیت‌های تکمیل خودکار باید ابتدا چند حرف ابتدایی نام کلاس را بنویسید و سپس دکمه‌های ترکیبی: CTRL + SPACE را نگه دارید. با این کار هم نام کلاس کامل می‌شود و هم کلاس مربوطه وارد می‌شود. حالا به سراغ بررسی برنامه برویم:

در متد اصلی (main) ما ابتدا نام کلاس JOptionPane را می‌نویسیم. سپس از متدی با نام showMessageDialog استفاده می‌کنیم. این متد چهار پارامتر دریافت می‌کند. پارامتر اول که مقدار آن null است، مشخص می‌کند هنگامی که برنامه اجرا شد و کادر گفتگو نمایش داده شد، این کادر گفتگو دقیقا در وسط صفحه‌ی نمایش، نشان داده شود. (در مباحث گرافیک در جاوا می‌توان تعیین کرد که این گونه پیغام‌ها در یک فریم خاصی نمایش داده شود که در حال حاضر خارج از بحث است و به آن پرداخته نمی‌شود). در پارامتر دوم متنی که می‌خواهیم نمایش داده شود را می‌نویسیم که باید حتما بین دابل کوتیشن قرار بگیرد. پارامتر سوم title یا عنوان کادر گفتگو را مشخص می‌کند. به عنوان مثال اگر قرار است پیغامی چاپ شود و آن پیغام بیانگر یک ارور باشد، در title آن می‌توان نوشت: Error. پارامتر آخر هم نوع پیغام را مشخص می‌کند که این پیغام از نوع اطلاعات است.

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

اگر برنامه‌ی فوق را اجرا کنیم با خروجی زیر مواجه می‌شویم:



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

مفاهیم پایه در زبان جاوا (قسمت ۴)

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

در ادامه‌ی جلسه‌ی قبل که با ساختار کنترلی if آشنا شدیم، در این جلسه با یکی دیگر از ساختار‌های کنترلی تحت عنوان switch آشنا می‌شویم. ساختار switch مشابه‌ if else چندگانه است. ولی این ساختار تنها برای ارزیابی مساوی بودن یک عبارت با مقادیر گوناگون به کار می‌رود. به کد زیر با تمام دقت نگاه کنید:


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

حالا می‌خواهیم با یک مثال بسیار ساده کاربرد ساختار سوییچ را آموزش دهیم. در این مثال ما مقدار 10 را برای کلید اصلی در نظر می‌گیریم. به کد زیر دقت کنید:


همانطور که در کد مشخص است ما یک متغیر با نام num از نوع Integer (عدد صحیح) تعریف کرده‌ایم و مقدار آن را صفر در نظر گرفته‌ایم. سپس ساختار switch را نوشته‌ایم. متغیر num را برای کلید اصلی در نظر گرفته‌ایم. یعنی قرار است که ما case‌های داخل بدنه‌ی سوییچ را با متغیر num مقایسه کنیم و اگر هرکدام از case‌ها که مقدار آن با مقدار متغیر num برابر بود، کد مربوط به آن case اجرا می‌شود و سپس برنامه از ساختار switch خارج می‌شود.
برای مقدار دهی case‌ ها ابتدا کلمه‌ی کلیدی case را می‌نویسیم و سپس یک فاصله (space) می‌دهیم و بعد مقدار مورد نظرمان را در جلوی آن می‌نویسیم. مثلا اولین case ما مقدار صفر دارد. دومی مقدار یک و سومی مقدار دو دارد. توجه داشته باشید که 0, 1, 2 مقادیر case‌های ما هستند و به اشتباه فکر نکنید که case‌ها دارای شماره هستند. بعد از اینکه ما مقدار یک case را مشخص کردیم، در مقابل آن یک دو نقطه قرار می‌دهیم و سپس در مقابل آن یا در خط پایین آن دستورات مربوط به case را می‌نویسیم.
در این برنامه اولین case ما مقدار صفر دارد. مقدار این case با کلید اصلی مقایسه می‌شود. آیا مقدار آن با کلید اصلی یکسان است؟ بله. بنابراین کد مربوط به این case اجرا می‌شود. یعنی پیغام: Good Luck در خروجی استاندارد چاپ می‌شود و سپس از ساختار switch خارج می‌شود و دیگر case‌های بعدی اجرا نمی‌شوند. حالا می‌توانید به عنوان تمرین مقدار متغیر num را تغییر دهید تا خروجی‌های متفاوت آن را ببینید.

ساختار تکرار for
حلقه‌ی for پرکاربردترین حلقه در جاوا است. شاید بتوان برنامه‌هایی را که با ساختار for پیاده‌سازی می‌کنیم را با سایر حلقه‌های دیگر بنویسیم. اما هرکدام برای کار خاصی طراحی شده‌اند و بهتر است با توجه به شرایطی که در برنامه به وجود می‌آید، ساختار مناسب را انتخاب کنیم. شرط انتخاب حلقه‌ی for این است که ما تعداد دفعات تکرار حلقه را از قبل بدانیم. فرض کنید می‌خواهیم یک عملیات را ۱۰ مرتبه اجرا کنیم. بنابراین بهتر است که از ساختار for استفاده کنیم. ساختار کلی for به صورت زیر است. با دقت به کد نگاه کنید:


همانطور که در کد فوق مشاهده می‌کنید ساختار بسیار ساده‌ای دارد. ابتدا کلمه‌ی کلیدی for را می‌نویسیم و بعد یک جفت پرانتز باز و بسته قرار می‌دهیم. چنانچه می‌بینید در داخل پرانتز ما سه قسمت جداگانه وجود دارد که هر قسمت با یک سمی‌کالن ( ; ) از هم جدا می‌شوند. همانطور که قرار است حلقه‌ی ما به تعداد 10 بار اجرا شود، پس نیاز به یک شمارنده دارد که با هر بار اجرای حلقه مقداری به شمارنده‌ی ما اضافه یا کم شود. (مقداری که باید اضافه یا کم شود توسط برنامه نویس مشخص می‌شود). مثلا در برنامه‌ی ما مقدار شمارنده در هر بار اجرای حلقه یک واحد اضافه می‌شود. (در مورد ++i در ادامه‌ی همین آموزش توضیح می‌دهیم). قسمت دوم شرط حلقه است. شرط حلقه‌ی ما این است که تا زمانی که مقدار متغیر i به 9 نرسیده است، این حلقه ادامه داشته باشید و زمانی که به 9 رسید دیگر حلقه ادامه پیدا نکند و از ساختار for خارج شود. قسمت سوم هم گام حرکت شمارنده است. یعنی شمارنده‌ی ما چگونه تغییر کند. مثلا در برنامه‌ی ما در هر بار اجرای حلقه یک واحد به شمارنده اضافه می‌شود تا به عدد 9 برسد. ممکن است در یک برنامه‌ی دیگر بجای یک واحد، دو واحد و یا سه واحد به شمارنده اضافه شود یا ممکن است که از مقدار شمارنده کم شود. بنابراین تغییر شمارنده بستگی به برنامه‌ای است که در حال نوشتن آن هستیم.

عملگر ++
در مورد گام حرکت شمارنده نکته‌ای است که باید بسیار به آن دقت کنید. ما می‌توانیم یک متغیر را به صورت ++i یا i++ بنویسیم. یعنی علامت ++ (plus plus) یکبار در سمت راست متغیر قرار دارد و بار دیگر در سمت چپ آن. این عملگر باعث افزایش یک واحد در متغیر می‌شود. در بعضی از مواقع سمت راست یا چپ نوشتن عملگر ++ تغییری در برنامه ایجاد نمی‌کند. اما مفهوم آن را باید بدانید.
اگر عملگر ++ را در سمت راست متغیر بنویسید: یعنی ++i، مقدار متغیر i ابتدا در برنامه استفاده می‌شود و بعد یک واحد به مقدار متغیر اضافه می‌شود. اما اگر عملگر ++ را در سمت چپ متغیر بنویسید: یعنی i++، ابتدا به متغیر یک واحد اضافه می‌شود و بعد در برنامه استفاده می‌شود. برای روشن شدن این مسئله به مثال زیر دقت کنید:


خروجی برنامه‌ی بالا در زیر آمده است. با دقت نگاه کنید:


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

حالا بر می‌گردیم به حلقه‌ی for. ما می‌خواهیم هنگامی که برنامه اجرا شد، اعداد 0 تا 9 در خروجی استاندارد چاپ شود. برای این‌کار کد خود را به صورت زیر تغییر می‌دهیم:


شمارنده‌ی ما (متغیر i) مقدار صفر دارد و در هر بار اجرای حلقه یک واحد به آن اضافه می‌شود. ما همان متغیر را در خروجی استاندارد چاپ کرده‌ایم. بنابراین خروجی برنامه‌ی ما چاپ اعدا 0 تا 9 است.

نکته‌ی دیگری که در مورد حلقه‌ها وجود دارد این است که اگر الگوریتمی که برای طراحی حلقه پیاده‌سازی می‌کنیم اشتباه باشد، با نتایج متفاوتی رو به رو می‌شویم. مثلا ممکن است که حلقه‌ی ما پایان نداشته باشد و تا بی‌نهایت ادامه داشته باشد. یک حلقه‌ی بی‌نهایت ساده در زیر مشاهده می‌کنید:


در کد بالا شرط حلقه هیچ وقت برقرار نمی‌شود. یعنی همیشه متغیر i یک واحد کم می‌آورد. برای همین این حلقه تا بی‌نهایت ادامه دارد. (بعد از اجرای برنامه، برای نگهداری برنامه بر روی دکمه‌ی قرمز رنگ در کنسول اکلیپس با نام Terminate کلیک کنید).

حلقه‌های تو در تو
اگر در داخل بدنه‌ی یک حلقه از یک حلقه‌ی دیگری استفاده شود، می‌گوییم که حلقه‌های تو در تو ایجاد شده‌اند. نکته‌ای که باید در مورد حلقه‌های تو در تو یا (Nested Loops) توجه کنیم این است که به ازای هر بار تغییر شمارنده‌ی حلقه‌ی بیرونی، حلقه‌ی درونی یک‌بار به طور کامل اجرا می‌شود. به عنوان مثال فرض کنید شمارنده‌ی حلقه‌ی بیرونی و داخلی 0 است. وقتی شمارنده‌ی حلقه‌ی بیرونی از صفر به یک تبدیل می‌شود، حلقه‌ی داخلی یک‌بار به طور کامل (به عنوان مثال اگر شرط حلقه 10 است) یعنی 10 بار اجرا می‌شود و بعد از ده بار اجرای حلقه‌ی داخلی، حلقه‌ی بیرونی یک‌بار دیگر تغییر می‌کند.
به عنوان تمرین برنامه‌ای بنویسید که جدول ضرب را از 0 تا 100 به صورت مرتب چاپ کند. (برای حل این مسئله در مورد کارکتر‌های کنترلی تحقیق کنید. به عنوان مثال کاراکتر کنترلی t\). خروجی جدول ضرب به صورت زیر است:


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

در جلسه‌ی آینده در مورد ساختار‌های حلقه‌های تکرار دیگر در جاوا صحبت می‌کنیم.

مفاهیم پایه در زبان جاوا (قسمت ۵)


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

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

همانطور که در کد بالا مشاهده می کنید، ما از هر سه نوع کامنت‌گذاری که در جاوا وجود دارد استفاده کرده‌ایم.

اولین کامنت با دو علامت اسلش (Slash) که به شکل // است مشخص شده است. این نوع کامنت‌گذاری فقط برای یک خط است و از بعد از علامت // هرچیزی را که بنویسیم، تا آخر همان خط به صورت کامنت در می‌آید.

کامنت بعدی با علامت‌های اسلش استار (Slash Star) */ شروع می‌شود و با استار اسلش (Star Slash) /* تمام می‌شود. در این نوع کامنت ما می‌توانیم توضیحات خود را در چندین خط بنویسیم. همانطور هم که مشاهده می‌کنید هر خط با یک ستاره (*) شروع شده است.

آخرین کامنت که به آن جاوا داک (Javadoc) گفته می‌شود مخفف: Java Documentation است. این نوع کامنت فقط مخصوص زبان برنامه‌نویسی جاوا است. جاوا داک با علامت‌های یک اسلش و دو ستاره (**/) شروع می‌شود و در آخر هم با یک ستاره و اسلش (/*) پایان می‌پذیرد. جملاتی که در جاوا داک نوشته می‌شود در حقیقت مستندات جاوا هستند و این امکان وجود دارد تا در پایان انجام پروژه با استفاده از ابزار javadoc که یکی از ابزار‌های JDK است از روی این مستندات فایل‌های HTML تولید کنیم. به کد زیر توجه کنید:


در کد بالا ما یک متد با نام run نوشته‌ایم و در بدنه‌ی آن رشته‌ای را به خروجی استاندارد ارسال کرده‌ایم (متد زیاد مهم نیست!). نکته‌ی مهم این است که ما قبل از متد run از جاوا داک استفاده کرده‌ایم. بنابراین جاوا داک برای متد run تولید می‌شود. ابتدا یک توضیح کوتاهی نوشته‌ایم و بعد با استقاده از تگ‌های version و author، ورژن و نویسنده‌ی برنامه را مشخص کرده‌ایم. همانطور که در قسمت پایین کد مشاهده می‌کنید، اکلیپس به صورت خودکار جاوا داک را برای ما تولید کرده است و در یک پنجره با نام javadoc تمام چیز‌هایی که ما در کامنت نوشته‌ایم را نوشته است. (با دقت به جاوا داک نگاه کنید تا متوجه‌ی جزئیات آن شوید). یکی دیگر از کاربرد‌های جاوا داک این است که ما می‌توانیم به دید یک منبع آموزشی به جاوا داک‌ها نگاه کنیم. زیرا توسعه‌دهندگان جاوا توضیحات مفصلی را هنگام تولید کلاس‌های جاوا به صورت جاوا داک نوشته‌اند و ما می‌توانیم با مراجعه به آن‌ها اطلاعاتی را کسب کنیم.

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


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

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


در کد بالا یکی دیگر از کاربرد‌های کامنت‌ها دیده شده است. هنگامی که ما در برنامه کدی را نوشته‌ایم، اما به دلایلی نمی‌خواهیم فعلا آن کد اجرا شود و همچنین نمی‌خواهیم که آن کد را پاک کنیم، بنابراین آن کد را به صورت کامنت در می‌آوریم تا آن را نه کامپایلر اجرا کند و نه ما آن را پاک کنیم. در مثال بالا کدی که ما برای مثال حلقه‌ی while نوشته‌ایم را با کمی تغییرات به صورت کامنت در آورده‌ایم تا اجرا نشود.
ساختار do-while را در کد بالا مشاهده می‌کنید. ابتدا از کلمه‌ی کلیدی do استفاده می‌کنیم و بعد بدنه‌ی حلقه را مشخص می‌کنیم و در آخر هم شرط حلقه را می‌نویسیم. برنامه‌ای که ما در بالا نوشته‌ایم به این صورت است که اگر مقدار number کوچکتر از ۱۰ شد از حلقه خارج شود. این برنامه را اگر با while بنویسیم، برنامه‌ی ما هیچ خروجی‌ای ندارد. زیرا ابتدا شرط حلقه چک می‌شود و شرط هم برقرار نیست. بنابراین حتی یک‌بار هم بدنه‌ while اجرا نمی‌شود. اما اگر در ساختار do-while همان برنامه را بنویسید، برنامه‌ی ما یک خروجی دارد. زیرا قبل از اینکه شرط حلقه بررسی شود، مقدار number چاپ شده است و بعد شرط حلقه بررسی شده است.

چه وقت بهتر است از کدام یک از این حلقه‌ها استفاده کنیم؟
همانطور که قبلا هم نیز متذکر شدیم، اگر از قبل تعداد دفعات مورد نیاز اجرای حلقه را بدانیم، بهتر است از ساختار for برای ایجاد حلقه استفاده کنیم. گرچه می‌توان از حلقه‌ی while نیز برای ایجاد حلقه‌ی تکرار با شمارنده استفاده کرد! اما از انجام این کار به شدت خودکاری کنید. زیرا از خوانایی برنامه می‌کاهد. اما هرگاه تعداد دفعات تکرار حلقه را ندانیم باید به دنبال یک نگهبان برای شرط حلقه باشیم تا بتوانیم از یکی از دو ساختار while یا do-while استفاده کنیم. همچنین هرگاه نیاز داشته باشیم دستورات داخل بلاک حلقه حداقل یکبار اجرا گردد، از ساختار do-while استفاده می‌کنیم، در غیر این صورت از ساختار while باید استفاده کرد.

استفاده از قابلیت‌های اکلیپس
تمام محیط‌های توسعه‌ی برنامه نویسی قابلیت‌هایی را دارند که برنامه‌نویسی را ساده‌تر می‌کنند. منظور از ساده کردن برنامه‌نویسی این است که مثلا اگر در سینتکس برنامه‌ی ما خطایی رخ داده باشد، محیط‌های توسعه، آن خطا را مشخص می‌کنند و راهکاری را نیز برای رفع آن مشکل پیشنهاد می‌دهند. البته همیشه این راه‌کار‌ها درست نیست. یا به عنوان مثالی دیگر قابلیت تکمیل کد‌ها را دارند. این کار جدا از اینکه به نوشتن برنامه سرعت می‌دهد، باعث می‌شود که کد‌ها به درستی نوشته شوند. همانطور که می‌دانید زبان جاوا یک زبان Case Sensitive است. یعنی به حروف بزرگ و کوچک حساس است. حالا فرض کنید برنامه‌نویس می‌خواهد از یک متد استفاده کند. بنابراین باید نام آن متد را دقیقا به همان صورتی که تعریف شده است بنویسد. ممکن است در نوشتن نام متد اشتباه کند. اما اگر از قابلیت تکمیل کد IDE استفاده کند هرگز این اشتباه رخ نمی‌دهد. به عنوان مثال فرض کنید که ما می‌خواهیم جمله‌ی ;()System.out.println را بنویسیم و رشته‌ای را به خروجی استاندارد ارسال کنیم. ما می‌توانیم فقط با نوشتن: sysout و سپس گرفتن دکمه‌های ترکیبی: Ctrl + Space جمله‌ی فوق را کامل کنیم. به این کار Template گفته می‌شود. برای دیدن Templateها در اکلیپس ابتدا به منوی Window بروید و بعد آخرین گزینه یعنی: Preferences را انتخاب کنید. در پنجره‌ی باز شده، از قسمت بالا سمت چپ عبارت Template را سرچ کنید. (شکل زیر):


همانطور که در تصویر مشاهده می‌کنید، طبق شماره‌های مشخص شده پیش بروید و در Template و بر روی sysout کلیک کنید. در قسمت Preview کد کامل آن نمایش داده می‌شود.
از دیگر قابلیت‌های محیط‌های توسعه این است که ما می‌توانیم مشخص کنیم که برای هر خط از کد ما یک عددی را درنظر بگیرید. به عکس زیر دقت کنید:


همانطور که در عکس مشخص است، ابتدا بر روی نوار کناری کلیک راست کنید و از منوی باز شده گزینه‌ی Show Line Numbers را انتخاب کنید (مستطیل قرمز رنگ). در ادامه اگر به کنار هر خط کد توجه کنید، شماره‌ای برای آن خط در نظر گرفته شده است (مستطیل آبی رنگ).

Perspective
یکی دیگر از قابلیت‌های موجود در اکلیپس، انتخاب پرسپکتیو است. اجازه دهید پرسپکتیو را اینگونه برای شما توضیح دهم. همانطور که قبلا اشاره کردیم، محیط‌های توسعه قابلیت‌هایی را برای برنامه‌نویسان مهیا می‌کنند. بخشی از این قابلیت‌ها پنجره‌هایی است که ما برای مشاهده‌ی خروجی برنامه‌ خود به آنها مراجعه می‌کنیم. اما ما در هنگام تولید یک برنامه کار‌های زیادی قرار است انجام دهیم. مثلا ما در هنگام نوشتن کد‌های یک برنامه فقط به پنجره‌های Console, Problems, Javadoc و ... احتیاج داریم. اما فرض کنید که ما در هنگام نوشتن برنامه بخواهیم برنامه را دیباگ کنیم. بنابراین ما به پنجره‌های دیگری از قبیل Variables, BreakPoints و ... هم احتیاج داریم. حالا فرض کنید اگر ما بخواهیم تمام این پنجره‌ها را در یک صفحه قرار دهیم، چقدر صفحه‌ ما شلوغ می‌شود. بنابراین ما از قابلیتی به نام Perspective استفاده می‌کنیم. Perspective به این معنی است که ما پنجره‌هایی را که برای یک کار خاص (مثلا دیباگ کردن) احتیاج داریم را انتخاب می‌کنیم و آن را با یک نام مشخص Save می‌کنیم. بعدا هر موقع که خواستیم سریعا به پرسپکتیو دیباگ مراجعه می‌کنیم و بصورت حاضر و آماده از پنجره‌های موجود استفاده می‌کنیم. به صورت پیش‌فرض پرسپکتیو اکلیپس (برای نسخه‌ JavaSE) جاوا (Java) است. برای دیدن Perspective‌های دیگر به عکس زیر توجه کنید:


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


به عنوان مثال اولین پرسپکتیو یعنی Debug را انتخاب و بعد بر روی دکمه‌ی OK کلیک کنید. بعد از OK کردن نمای صفحه عوض می‌شود و همچنین پرسپکتیو Debug نیز در کنار پرسپکتیو Java قرار می‌گیرد (تصویر زیر):


همانطور که مشاهده می‌کنید چینش پنجره‌های اکلیپس عوض شد و بعضی از پنجره‌ها غیب شدند و بعضی دیگر جای آن‌ها را گرفتند. حالا برای برگشتن به پرسپکتیو جاوا فقط کافی است بر روی پرسپکتیو جاوا کلیک کنید. همچنین می‌توانید براساس سلیقه‌ی خود چینش پنجره‌ها را تغییر دهید (راست کلیک بر روی پرسپکتیو و انتخاب گزینه‌ی: ...Customize) و با نام دلخواه آنها را Save کنید. برای این کار کافی است بر روی پرسپکتیو مورد نظر کلیک راست کنید و بعد گزینه‌ی ...Save As را انتخاب کنید. در پنجره‌ی باز شده یک نام برای پرسپکتیو خود انتخاب کنید و سپس پنجره را OK کنید. البته پیشنهاد می‌شود که تغییری در پرسپکتیو‌های پیش‌فرض ایجاد نکنید. زیرا تمام آن‌ها برای یک کار خاص طراحی شده‌اند.

در جلسه آینده با نحوه‌ی دیباگ کردن برنامه آشنا می‌شویم.

مفاهیم پایه در زبان جاوا (قسمت ۶)


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

داده‌های یک برنامه ممکن است از طریق موس، صفحه کلید، فایل، حافظه‌ کامپیوتر و حتی شبکه وارد برنامه شوند. در بین تمام این ورودی‌ها صفحه کلید به عنوان ورودی استاندارد شناخته می‌شود. برای خواندن از صفحه کلید باید از جمله‌ی:
;()System.in.read استفاده شود. وقتی که از این کد برای دریافت ورودی استفاده می‌کنیم و کاربر روی یک کلید از کی‌بورد فشار می‌دهد تا یک داده‌ای را وارد برنامه کند (به عنوان مثال دکمه‌ی a)، متد ()read کد اسکی (ASCII) کارکتر a را بر می‌گرداند. (در مورد کد‌های اسکی تحقیق کنید و با فلسفه‌ی بوجود آمدن آن‌ها آشنا شوید). اما برای درک بهتر با یک مثال کار خود را ادامه می‌دهیم. در مثال زیر می‌خواهیم کد‌های اسکی کارکتر‌های a و A را بدست بیاوریم.


همانطور که در کد بالا مشاهده می‌کنید ما ابتدا در خط‌های پنج و شش دو متغیر از نوع کارکتر تعریف کرده‌ایم. که به ترتیب مقادیر a و A را به آن‌ها نسبت داده‌ایم. حالا برای اینکه بخواهیم کد‌های اسکی آن‌ها را مشاهده کنید در خطوط ۸ و ۹ دو متغیر از نوع عدد صحیح تعریف کرده‌ایم و متغیر‌های کارکتری را به آن‌ها نسبت داده‌ایم. با این کار ما اگر متغیر‌های عدد صحیح را در خروجی استاندارد چاپ کنیم، بجای نمایش حروف a و A، یک سری عدد صحیح نمایش داده می‌شود که آن‌ها کد اسکی حروف تعریف شده هستند. نتیجه‌ی اجرای برنامه‌ی فوق به صورت زیر است:



اعداد صحیح 97 و 65 کد‌های اسکی حروف فوق هستند. همانطور هم که مشاهده می‌کنید کد‌های اسکی حروف کوچک با حروف بزرگ متفاوت است. به همین دلیل است که هیچ وقت a کوچک مساوی با A بزرگ نیست. (به عنوان تمرین برنامه را طوری تغییر دهید که با چاپ کد‌های اسکی، حروف آن‌ها نمایش داده شود).
مثال فوق صرفا برای آشنایی شما با کد‌های اسکی است و اینکه ما با فشار دادن یک کلید از کی‌بورد، در واقع عددی را وارد برنامه می‌کنیم. برای همین منظور وقتی ما از جمله‌ی ;()System.in.read برای دریافت ورودی استفاده می‌کنیم، و بخواهیم ورودی‌ را که دریافت کرده‌ایم را به کاربر نمایش دهیم، حتما باید ورودی را به داده‌ی کارکتری اصطلاحا Cast کنیم. کست کردن کاربرد‌های بسیار زیادی دارد. به کد زیر توجه کنید:



همانطور که مشاهده می‌کنید ما داده‌ای را که از طریق ورودی دریافت می‌کنیم را به داده‌ی کارکتری کست کرده‌ایم. یعنی داده‌ی پایه‌ی char را داخل یک جفت پرانتز باز و بسته قرار داده‌ایم. با این کار داده‌ی ما هرچیزی که باشد به کارکتر تبدیل می‌شود و بعد در متغیر ch ذخیره می‌شود. (می‌توانیم به داده‌های دیگر هم کست کنیم. مثلا به String, double و ... ).

همانطور که خودتان متوجه‌ این قضیه شده‌اید جمله‌ی ;()System.in.read فقط یک کارکتر را می‌خواند! اما ما می‌خواهیم برنامه‌ای را بنویسیم که به عنوان مثال یک جمله‌ای را از کاربر دریافت کند (یعنی مجموعه‌ای از کارکتر‌ها). بنابراین ما باید برای دریافت یک جمله‌ی کامل از کاربر، از یک حلقه استفاده کنیم. یعنی تا زمانی که کاربر در حال تایپ است و دکمه‌ی Enter را نزده است، برنامه متوقف نشود و به دریافت ورودی از کاربر ادامه دهد. برای این کار ما از یک حلقه‌ی while استفاده می‌کنیم. علت هم این است که ما (برنامه نویس) نمی‌دانیم که تا چه زمانی قرار است این حلقه ادامه پیدا کند. به عبارت دیگر نمی‌دانیم که چه زمانی کاربر می‌خواهد دکمه‌ی Enter را فشار دهد.
در زبان جاوا یک سری کارکتر‌هایی هستند که به آن‌ها کارکتر‌های کنترلی می‌گویند. یعنی آن کارکتر‌ها نمایش داده نمی‌شوند اما یک سری تغیراتی را ایجاد می‌کنند. کارکتر‌های کنترلی با استفاده از بک اسلش (Back Slash) مشخص می‌شوند و بعد در جلوی آن‌ها از یک سری حروف استفاده می‌شود که هر کدام نشانگر کار خاصی است. مثلا n\ در هر جایی که ظاهر شود، از ادامه‌ی آن را در خط بعدی نمایش می‌دهد. یا t\ یک تب (Tab) کارکتر را به جلو می‌برد. (ما با کارکتر‌های کنترلی در ادامه‌ی آموزش‌ها آشنا می‌شویم). r\ یکی از کارکتر‌های کنترلی است که به عبارتی کد اسکی دکمه‌ی Enter است. در برنامه‌ی زیر ما از این کارکتر کنترلی استفاده می‌کنیم. به کد زیر دقت کنید:


در خط‌های ۵ و ۶ ابتدا یک متغیر از نوع String و یک متغیر از نوع کارکتر تعریف کرده‌ایم که مقادیری ندارند. قلب برنامه‌ ما در حلقه‌ while است. ابتدا به بدنه‌ی حلقه توجه کنید. در خط 10 همانطور که قبل‌تر هم گفته شد ما یک کارکتر دریافت می‌کنیم و آن را کست می‌کنیم. در خط بعدی هم مقدار داده‌ای را که در خط قبل دریافت کرده‌ایم به String تبدیل می‌کنیم. البته برای کوتاه‌تر شدن کد هم می‌توانیم در تبدیل به String کد را به صورت زیر بنویسیم:



تکه کد فوق دقیقا معادل با کدی است که ما در خط 11 نوشته‌ایم. در حلقه‌ی while ابتدا شرط آن بررسی می‌شود و اگر شرط آن برقرار بود ادامه‌ اجرای برنامه به داخل حلقه می‌رود. در غیر اینصورت برنامه از حلقه خارج می‌شود. علامت =! به معنی نابرابری است. یعنی تا زمانی که مقدار ch برابر با کاراکتر کنترلی r\ (یا همان دکمه‌ی Enter) نبود یا به عبارتی دیگر نابرابر کداسکی دکمه‌ی Enter بود، حلقه‌ی ما ادامه دارد. به محض اینکه کاربر دکمه‌ی اینتر را فشار دهد مقدار ch برابر با کد اسکی اینتر می‌شود و برنامه از حلقه خارج می‌شود. در خط 14 هم مقدار String را نمایش داده‌ایم.
خروجی برنامه:


همانطور که مشاهده می‌کنید عبارتی که با رنگ سبز نوشته شده است، مقداری است که من (کاربر) نوشته‌ام و خط بعدی که با رنگ سیاه است برنامه نوشته است، یعنی برنامه ورودی‌ را که من ارسال کردم را دریافت کرده و آن را نمایش داده است.

در کد فوق نکته‌ای است که باید به آن توجه کنید، این است که در مقابل متد main جمله‌ throws Exception نوشته شده است. این عبارت مربوط به ;()System.in.read است. اجرای ;()System.in.read و برخی دیگر از متد‌های جاوا ممکن است با خطا مواجه شود. در چنین مواردی برنامه باید تصمیم بگیرد که با خطای احتمالی چگونه باید برخورد شود. عبارت throws Exception ساده‌ترین نوع برخورد با خطای احتمالی است که در آن هیچ تمهیدی برای رخداد خطا در نظر نمی‌گیرد. اگر برای این خطاها راه حلی در نظر نگیریم، ممکن است برنامه در هنگام اجرا اصطلاحا کرش (Crash) کند. (هندل کردن استثناها (Exceptions Handling) یکی از مباحث مهم در برنامه نویسی است که در یکی از فصل‌های این دوره‌ی آموزشی در مورد آن صحبت می‌کنیم).
در جلسه‌ آینده ما با دو نوع دیگر از نحوه‌ی ورودی گرفتن در جاوا آشنا می‌شویم. یکی کلاس اسکنر و دیگری دریافت ورودی از طریق واسط کاربری است.
به عنوان تمرین این جلسه، برنامه‌ای بنویسید که کد اسکی حروف a تا z (هم حروف کوچک و هم حروف بزرگ) را نمایش دهد.

مفاهیم پایه در زبان جاوا (قسمت ۷)


در جلسه‌ قبل ما با نحوه‌ی ورودی گرفتن از طریق کنسول آشنا شدیم. در این جلسه با انواع دیگری از روش‌های ورودی گرفتن در جاوا آشنا می‌شویم (ورودی از طریق اسکنر و واسط کاربری). همچنین با کلاس Math و متد‌های آن آشنا می‌شویم و به متد‌ها نگاهی عمیق‌تر می‌کنیم. در ادامه یاد می‌گیریم چگونه مقادیری را برای پارامتر‌های متد main در نظر بگیریم و از آن‌ها استفاده کنیم. این پارامتر‌ها را هم از طریق Command Prompt به برنامه ارسال می‌کنیم و هم از طریق محیط توسعه‌ اکلیپس.

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

یکی دیگر از روش‌های دریافت ورودی از کاربر استفاده از کلاس Scanner است. این کلاس در پکیج java.util قرار دارد و برای استفاده از این کلاس حتما باید پکیج مربوطه را import کنیم. برای استفاده از کلاس اسکنر ابتدا باید با استفاده از کلمه‌ی کلیدی new یک آبجکت یا شی بسازیم. با توجه به اینکه در حال حاضر ما به مبحث شی‌گرایی نرسیده‌ایم بهتر است فقط نحوه‌ی استفاده از این کلاس را حفظ کنید تا بعدا در مبحث مربوطه با جزئیات کار آشنا شوید. به کد زیر دقت کنید:

همانطور که مشاهده می‌کنید ما ابتدا نام کلاس Scanner را نوشته‌ایم و بعد متغیری با نام input تعریف کرده‌ایم و بعد با استفاده از کلمه‌ی کلیدی new شی‌ را ساخته‌ایم. متغیر input در اصل ارجاعی به شی Scanner است نه اینکه خود input شی باشد. اما تمام برنامه نویسان برای راحتی کار به متغیر input آبجکت یا شی می‌گویند. به عملی که ما در بالا انجام داده‌ایم ساختن یک آبجکت یا شی از روی کلاس Scanner گفته می‌شود. در مبحث شی‌گرایی مفهومی است با نام Constructor یا سازنده که به متد هم نام آن کلاس گفته می‌شود. (این مفاهیم در مبحث شی گرایی به طور مفصل توضیح داده خواهد شد. پس نگران نباشید!!!). اگر در کد بالا دقت کنید ما در داخل پرانتز‌های باز و بسته‌، استریم (جریان) System.in را نوشته‌ایم. همانطور که در آموزش قبلی مشاهده کردید ما با استفاده از System.in از طریق کنسول برنامه ورودی‌ را دریافت کردیم. در اینجا System.in در کانستراکتور کلاس Scanner معرف جریان داده‌ای است که از طریق کنسول برنامه از کاربر دریافت می‌شود. این جریان داده در اختیار آبجکت اسکنر قرار داده می‌شود تا این آبجکت نیز داده‌ها را در قالب یک متن قابل تفسیر در اختیار ما قرار دهد. در ادامه ما با استفاده از متد‌هایی که در کلاس Scanner تعریف شده اند می‌توانیم از کاربر ورودی دریافت کنیم. بعضی از این متد‌ها در زیر آورده شده اند:

حالا می‌خواهیم برنامه‌ای بنویسیم که کاربر یک متنی را بنویسد و تا زمانی که دکمه‌ی Space را نزده است، متن نوشته شده توسط کاربر وارد برنامه شود. یعنی زمانی که Space زده شد، از Space به بعد را برنامه نادیده بگیرد (وارد برنامه نشود). به کد زیر توجه کنید:

در مورد کدی که در خط هفت نوشته شده است توضیح داده شد. مهم ترین خط، خط 10 است که ابتدا یک متغیر با نام name از نوع String تعریف کرده‌ایم و بعد علامت مساوی را قرار داده‌ایم. در سمت راست مساوی ما عملیات ورودی را انجام داده‌ایم. ما با استفاده از متد next می‌توانیم به متنی که توسط کاربر تایپ شده است دست یابیم. چون متد next در کلاس اسکنر است، بنابراین برای دسترسی به آن متد باید از آبجکتی که از روی آن کلاس ایجاد شده است استفاده کنیم. ما آبجکت input را از روی کلاس Scanner ایجاد کرده‌ایم. بنابراین ابتدا این آبجکت را می‌نویسیم و سپس یک نقطه (.) قرار می‌دهیم و بعد نام متد را می‌آوریم. وقتی اجرای برنامه به این خط از برنامه می‌رسد (خط 10)، برنامه منتظر می‌ماند تا کاربر چیزی را در کنسول برنامه تایپ کند و سپس دکمه‌ی اینتر را بزند. بعد از اینکه کاربر دکمه‌ی اینتر را فشار داد، چیز‌هایی که کاربر تایپ کرده است در متغیر name ذخیره می‌شود. در خط آخر برنامه هم (خط 13) استفاده از آبجکت اسکنر مسدود شده است. مسدود کردن آبجکت Scanner باعث آزاد شدن کنسول برنامه می‌شود تا قسمت‌های دیگر برنامه در صورت نیاز بتوانند از آن استفاده کنند.

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

اگر پکیج‌ها را import نکنیم و به شکل بالا از کلاس‌ها استفاده کنیم، نکته‌ای است که همانطور که مشاهده می‌کنید ما در هر جایی که بخواهیم از کلاس Scanner استفاده کنیم، باید نام کلاس به همراه نام دقیق پکیج آن نوشته شود. اما اگر import کنیم دیگر نیازی به این کار نیست. بنابراین import کردن بهترین کار است. نکته‌ی مهم دیگری که در این کار وجود دارد این است که import کردن فقط در فایل java. است و وقتی که برنامه‌ی ما توسط ابزار javac کامپایل می‌شود و فایل class. ایجاد می‌شود، دیگر در فایل class. خبری از import نیست. زیرا کامپایلر جاوا زمانی که می‌خواد برنامه را کامپایل کند و به کلاس اسکنر می‌رسد، به import ها نگاه می‌کند و کلاس مورد نظر را پیدا می‌کند و آن را دقیقا مشابه آن چیزی که ما در بالا نوشته‌ایم می‌نویسد.

خروجی برنامه‌فوق به صورت زیر است:

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

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

همانطور که در تصویر بالا مشاهده می‌کنید، هم کد و هم خروجی برنامه آورده شده است. کلاس JOptionPane در پکیج javax.swing قرار دارد و طبق معمول باید آن را import کرد.

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

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

در برنامه‌ بالا ابتدا دو متغیر از نوع String تعریف شده‌اند که هر کدام مقدار 2 را دریافت کرده اند. در خط هفت وقتی آن دو متغیر را با هم جمع می‌کنیم، براساس منطق ریاضی جواب باید 4 شود. اما جواب 22 است. در حقیقت 22 هم نیست!!!. فقط برنامه دو تا دو را در کنار هم نوشته است. اما در قسمت بعد برنامه ما دو متغیر از نوع int تعریف کرده‌ایم و در خط 11 آن‌ها را با هم جمع و در خروجی چاپ کرده‌ایم. اینبار جواب درست را می‌بینیم. یعنی 4.

در برنامه‌ای که دو عدد را از کاربر دریافت و سپس جمع می‌کند، برنامه ابتدا ورودی کاربر را در متغیر‌هایی از نوع String ذخیره کرده است. بنابراین اگر ما آن دو متغیر را با هم جمع کنیم، برنامه جواب درست را به ما نمی‌دهد. پس باید چه کاری انجام دهیم!؟ در خطوط 10 و 11 برنامه این مسئله روشن شده است. ما مقادیر String را به double تبدیل کرده‌ایم. در جلسه‌ی قبل در مورد cast کردن صحبت کردیم که می‌توانستیم داده‌ای از نوع دیگر را به داده‌ای از نوع دیگر تبدیل کنیم. اما در اینجا ما کست نکرده‌ایم. در حقیقت با استفاده از متد parseDouble، عمل پارس کردن را انجام داده‌ایم. علت هم این است که کست کردن فقط برای داده‌های پایه در جاوا است.

در جاوا ما به اندازه‌ی داده‌های پایه (Primitive Data Types)، کلاس‌های تقریبا با همین نام‌ها که با حروف بزرگ شروع می‌شوند داریم که به آن‌ها Wrapper class گفته می‌شود. ما در اینجا قصد صحبت کردن در مورد Wrapper class ها را نداریم. اما برای استفاده از متد parseDouble باید از Wrapper class ها استفاده می‌کردیم. نهایتا با کاری که ما در خطوط 10 و 11 انجام داده‌ایم، مقادیر String را به double تبدیل کرده‌ایم تا بتوانیم عملیات ریاضی بر روی آن‌ها انجام دهیم. خطوط بعدی برنامه هم کاملا واضح است. ما داده‌های تبدیل شده به double را با هم جمع کردیم و در یک متغیر دیگری از با نام result از نوع double ذخیره کرده‌ایم. در خط آخر هم جواب نهایی را با استفاده از کادر‌های گفتگو نمایش داده‌ایم.

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

استفاده از متد‌های کلاس Math

در جاوا کلاسی با نام Math وجود دارد که حاوی متد‌هایی برای انجام اعمال محسباتی و مثلثاتی است. بعضی از متد‌هایی که در این کلاس وجود دارند در زیر آمده است:

متد‌های بسیار زیادی در این کلاس وجود دارد که در بالا فقط هفت متد آن آورده شده است.

1. Math.sqrt ریشه‌ی دوم یک عدد را حساب می‌کند (جذر می‌گیرد).
   
2. Math.round یک عدد را رُند می‌کند.
   
3. Math.abs قدر مطلق یک عدد را حساب می‌کند.
   
4. Math.ceil یک عدد را به سمت بالا رُند می‌کند.
   
5. Math.floor یک عدد را به سمت پایین رُند می‌کند.
   
6. Math.sin سینوس یک عدد را حساب می‌کند.
   
7. Math.cos کسینوس یک عدد را حساب می‌کند.
   

تمام هفت متد معرفی شده در برنامه‌ی زیر به کار رفته است:

برنامه را اجرا کنید و خروجی آن را مشاهده کنید. (پاسخ سینوس و کسینوس را درست نمایش نمی‌دهد. در مورد آن سرچ کنید).

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

همانطور که مشاهده می‌کنید در خط اول import static را نوشته‌ایم و در استفاده از متد‌ها دیگر از نام کلاس Math استفاده نکرده‌ایم.

در زبان‌های برنامه نویسی دیگری مثل ++C به متد‌ها تابع گفته می‌شود. اما در جاوا از کلمه‌ی متد (Method) استفاده می‌شود. در این آموزش ما یک مثال ساده از نحوه‌ی نوشتن یک متد و استفاده از آن (فراخوانی متد) در برنامه آشنا شدیم. اگر بخواهیم نحوه‌ی کارکرد متد‌ها را در یک جمله برای شما توضیح دهیم، متد‌ها مانند یک کارخانه هستند که از یک سمت ورودی‌هایی را دریافت می‌کنند و بعد بر روی این ورودی‌ها که شامل هر نوع داده‌ای می‌تواند باشد پردازش‌هایی را انجام می‌دهند و از سمت دیگر خروجی‌ای را تولید می‌کنند.

متد‌ها را به روش‌های مختلفی می‌توانیم طراحی کنیم. می‌توان نوع برگشتی‌ای برای آن مشخص نکرد (یعنی متد از نوع void باشد) و یا می‌توان برای آن مقدار برگشتی مشخص کرد (می‌تواند از نوع int, double, String و ... باشد). که اگر مقدار برگشتی برای آن‌ها مشخص کنیم، در آخر آن متد باید با استفاده از کلمه‌ی کلیدی return مقداری را برگرداند. در آموزشی که گفته شد متد ما مقدار برگشتی نداشت (یعنی از نوع void بود). اما در ادامه می‌خواهیم مثالی را برای شما بیاوریم که متد ما از نوع int باشد و مقداری را برگرداند. به کد زیر توجه کنید:

همانطور که در کد فوق مشخص است، ما در خط 8 یک متدی با نام sum که از نوع int است ساخته‌ایم. (منظور از int نوع برگشتی متد ما است و متد باید یک مقدار صحیح برگرداند. بنابراین از کلمه‌ی کلیدی void استفاده نمی‌کنیم). در داخل متد هم همانطور که معلوم است دو متغیر از نوع عدد صحیح با مقادیر تعیین شده تعریف کرده‌ایم. در آخر هم (خط 12) این دو متغیر را با هم جمع کرده‌ایم و با استفاده از کلمه‌ی کلیدی return مقداری را برگردانده‌ایم. (شاید برگرداندن مقدار کمی گنگ باشد. در ادامه متوجه می‌شوید). ما برای استفاده از این متد باید این متد را از داخل متد اصلی (main) فراخوانی کنیم. بنابراین برای فراخوانی متد فقط کافیست نام متد را بنویسیم. ما در متد main نام متد را در داخل جمله‌ی ;()System.out.println نوشته‌ایم. علت هم این است که می‌خواهیم مقداری که متد برمی‌گرداند را در کنسول مشاهده کنیم. بنابراین اگر برنامه را اجرا کنیم، خروجی اجرای برنامه‌ی ما 10 است. یعنی مقدار برگشتی متد ما حاصل جمع دو متغیری است که در داخل آن تعریف شده است.

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

در برنامه‌ قبلی ما دو متغیر num1 و num2 را داخل بدنه‌ متد تعریف کردیم. اما این‌بار همانطور که مشاهده می‌کنید در پرانتز‌های باز و بسته‌ متد sum تعریف کرده‌ایم. این‌ها پارامتر‌های متد ما هستند و نکته‌ی بسیار مهمی که وجود دارد این است که باید در همان ابتدای استفاده از متد پارامتر‌های متد را مقدار دهی کنیم. در غیر این صورت برنامه‌ی ما کامپایل نمی‌شود. زیرا در جاوا مقدار پیش فرض برای یک پارامتر وجود ندارد. یعنی برای فراخوانی یک متدی که دارای پارامتر است، باید حتما مقدار تمام پارامتر‌های متد را به ترتیب مشخص کنیم. به خط 5 در داخل متد main توجه کنید. ما وقتی متد sum را فراخوانی کرده‌ایم، به ترتیب برای پارامتر‌های آن مقادیری را تعیین کرده‌ایم. شما می‌توانید هر مقدار دیگری را در نظر بگیرید. بنابراین اگر برنامه را اجرا کنید پاسخ 12 خواهد بود.

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

سوال اینجاست که متد main چگونه اجرا می‌شود؟ پاسخ این است که متد ()main توسط برنامه نویس فراخوانی نمی‌شود، بلکه در زمان اجرا توسط JVM فراخوانی می‌شود. هنگامی که ما با استفاده از ابزار java کلاس را اجرا می‌کنیم، ماشین مجازی جاوا متد ()main درون کلاس مشخص شده را یافته و اجرا می‌کند.

با توجه به توضیحات قسمت قبل، گفتیم که در جاوا مقدار پیش فرض برای پارامتر‌ها وجود ندارد. پارامتر‌های ورودی متد main یک آرایه‌ای از رشته‌ها است (String[] args) (در مورد آرایه‌ها بعدا توضیح داده خواهد شد). اما ما هیچگاه مقادیر پارامتر‌های متد main را مشخص نکرده‌ایم.

پس چگونه برنامه‌ی ما اجرا می‌شود؟ پاسخ این است که از آنجایی که متد main توسط JVm فراخوانی می‌شود، در فراخوانی آن می‌توانید هیچ پارامتری را مشخص نکنید، در این صورت JVM متد ()main را با یک پارامتر بدون مقدار (null) فراخوانی می‌کند.

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



کد بالا به این معنی است که نام آرایه‌ی ما array است و به خانه‌ی یکم اشاره می‌کند. ایندکس آرایه را هم در بین یک جفت کروشه می‌نویسیم. به این صورت به آن خانه‌ی آرایه دسترسی پیدا می‌کنیم.

حالا ما می‌خواهیم از پارامتر‌های متد main استفاده کنیم. یعنی می‌خواهیم مقادیری را برای آن‌ها در نظر بگیریم و آن‌ها را در خروجی استاندارد چاپ کنیم. برای این کار دو راه وجود دارد. یکی اینکه از طریق Command Prompt موقع‌ای که می‌خواهیم برنامه را اجرا کنیم پارامتر‌ها را ارسال کنیم. و راه دیگر که راه آسان تری است از محیط توسعه‌ی اکلیپس برای این کار استفاده کنیم. ما ابتدا روش اول را آموزش می‌دهیم. به کد زیر توجه کنید:


به پارامتر متد main توجه کنید. آرایه‌ای از جنس String تعریف شده است. (نحوه‌ی تعریف آرایه به این شکل است). در خطو 5 و 6 و 7 هم با استفاده از جمله‌ی ;()System.out.println محتویات خانه‌های 1 تا 3 آرایه را چاپ کرده‌ایم. (توجه کنید که اگر به همین شکل برنامه را اجرا کنید با خطا مواجه می‌شوید. زیرا هنوز مقادیری برای پارامتر متد main در نظر نگرفته‌ایم). ابتدا این برنامه را با استفاده از Command Promt کامپایل کنید تا فایل class. آن ایجاد شود. سپس به عکس زیر توجه کنید:


همانطور که در تصویر مشاهده می‌کنید ما ابتدا برنامه‌ی خودمان را کامپایل کرده‌ایم و سپس با استفاده از ابزار java می‌خواهیم کلاس MainClass را اجرا کنیم. ما در برنامه‌ی خود محتویات سه خانه‌ ابتدایی پارامتر متد main را در خروجی استاندارد چاپ کرده‌ایم. بنابراین در اینجا هنگام اجرای برنامه باید مقادیری را برای آن پارامتر‌ها در نظر بگیریم. همانظور که مشاهده می‌کنید مقادیر خانه‌های یک تا سه آرایه مشخص شده است. برای هر خانه چیزی را که می‌خواهیم می‌نویسیم و سپس یک Space می‌زنیم. هنگامی که Space می‌زنیم به سراغ خانه‌ی بعدی آرایه می‌رومیم. خروجی برنامه هم در کادر قرمز رنگ در تصویر مشخص شده است.
اما روشی راحت‌تر برای ارسال پارامتر به متد ()main وجود دارد و آن استفاده از اکلیپس است. برای ارسال پارامتر از طریق اکلیپس باید به پنجره‌ی Run Configurations مراجعه کنید. به تصویر زیر توجه کنید:


همانطور که در تصویر مشخص است دو راه برای دسترسی به Run Configurations وجود دارد. یا در فیلد Quick Access عبارت Run Configurations را سرچ کنید و یا اینکه بر روی علامت پیکان دکمه‌ی Run کلیک کنید تا منوی آن باز شود و گزینه‌ی مشخص شده را انتخاب کنید. بعد از انتخاب گزینه‌ مورد نظر وارد پنجره‌ی زیر می‌شوید:


در پنجره‌ فوق ابتدا تب Arguments را انتخاب کنید و در قسمت Program Arguments مقادیری را تایپ کنید و در آخر بر روی دکمه‌ی Run کلیک کنید. برنامه اجرا می‌شود و دقیقا این سه مقداری که ما در اینجا نوشته‌ایم در خروجی چاپ می‌شود.