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

با سلام و احترام خدمت کاربران گرامی

در این تاپیک آموزش مفاهیم پایه ای برنامه نویسی جاوا را دنبال خواهیم کرد و این تاپیک به صورت روزانه و هر روز چند پست ، به روزرسانی خواهد شد 

مقدمه بر زبان های برنامه نویسی

در حقیقت گام اول و اساسی برای برنامه نویس شدن انتخاب زبان برنامه نویسی مناسب است. منظور از زبان برنامه نویسی مناسب این است که هر زبان برنامه نویسی دارای نقاط ضعف و قوتی و بسته به اینکه شما چه نیازی از زبان برنامه نویسی دارید یکی را بر دیگر زبان ها ترجیح خواهید داد. زبان برنامه نویسی Visual Basic شرکت مایکروسافت برای طراحی هزاران هزار برنامه تجاری، اداری و شخصی مورد استفاده قرار گرفته است و این در حالی است که برنامه های طراحی شده در این زبان برنامه نویسی در مقایسه با برنامه های طراحی شده در قالب زبان های دیگری همچون زبان برنامه نویسی C# و C++ از سرعت اجرای کمتری برخوردارند و این افت سرعت در برنامه هایی همچون بازی ها که از گرافیک بالاتری نسبت به مابقی برنامه ها برخوردارند نمود بیشتری دارد.

زبان برنامه نویسی جاوا در اوایل دهه 1990 توسط جیمز گاسلینگ و همکارانش در شرکت سان مایکروسیستمز پایه ریزی شد و از همان ابتدا شعار طراحان این زبان این بود که "یک بار بنویس، همه جا اجراش کن" که بعد ها این شرکت توسط شرکت اوراکل خریداری شد. در حقیقت آقای گاسلینگ از روش برنامه نویسی در C++ خیلی احساس رضایت نمی کرد و همین امر موجب شد که وی زبان جاوا را بر مبنای زبان C++ طراحی کند به نحوی که برنامه های مد نظر ایشان را به نحو بهتری اجرا کند. این زبان برنامه نویسی موفق که در سال 1995 به طور رسمی وارد بازار شد توانست چنان محبوبیتی در جهان پیدا کند که در حال حاضر در بیش از 3 میلیارد ابزار رایانه ای و تلفنی مورد استفاده قرار گرفته و تاکنون بیش از 1000 جلد کتاب پیرامون آن به رشته تحریر درآمده است. این زبان داری ساختار یا Syntax همچون زبان های C و C++ می باشد اما از سادگی بیشتری برخوردار است. اگر چه که زبان برنامه نویسی جاوا نسبت به زبان برنامه نویسی Visual Basic از دشواری بیشتری برخوردار است اما این زبان از مزایای بسیاری برخوردار می باشد که از آن جمله می توان به این نکته اشاره کرد که زبان جاوا زبان وب و موبایل است به نحوی که از آن می توان در ساخت و طراحی اپلیکیشن ها و بازهای تحت وب و قابل اجرای بر روی گوشی های همراه استفاده کرد.

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

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

در واقع این همان ویژگی است که زبان برنامه نویسی جاوا را بسیار منحصر به فرد کرده است. آنچه زبان برنامه نویس جاوا را بسیار زیبا می سازد این ویژگی است که در ذیل در قالب مثال آپارتمان ذکر می شود. در واقع ما یک نقشه کلی یا Class برای آپارتمان طراحی می کنیم. حال تصمیم می گیریم که تعدادی از طبقات آپارتمان ما سه خوابه بوده و تعدای از آنها چهار خوابه ساخته شوند. در حقیقت ما از روی Class اصلی دو Class دیگر تحت عناوین سه خوابه و چهار خوابه طراحی می کنیم که ویژگی های Class اصلی را به ارث می برند. در برنامه نویسی جاوا به این رویداد Inheritance یا به ارث بردن می گویند. اصطلاحاً Class اصلی Superclass یا Class اصلی است و کلاس های سه خوابه و چهار خوابه Subclass یا Class زیرمجموعه می باشند. به عبارت دیگر می توان گفت که Class اصلی Class والد بوده و Class های زیرمجموعه Class فرزند می باشند.

نکته ای که در اینجا می بایست حتماً مد نظر قرار دهیم این است که Class خود به تنهایی منجر به ایجاد چیزی نخواهد شد چرا که Class یک مفهوم انتزاعی است و چنانچه بخواهیم نمود عینی یک Class را ببینیم به یک Object نیاز داریم. در حقیقت پیش از طرح ریزی زبان های برنامه نویسی شئی گرا، برنامه نویسان چنانچه مجبور بودند تغییری در بخش از برنامه خود ایجاد کنند می بایست کل برنامه را از ابتدا بنویسند اما پس از ظهور زبان های برنامه نویسی این مشکل به کلی حل شد چرا که با اعمال تغییر روی یک Class مد نظر، کلیه Object های برگرفته از آن Class تغییر خواهند یافت.

در مثال دوم فرض کنیم که قرار است برای یک بانک یک نرم افزار حفظ اطلاعات حساب های مشتریان بنویسیم. ساختار چنین برنامه ای به شکل زیر خواهد بود:

در مثال فوق ما یک Class داریم تحت عنوان Account و این کلاس ما دارای سه متغییر با نام های Name, Id, Balance به معنی به ترتیب نام، شناسه و موجودی می باشد. حال از روی این Class می توانیم دو Object ایجاد کنیم که Object اول دارای خصوصیاتName: CustomerOne, Id: 2234, Balance: 100000 و Object دوم دارای خصوصیات Name: CustomerTwo, Id: 2235, balance: 2000000 می باشد. در واقع هر دو Object ما نمود عینی کلاس Account می باشند.

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

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

اول ماشین را خاموش کند. دوم کاپوت ماشین را بالا بزند. سوم روکش انژکتور را بردارد. چهارم پس از باز کردن انژکتور سوزن سوم آن را تعویض کند. پنجم انژکتور را مجدداً سوار کند. ششم روکش آن را نصب کند. و در نهایت کاپوت ماشین را بسته و استارت بزند.

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

در برنامه نویسی اصطلاحاً به هر دستوری که می خواهیم اجرا شود یک Statement گفته می شود. حال برای نوشتن تعدادی Statement ما نیاز به یک ویرایشگر متن داریم تا بتوانیم دستورات مد نظر را در آن وارد سازیم

مسئله که موجب دلسردی و حتی دل زدگی بسیاری از برنامه نویسان تازه کار می شود مشکلاتی که در حین برنامه نویسی با آن ها رو به رو می شوند. این گونه مشکلات یا Error ها به دو دسته تقسم می شوند: گروه اول Error هایی هستند که از نوع Syntax یا ساختاری می باشند. به طور مثال دستور system.out.println(); در مقایسه با System.out.println(); اشتباه است چرا که حرف اول واژه system به صورت حرف کوچک نوشته شده است و همین مسئله موجب می گردد که برنامه اجرا نشود. خبر امیدوار کننده اینجا است که این گروه از مشکلات توسط خود نرم افزاری که برنامه مان را با آن می نویسیم تشخیص داده شده و به ما اخطار می دهد و به سادگی می توان آن را رفع کرد.

در مورد اینکه دستور بالا چه کاری را انجام می دهد در بخش های آتی به تفصیل توضیح خواهیم داد چرا که در اینجا صرفاً جهت مثال مورد استفاده قرار گرفته است. دسته دوم Errorهایی از نوع Logical یا منطقی هستند. به عبارت دیگر از لحاظ ساختار برنامه هیچ گونه مشکلی وجود ندارد و نرم افزار هم هیچ خطایی از برنامه نویس نمی گیرد اما در حین اجرای کد با مشکل مواجه خواهیم شد. به عنوان نمونه int total = 7 – 17; از لحاظ Syntax یا ساختار درست است ولی از لحاظ منطقی کاملاً اشتباه است چرا که هیچ وقت نمی توان یک عدد کوچک را از یک عدد بزرگتر از خود کسر کرد و برنامه نویس حتما در حین اجرای برنامه با مشکل مواجه خواهد شد. مشکلات برنامه نویسی اصطلاحاً Bug نامیده می شوند و فرایند مشکل یابی و رفع آن اصطلاحاً Debugging گفته می شوند.

انتخاب ابزاری برای برنامه نویسی جاوا

محیط های برنامه نویسی یا IDE های زیادی همچون JDK، Eclipse، IntelliJ IDEA و NetBeans هستند که به منظور نوشتن کد های جاوا و دیگر زبان های برنامه نوبسی می توان از آن ها استفاده کرد. در این سری از آموزش ها از محیط برنامه نویسی قدرتمند Eclipse استفاده می کنیم که علاقمندان می توانند به صورت رایگان آن را از سایت Eclipse بسته به نوع سیستم عامل خود دانلود کنند. در واقع برنامه Eclipse نیازی به نصب نداشته و صرفا پس از خارج کردن فایل دانلود شده از حالت زیپ با کلیک کردن بر روی آیکان eclipse.exe می توانید آن را اجرا نمایید. به منظور آماده سازی محیط برنامه نویسی جاوا شما حتماً بهJRE و JDK نیاز دارید که می توانید آخرین نسخه آن را از این لینک دریافت نمایید.

پس از اجرای برنامه اکلیپس از شما درخواست می شود تا مسیری را مشخص نمایید تا پروژه های جاوا که طراحی می کنید را در آن ذخیره سازد. این مسیر به دلخواه شما می تواند هرجایی رو کامپیوتر شما باشد. پس از مشخص کردن مسیر گزینه OK را انتخاب نمایید. از آنجا که این اولین باری است که شما نرم افزار را اجرا می کنید، یک صفحه خوش آمد گویی یا Welcome Screen نمایان خواهد شد. پس از نگه داشتن نشانگر موس خود روی تک تک گزینه ها، گزینه مرتبط با Workbench یا صفحه اصلی نرم افزار را پیدا نموده و روی آن کلیک نمایید. حال شما در محیط اصلی نرم افزار قرار دارید. از آنجا که ممکن است شما بیش از یک نسخه از نرم افزار جاوا را روی سیستم عامل خود نصب داشته باشید، نیاز است که در این مرحله برای اکلیپس مشخص کنید که از کدام نسخه جاوا برای برنامه نویسی استفاده کند(درحال حاضر آخرین نسخه جاوا 7 می باشد). در منوی اصلی اکلیپس، با انتخاب گزینه Windows زیرشاخه Preferences را انتخاب نمایید. در قسمت چپ پنجره منوی Java را انتخاب نمایید. با کلیک کردن روی مثلث مشکی رنگ کنار واژه Java قادر خواهید بود تا زیرشاخه های آن را نیز مشاهده کنید. از میان زیرشاخه ها گزینه Installed JREs را انتخاب کنید.

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

حال چنانچه نسخه JRE مد نظر شما در لیست موجود نباشد می توانید روی دکمه Add کلیک نموده و آن را به لیست فوق اضافه نمایید. در پنجره ای که باز خواهد شد روی گزینه Standard VM کلیک نمایید و سپس دکمه Next را کلیک نمایید. حال در بخش JER home مکانی که در آن جاوا را روی سیستم عامل خود نصب نموده اید را مشخص نمایید. معمولاً نسخه های JRE که روی ویندوز نصب می شوند در مسیر C:\Program Files\Java\jre7 قرار می گیرند. در صورتیکه اکلیپس به صورت خودکار بخش JRE name را پر نکرد می توانید این کار را خود با نامی مرتبط با JRE مد نظر انجام دهید. حال می توانید گزینه Finish را انتخاب نمایید تا تغییرات شما اعمال شود و به صفحه ای بازگردید که در آن نسخه های نصب شده JRE شما قابل مشاهده هستند. نسخه نصب شده جدید خود را پیدا نموده و آن را انتخاب نمایید. در این مرحله کار شما به پایان رسیده است. حال در همان منوی اصلی جاوا که از آن Installed JREs را انتخاب نمودید، زیرشاخه Compiler را پیدا نموده و به هیچ وجه آن را باز ننمایید بلکه فقط با کلیک کردن موس روی آن، آن را انتخاب نمایید تا رنگ آن آبی شود.

حال در منوی سمت راست مرتبط با زیرشاخه Complier از بخش Complier compliance level لیستی از نسخه های نصب شده JRE بر روی سیستم عامل را خواهید دید. به طور مثال برای جاوای نسخه 7 مورد 7.1 را از لیست انتخاب نمایید. حال می توانید دکمه OK صفحه Preferences را بزنید و به صفحه اصلی نرم افزار اکلیپس باز گردید. حال کلیه ابزارهای مورد نیاز برای نوشتن اولین برنامه جاوای خود را به صورت رایگان در اختیار دارید. آنچه جالب توجه است این است که با به کار گیری ابزاری رایگان از جاوا، پشتکار و انگیزه فراوان قادر خواهید بود به صورت میلیونی درآمد زایی کنید.

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

منابع:

از منابعی که در تدوین این سری آموزش های زبان برنامه نویسی جاوا استفاده شده است می توان به کتاب Beginning Programming with Java for Dummies ویرایش سوم از انتشارات Wiley و همچنین Teach Yourself Java in 24 Hours ویرایش ششم از انتشارات Sams و همچنین سایت رسمی شرکت اوراکل به آدرس http://docs.oracle.com و دیگر منابع آزاد اینترنتی اشاره کرد. در حقیقت هیچ کدام از مطالب این دوره آموزشی به صورت ترجمه لغت به لغت کتاب های اصلی نبوده و منابع صرفاً به منزله یک خط مشی مورد استفاده قرار گرفته اند.

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


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

تا اینجا شما اولین گام برای ساخت یک پروژه جاوا را برداشته اید. شما در محیط اکلیپس در بخش Package Explorer فولدر پروژه ای تحت عنوان HelloWorld خواهید دید. حال با کلیک بر روی نام پروژه ای که جدیداً ساخته اید آن را انتخاب نموده سپس کلیک راست نمایید. با انتخاب گزینه New پنجره دیگری باز خواهد شد و از میان گزینه های موجود روی گزینه Class کلیک نمایید. پنجره ای تحت عنوان New Java Class باز خواهد شد. به منظور دسترسی به چنین پنجره ای می توانید از منوی اصلی گزینه File را انتخاب نموده سپس روی گزینه New کلیک نمایید و در نهایت گزینه Class را انتخاب نمایید. حال در پنجره Class در بخش Name نامی را برای Class مد نظر انتخاب نمایید. در اینجا ما نام FirstProram را انتخاب می کنیم. این نام می بایست با نام فایلی به پسوند .java که در این مرحله ایجاد می گردد یکسان باشد که اکلیپس این کار را به صورت خودکار برای ما انجام خواهد داد).

چنانچه نام Class با نام فایل با پسوند .java یکی نباشد بسته به اینکه این Class ایجاد شده در کجای برنامه مورد استفاده قرار گیرد منجر به Error در حین Compile شدن برنامه خواهد شد(چنانچه نامی به غیر از آنچه می بایست انتخاب نمایید انتخاب کرده اید، می توانید روی فایل مد نظر کلیک راست نموده و از بخش Refactor گزینه Rename را انتخاب نمایید). لازم به ذکر است حرف اول نامی که برای Class خود انتخاب می نمایید می بایست با حرف بزرگ شروع شود. در حقیقت برای نامگذاری یک Class شما نمی توانید از , و- و فضای خالی استفاده کنید. تنها علامت نگارشی که در نامگذاری یک کلاس می توان استفاده کرد _ می باشد. حال گزینه ای با عنوان public static void main(String[] args) را تیک بزنید و دیگر گزینه ها را در حالت پیش فرض قرار داده و دکمه Finish را بزنید. اکنون درون کلاس HelloWorld شما می بایست کدهایی به شکل زیر را مشاهده نمایید:
 

1. class FirstProgram {
2. /**
3. * @param args
4. */
5. public static void main(String[] args) {
6. // TODO Auto-generated method stub
7. }
8. }

خطی از برنامه که در برگیرنده public static void main(String[] args) می باشد به جاوا می گوید که این نقطه به منزله نقطه آغازین برنامه است. در حقیقت واژه main به ما می گوید که این بخش از برنامه جایی است که برنامه از آن آغاز می گردد. همانطور که ما برای نگارش از پرانتز برای تبدیل تعدادی واژه به یک گروه استفاده می کنیم مثل (جاوا، زبان برنامه نویسی و اکلیپس)، در زبان برنامه نویسی جاوا نیز به منظور نشان دادن عناصری که به یک گروه تعلق دارند از { و } استفاده می کنیم. به عبارت دیگر هرآنچه که مابین { آغازین و } پایانی باشد از یک گروه می باشد. به این گروه ها در زبان برنامه نویسی جاوا Block گفته می شود. در کد بالا { اول بعد از واژه Firstprogram و آخرین } نشاگر یک block می باشند که کل برنامه جاوای ما را در بر می گیرند. نکته ای که اینجا می بایست مد نظر قرار داده شود این است که block ها را می توان درون دیگر block ها قرار داد. در خط 5 و خط 7 یک جفت {} دیگر مشاهده می شود که دربرگیرنده یک Method با نام main هستند(در بخش های آتی به توضیح اینکه یک Method چیست خواهیمم پرداخت). آنچه در این block قرار می گیرد به منزله نقطه آغازین برنامه خواهد بود. در خط ششم علامت // دیده می شود که اصطلاحاً در زبان برنامه نویسی جاوا Comment گفته می شود. در حقیقت Comment ها در زبان برنامه نویسی جاوا صرفاً برای خود برنامه نویس هستند و از چشمان Compiler مخفی می مانند. به عبارت دیگر چنانچه شما بخواهید نکته را درون کد خود بنویسید که از یک سو در حین اجرا از چشمان Compiler مخفی بماند و از سوی دیگر نکته ای را به شما یادآور شود از Comment ها استفاده می کنید. در زبان برنامه نویسی جاوا ما سه مدل Comment داریم که در بخش های آتی به تفصیل در مورد آن ها توضیح داده خواهد شد(از خط 2 تا پایان خط 4 نوع دیگری از آن ها قابل مشاهده است). نحوه استفاده از Comment خطی به این شکل است که در منتها الیه سمت چپ خطی از کد که نوشته اید علامت // را قرار دهید تا آن خط از کد از دید Compiler مخفی بماند (به محض اینکه علامت فوق را تایپ نمایید، رنگ کد شما به رنگ خاکستری تغییر رنگ خواهد داد و این بدان معنی است که این خط از کد به یک Comment تبدیل شده است. از این پس هر کجا که خطی یا خط هایی از کد به رنگ خاکستری کم رنگ دیدید، این بدان معنا است که آن خط یا خطوط Comment هستند). تا اینجا شما موفق شده اید که اولین برنامه جاوای خود را با موفقیت بنویسید. اما چنانچه از منوی اصلی گزینه Run و مجدداً گزینه Run را انتخاب کنید یا به جای این کار کلید F5 را بزنید هیچ خروجی را مشاهده نخواهید کرد چرا که در بخش main که به منزله نقطه آغازین برنامه است شما هیچ چیزی به جزء یک خط Comment که آن هم از دید Compiler مخفی می ماند ننوشته اید(در بخش های آینده در مورد تک تک واژگان خط 5 و معنی آن ها به تفصیل توضیح داده خواهد شد. با توجه به نوع کیبورد شما ممکن است برای فعال کردن دکمه F5 نیاز باشد هم زمان دکمه Fn را هم پایین نگه دارید. به منظور برنامه نویسی ما نیاز داریم تا اطلاعات مورد نظر خود را در جایی ذخیره سازیم. برای این کار ما اطلاعات را بسته به نوع آن ها درون یک Variable ذخیره می سازیم. در زبان برنامه نویسی جاوا ما 8 نوع Variable داریم و نکته ای که در اینجا می بایست خیلی مد نظر قرار داده شود این است که هر Variable می توان نوع خاصی از Data یا داده را در خود ذخیره سازد. به طور مثال، اگر Variable که مخصوص ذخیره سازی یک عدد صحیح است را برای یک تعداد واژه تعریف کنیم برنامه از ما ایراد خواهد گرفت. در طول آموزش ها با انواع Variable ها، نحوه به کار گیری آن ها، نحوه اختصاص Value یا مقدار به آن ها، به کار گیری اعمال اصلی میان آن ها مثل جمع و تفریق و... آشنا خواهیم شد. در اولین برنامه ای که ما می نویسیم می خواهیم جمله In the Name of God به معنی به نام خدا پس از اجرای برنامه نمایش داده شود. بنابراین ما نیاز به یک Variable داریم تا یک Value از جنس کلمه، جمله یا پاراگراف را بتواند در خود جای دهد. String یک Variable است که این کار را به راحتی می تواند برای ما انجام دهد. نکته ای که می بایست مد نظر قرار داده شود این است که هر Variable از سه بخش تشکیل می شود. بخش اول نوع خود Variable است که در این جا String می باشد(به خاطر داشته باشید که اولین حرف این واژه با حرف بزرگ نوشته شده است). بخش دوم نام Variable است که این نام کاملاً اختیاری است فقط می بایست به خاطر داشته باشیم که اولین حرف نام Variable می بایست با حرف کوچک نوشته شود. در اینجا نام text را در نظر می گیریم. و در نهایت Value آن که مابین “ ” قرار می گیرد. به منظور اختصاص دادن یک Value به یک Variable می بایست از = استفاده کرده و در نهایت یک ; قرار داد. در واقع در زبان برنامه نویسی جاوا و برخی از دیگر زبان های برنامه نویسی ; عملکردی همچون نقطه در حین نگارش یک متن دارد. به عبارتی با قرار دادن یک ; در انتهای یک Statement به جاوا می گوییم که به پایان Statement رسیده ایم. Variable فوق را به طور خلاصه به شکل زیر نوشته می شود:

1. String text = "In the name of God";

حال این Variable را در بعد از { مربوط به Method با نام main قرار می دهیم. حال کد شما می بایست به شکل زیر باشد:

1. class FirstProgram {
2.  
3. public static void main(String[] args) {
4. String text = "In the name of God";
5. }
6.  
7. }

این خط از کد یک Variable می باشد که هدف آن نمایش دادن جمله In the Name of God است. اما خط فوق صرفاً یک Variable است که مقداری را در خود جای داده است و برای به نمایش در آمدن نیاز به ساختاری دارد که آن را به Compiler بفرستد و نهایتاً به نمایش درآید که در بخش ذیل به توضیح نحوه اجرای این کار می پردازیم. در خط بعد یک Statement با محتوای System.out.println(); بنویسید. این خط از کد به کامپیوتر شما این دستور را می دهد که هر آنچه مابین دو پرانتز قرار دارد را به نمایش در آورد. پس در این مرحله نام Variable که در مرحله قبل ساخته بودیم را داخل پرانتز تایپ می کنیم(به خاطر داشته باشید که چنانچه نام Variable که text می باشد را با حرف بزرگ به صورت Text بنویسیم برنامه از ما خطا خواهد گرفت چرا که زبان برنامه نویسی جاوا یک زبان case-sensitive است). یکی از ویژگی های اکثر زبان های برنامه نویسی case-sensitive بودن آن ها است به این معنی که به بزرگ و کوچک بودن حروف حساس هستند. به عبارتی اگر شما کلمه System که با حرف بزرگ نوشته شده است را با حرف کوچک به صورت system بنویسید در حین اجرای برنامه با مشکل مواجه خواهید شد چرا که System جزو Keyword ها یا اصطلاحات درونی خود جاوا است که فقط و فقط به صورت System و نه system برای جاوا قابل فهم است(در ادامه آموزش ها با انواع Keyword ها بیشتر آشنا خواهیم شد). در این مرحله شما با موفقیت توانستید اولین برنامه کامل جاوای خود را بنویسید. کد های شما می بایست دقیقاً با کد ذیل مطابقت داشته باشد:

1. class FirstProgram {
2.  
3. public static void main(String[] args) {
4. String text = "In the name of God";
5. System.out.println(text);
6. }
7.  
8. }

پیش از اجرای برنامه ما نیاز داریم تا برنامه را Compile کرده و به عبارتی به دستوراتی تبدیل کنیم که برای کامپیوترمان قابل فهم باشند(صفر و یک). حال از منوی اصلی گزینه Run و مجدداً گزینه Run را انتخاب کرده، اولین برنامه شما پس از Compile شدن به صورت اتوماتیک توسط اکلیپس با موفقیت اجرا خواهد شد و در بخش Console نرم افزار اکلیپس که در قسمت پایین قرار دارد و با اجرای برنامه به صورت خودکار فعال خواهد شد مقداری را که به Variable از جنس String تحت عنوان text داده بودید را مشاهده خواهید کرد.

زمانیکه شما Value مرتبط با Variable خود تحت عنوان text را تغییر دهید و جمله دیگر را داخل “ ” بنویسید، Variable شما مقدار قبلی خود را کاملاً از دست داده و مقدار جدید را در خود ذخیره می سازد و بالطبع پس از اجرای برنامه در بخش Console مقدار جدید اختصاص داده شده به text نمایش داده می شود. در این قسمت از آموزش شما توانستید اولین برنامه جاوای خود را با موفقیت اجرا نمایید. آنچه در برنامه نویسی حائز اهمیت است تکرار و تمرین می باشد و اینکار منجر به نهادینه شدن مفاهیم زبان برنامه نویسی جاوا در ذهن برنامه نویسان تازه کار خواهد شد. در اولین آموزش برنامه نویسان مبتدی با تعدادی واژگان آشنا شدند که هر کدام از آن ها در زبان برنامه نویسی جاوا دارای معنی خاصی می باشند و چنانچه ما بخواهیم یک زبان برنامه نویسی مثل جاوا را به خوبی درک کنیم می بایست با Syntax آن زبان کاملاً آشنا باشیم. برای روشن تر شدن این مطلب زبان برنامه نویسی جاوا را با زبانی که به آن مکالمه می کنیم مقایسه می کنیم. در واقع زبان فارسی که ما به آن تکلم می کنیم از یک دستور زبان که در برگیرنده تعدادی قاعده و قانون است و همچین تعدادی واژه تشکیل شده است. حال این واژگان فارسی بر اساس قواعد خاصی می توانند در کنار یکدیگر قرار گیرند تا بتوانیم از آن طریق با یکدیگر ارتباط برقرار سازیم. در حقیقت زبان برنامه نویسی جاوا هم مثل زبان فارسی از یکسری قواعد، اسم و غیره تشکلیل شده است و برای آنکه بخش های مختلف یک برنامه جاوا بتوانند با یکدیگر ارتباط برقرار سازند، می بایست این اصول کاملاً مد نظر قرار داده شوند. در حقیقت در زبان برنامه نویسی جاوا اسامی در قالب ابزارهای API یا Application Programming Interface شناخته می شوند. کسانیکه زبان برنامه نویسی جاوا را طرح ریزی کردند اسامی خاصی را برای بخش های مختلف زبان جاوا در نظر گرفته و در این زبان برنامه نویسی گنجانده اند. به عنوان مثال از قواعد و قوانین جاوا می توان به قرار دادن ; در انتهای هر Statement اشاره کرد که در صورتیکه فراموش کنیم آن را بنویسیم گویی فراموش کرده ایم جمله ای که در یک نامه فارسی نوشته ایم را با قرار دادن یک نقطه به پایان برسانیم(شاید اگر در نوشتن یک نامه گاهی اوقات فراموش کنیم که نقطه گذاری کنیم و هیچ مشکلی هم پیش نیاید. اما در زبان برنامه نویسی جاوا قواعد گرامری خیلی سخت گیرانه تر بوده و چنانچه فراموش کنیم یک ; در انتهای یک Statement قرار دهیم برنامه ای که نوشته ایم اجرا نخواهد شد). قواعد زبان برنامه نویسی جاوا خیلی گسترده نیستند اما در عوض API یا همان آجرهای تشکیل دهنده این زبان برنامه نویسی که در برگیرنده واژگان زبان برنامه نویسی جاوا نیز می باشند خیلی گسترده هستند و بیش از 4000 عنوان را شامل می شود و با انتشار هر نسخه جدید جاوا تعدادی هم به این لیست گسترده اضافه خواهد شد. اما خبر امیدوار کننده این است که شما به عنوان یک برنامه نویس جاوا نیازی به حفظ کردن کلیه این ابزارها نبوده و با توجه به نیازی که از زبان جاوا دارید همان ابزارها را به کار خواهید گرفت که در طول زمان ملکه ذهن شما خواهد شد. واژگان API جاوا به سه دسته تقسیم می شود که عبارتند از: Keyword, Identifier, API Identifier در حقیقت Keyword به واژه ای در جاوا اطلاق می شود که همواره دارای معنای ثابتی است و هیچ فرقی هم نمی کند که در کجای برنامه مورد استفاده قرار گیرد. به طور مثال واژه میز در زبان فارسی همواره دارای معنای ثابتی است و هیچ فرقی هم نمی کند که توسط چه کسی مورد استفاده قرار گیرد. در زبان برنامه نویسی جاوا Boolean یک Keyword است و همواره داری معنای ثابتی است. از دیگر Keyword های جاوا می توان به if, else, char نیز اشاره کرد. در زبان جاوا Identifier به واژه ای اطلاق می شود که ما برای نامیدن چیزی در نظر می گیریم. در پروژه ساخت اولین برنامه جاوا، ما برای Variable خود نام text را در نظر گرفتیم. در واقع text یک واژه از نوع Identifier می باشد و این در حالی است که ما می توانستیم به جای واژه text از واژگان دیگری همچون sample, tester, myString, aliString نیز استفاده کنیم. چنانچه بخواهیم زبان برنامه نویسی جاوا را با زبان فارسی مقایسه کنیم، می توان گفت که واژگانی از قبیل اشکان، کیانا، احسان و غیره از نوع Identifier می باشند. حال نوبت به توضیح پیرامون API Identifier می رسد که امیدواریم با این توضیح مفهوم آن کاملاً روشن گردد. در زبان فارسی یکسری واژگان هستند که از نوع Identifier می باشند و به عبارتی یکسری نام هستند که به چیزی اطلاق می شوند اما این گروه از واژگان در طول زمان نهادینه شده و پس از مدتی صرفاً به یک چیز خاص اطلاق می شوند مثل مولوی که ابتداً یک واژه از نوع Identifier بوده اما پس از گذشت زمان به یک Identifier خاص تبدیل شده که فقط و فقط به شاعر بزرگ ایرانی اطلاق می شود. در زبان برنامه نویسی جاوا تعدادی واژه وجود دارند که اصطلاحاً به آن ها API Identifier گفته می شود. درست است که این گروه از واژگان یک واژه معمولی هستند ولی از آنجا که پایه ریزان زبان برنامه نویسی جاوا به کرات از آن ها استفاده کرده اند تبدیل به واژگانی شده اند که فقط و فقط به یک چیز خاص اشاره دارند و عملکردی همانند واژه مولوی دارند و این گروهی از این واژگان عبارتند از String, main, System, out, println یکی دیگر از مواردی که در جاوا خیلی مورد استفاده قرار می گیرد مفهوم Method است. در واقع Method به لیستی از کارهایی گفته می شود که قرار است به ترتیب خاص انجام شوند. در زبان برنامه نویسی جاوا هر Method دارای یک نام است که با آوردن نام متد در جایی از برنامه از جاوا می خواهیم که لیست کارهایی که درون متد برنامه ریزی شده اند را انجام دهد.

1. class FirstProgram {
2.  
3. public static void main(String[] args) {
4. String text = "In the name of God";
5. System.out.println(text);
6. }
7.  
8. }

کدهای فوق مربوط به مثال اولین پروژه جاوا است که طراحی کردیم. به منظور روشن تر شدن مطالب فوق الذکر، هر یک از اصطلاحات را از روی کد مشاهده خواهیم کرد. در این کد در خط اول یک Class با نام FirstProgram داریم و علامت { که پس از نام Class آمده و علامت } که در خط هشتم آمده است تشکیل دهنده یک block است که کل برنامه ما را در بر می گیرد. در خط سوم یک Method با نام main داریم که حاوی لیستی از دستورات می باشد. واژگانی مثل public, static, void را در بخش های آتی توضیح خواهیم داد. در واقع هر زمانیکه ما یک Method با نام main ایجاد کنیم، به Compiler این دستور را می دهیم که این بخش از کد بخشی است که برنامه را شروع می کند و در حین اجرا کامپیوتر به صورت خودکار برنامه نوشته شده توسط ما را از این بخش از برنامه به بعد اجرا می نماید. علامت { که پس از Method قرار گرفته و علامت } در خط ششم به منزله block دوم برنامه ماست. در این block ما یکسری دستورات مبنی بر نوشتن جمله In the Name of God روی مانیتور نوشته ایم که به ترتیب آن ها را مورد بررسی قرار خواهیم داد. در این Method ما یک Variable از جنس String تحت عنوان text داریم. در این Statement واژه String یک API Identifier است و واژه text یک Identifier می باشد. در خط پنجم ما یک Statement دیگر مشاهده می کنیم که حاوی واژگان System, out, println می باشد که همگی جزو API Identifier ها می باشند.

پایه و اساس تفکر OOP یا همان Object-oriented programming این بود که نگاه برنامه نویسان به برنامه نویسی به نگاه ایشان به دنیای ملموس و واقعی نزدیک تر گردد. به طور مثال کامپیوتری که شما با استفاده از آن به خواندن این مطالب آموزشی مشغول هستید یک Object یا شئی می باشد. حال این Object که در اختیار شما است با کامپیوتری که زیر دست بنده می باشد بسیار متفاوت است.

 

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

اما دیگر اشیاء در دنیای واقعی مثل یخچال دارای چنین Behavior نمی باشند. در واقع در برنامه نویسی شیئی گرایی، Object ها داری سه ویژگی می باشند: اول اینکه هر Object دارای یک Identity یا هویت خاص خود است(به طور مثال دو انسان که به منزله Object هستند را در نظر بگیرید. درست است که هر دو دارای یکسری خصایص مثل داشتن دست و پا و قدرت تفکر و غیره می باشند و در عین حال عملکردهای مشابهی نیز دارند مثل حرف زدن، دویدن و... اما دارای دو هویت مجزا می باشند مثلاً احسان و نیما.) ویژگی دوم مربوط به Attribute یا خصیصه می باشد. مثلاً قد احسان 185 سانتی متر است اما قد نیما 176 سانتی متر است. ویژگی سوم مربوط به Behavior شیئی است. مثلاً احسان می تواند به خوبی پیانو بنوازد اما نیما نقاش خوبی است.

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

همانطور که در مقدمه آموزش اشاره شد، Class همانند یک نقشه ساختمان است که از روی آن می توانیم هزاران هزار خانه بسازیم. در حقیقت ما در Class تعریف می کنیم که Object ما دارای چه Attribute و Behavior باشد. به عبارتی هر Object به منزله یک Instance یا نمونه ای از یک Class است. در برنامه نویسی به این کار اصطلاحاً Instantiation یا نمونه سازی گفته می شود.

ما در برنامه نویسی شیئ گرا برای ایجاد اشیاء اول نیاز به برخورداری از Class داریم اما نکته ای که این جا می بایست مد نظر قرار دهیم این است ما به عنوان برنامه نویس الزماً مجبور نیستیم که کلیه کلاس ها را خودمان بنویسیم چرا که بسیاری از کلاس ها از قبل در دل برنامه جای داده شده اند و ما به راحتی با وارد کردن Class مد نظر می توانیم از قابلیت های آن استفاده کنیم. اما چنانچه بخوایم Class خود را بنویسیم می بایست همواره چهار نکته را مد نظر داشته باشیم که در ذیل به آن ها اشاره خواهیم کرد:

در ایجاد یک کلاس جدید ما به عنوان برنامه نویس می بایست چهار مورد Abstraction, Polymorphism, Inheritance, Encapsulation را مد نظر قرار دهیم. به منظور به خاطر سپردن این چهار عنصر اصلی ساخت Class می توان حرف اول هر یک از چهار کلمه را گرفته و کلمه A PIE به معنی کلوچه را به خاطر سپرد. یک از ویژگی های OOP به کار گیری Abstraction است. در اینجا ترجمه این واژه را در قالب یک مثال عرض می کنیم.

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

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

در حقیقت در حین نوشتن Class ما به همین اکتفا کرده و به هیچ وجه در Class خود نام تک تک ورزشگاران را نخواهیم آورد. به طور خلاصه ما در ایجاد Class فقط و فقط یک مفهوم کلی را در نظر گرفته سپس Object هایی را به صورت Customized شده از روی آن Class ایجاد می کنیم.

تاکنون برای خیلی از ما پیش آمده که سرما خورده ایم. به پزشک مراجعه می کنیم و دارو دریافت می کنیم. ممکن است برخی دارو ها در قالب کپسول باشند. در حقیقت وظیفه کپسول نگهداری داروی داخل آن و محافظت از آن است. در برنامه نویسی شئی گرایی هم وظیفه Encapsulation نیز همین می باشد که Attribute ها و Behavior های موجود در یک Object را در کنار یک دیگر نگه دارد اما این در حالی است که موضوع به همین مسئله خلاصه نمی شود. در حقیقت وظیفه Encapsulation کمی فراتر از این هم هست. مفهوم Encapsulation این امکان را به ما می دهد تا از خصایص یک Object هر آنچه را که ما تمایل داریم نمایش داده شود، در معرض دید دیگر بخش های برنامه قرار گیرند و به عبارتی دیگر بخش های برنامه ما فقط به بخش هایی از یک Object دسترسی خواهند داشت که ما آن ها را پنهان نکرده ایم.

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

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

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

حال چنانچه ما تغییری در Superclass ایجاد کنیم، تغییر ایجاد شده در Class های سه خوابه و چهار خوابه نیز اعمال خواهد شد. نکته ای که در اینجا می بایست مد نظر قرار دهیم این است که در زبان برنامه نویسی جاوا ما فقط می توانیم از یک Class اصلی چیزی را به ارث ببریم.

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

در هر سه حالت این حس بویایی سگ است که فعالیت می کند و تنها تفاوت در نوع داده ای است که به حس بویایی سگ منتقل می شود. در زبان برنامه نویسی جاوا علامت + دقیقاً چنین ویژگی دارا است. چنانچه ما دو متغییر از جنس عددی را با علامت + جمع کنیم حاصل جمع آن دو عدد را به ما خواهد داد. مثلاً 7+5=12 اما اگر دو متغییر از جنس String یا کلمه را با یکدیگر جمع کنیم آن دو کلمه را در کنار یکدیگر قرار خواهند گرفت مثل Hello+World=HelloWorld

پس از صحبت پیرامون اصول برنامه نویسی شیئی گرایی، امیدواریم که مفهوم OOP را به خوبی درک کرده باشید. حال نوبت آشنایی با قسمت های مختلف تشکیل دهنده زبان برنامه نویسی جاوا می رشد که شامل Keywords, Identifiers, API Identifiers و غیره می شود. در آموزش بعدی با کلیه موارد فوق به طول مفصل آشنا خواهیم شد.

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

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

ادامه مطلب را از دست ندهید.

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

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

1. public class CompileTimeErrors {
2. /**
3. * @param args
4. */
5. public static void main(String[] args) {
6. // TODO Auto-generated method stub
7. }
8. }

حال می خواهیم جمله This is a Compile time error را روی صفحه مانیتور نمایش دهیم پس می بایست کد خود را به شکل زیر ویرایش نماییم (لازم به ذکر است که Comment های کد را که هیچ تاثیری در نحوه ی اجرای برنامه ما ندارند را حذف می کنیم. در بخش بعدی پیرامون انواع Comment ها به طور مفصل توضیح خواهیم داد):

1. public class CompileTimeErrors {
2. public static void main (String[] args) {
3. system.out.prinln("This is a compile time error");
4. }
5. }
6.  

در واقع کد فوق یک برنامه کامل و صحیح جاوا است که بدون هیچ مشکلی اجرا خواهد شد. در این جا ما قصد داریم تا عمداً تغییری در کد ایجاد کنیم تا Compiler از ما ایراد بگیرد. به همین منظور واژه out که می بایست حتماً با حروف کوچک نوشته شود را به صورت OUT می نویسیم. به محض اینکه ما واژه ی out را به OUT تغییر دهیم، با تصویر زیر مواجه خواهیم شد:

ما در تصویر فوق از روی دو مورد می توانیم متوجه شویم که برنامه ما دارای Error است. محیط برنامه نویسی اکلیپس دور واژه ی مشکل زا که در اینجا OUT است یک نقطه چین قرار داده است. از سوی دیگر در کنار نام فایل .java دو علامت ستاره مشاهده می شود که نشانگر ایرادی در برنامه است. حال با قرار دادن نشانگر موس خود روی واژه OUT اکلیپس پیامی را به ما نشان می دهد که به شکل زیر است:

این یکی از بخش های لذت بخش کار کردن با نرم افزار اکلیپس است. این محیط برنامه نویسی قدرتمند مشکل را پیدا کرده و در جهت رفع آن تعدادی پیشنهاد می دهد(در اینجا صرفاً یک پیشنهاد بیشتر به ما نمی دهد). چنانچه به خط آبی رنگ توجه کنیم، می بینیم که به ما پیشنهاد می شود که واژه OUT را به out تغییر دهیم که با این کار مشکل ما رفع خواهد شد. لازم به ذکر است که مثال فوق به منزله یکی از ساده ترین انواع Error ها در محیط برنامه نویسی جاوا است. در واقع یکسری از Error ها هستند که تا حدودی پیچیده تر هستند و اکلیپس برای رفع مشکل، بیش از یک مورد به ما پیشنهاد می دهد که در چنین حالتی کار ما به عنوان برنامه نویس این است که تک تک پیشنهادات را مورد بررسی قرار داده و سپس تغییر مورد نیاز را اعمال کنیم. نوع دیگر از Error ها تحت عنوان Unchecked Runtime Exception شناخته می شوند. در این صورت ما هیچ گونه Compile-time Error نداریم اما برنامه هم به طور کامل اجرا نمی شود. در واقع برنامه ای که ما نوشته ایم کاری را از جاوا می خواهد انجام دهد که جاوا از انجام آن ناتوان است. به طور مثال فرض کنیم که ما یک متغییر از جنس int داریم که Value اختصاص داده شده به آن 1,000,000 است. در حین نوشتن برنامه ما با هیچ گونه مشکلی مواجه نخواهیم شد اما به محض اینکه اقدام به Compile کردن برنامه می کنیم Error دریافت می کنیم. در مثال فوق اشکال کار در اینجا است که ما مابین ارقام یک کاما قرار داده ایم از این رو جاوا قادر به Compile کردن برنامه نخواهد بود. به منظور رفع این مشکل می بایست عدد فوق را به 1000000 تبدیل کنیم. در حقیقت نرم افزار اکلیپس از درک اینکه این مسئله می تواند در حین اجرا مشکل زا باشد عاجز است. برای روشن تر شدن این مسئله مثالی از دنیای واقعی می زنیم. فرض کنیم که شما از شخصی آدرس می پرسید. آن شخص به شما می گوید که مستقیم بروید تا به یک چهار راه برسید سپس به سمت راست بروید و رو به روی شما یک سینما قرار دارد. حال شما همانطور که آن شخص گفت مسیر را طی می کنید. مستقیم می روید. به چهار راه که رسیدید به سمت راست می روید. به رو به رو که نگاه می کنید به جای یک سینما یک دیوار سیمانی رو به روی شما قرار دارد. به عبارت دیگر شما از اول نمی دانستید که آدرسی که به شما داده شده است اشتباه است. زمانیکه اینگونه Error ها اتفاق می افتند نیز همین طور است. از بدو امر جاوا نمی داند که در حین اجرای برنامه در وسط کار مشکلی قرار است اتفاق افتد از همین رو نمی تواند پیش بینی کند که برنامه در حین Compile با مشکل مواجه خواهد شد. دسته دیگری از Errorها از نوع Logical یا منطقی هستند. در چنین مواقعی نرم افزار اکلیپس هیچ گونه خطایی را نشان نخواهد داد و برنامه هم به طور کامل اجرا خواهد شد اما پاسخی که نرم افزار قرار بود به ما بدهد صحیح نیست. فرض کنیم در مثال فوق شخصی که به ما آدرس می دهد به جای اینکه به ما بگوید به سمت راست برویم بگوید که به سمت چپ برویم. این دسته از Error ها به منزله چالش بر انگیزترین Error ها می باشند به طوری که رفع کردن آن ها هم ممکن است با دشواری زیادی همراه باشد(شاید مجبور باشید هفته ها وقت صرف کنید تا مشکل را بیابید). نکته ای که بایستی مد نظر قرار داده شود این است که خیلی از این دسته از Error ها خیلی اوقات اصلاً مورد توجه قرار نمی گیرند و در آینده مشکلات زیادی را برای ما به بار خواهند آورد. دسته آخر Error ها که بهتر است نام آن ها را Error نگذاریم بلکه Warning یا هشدار بنامیم تحت عنوان Compile-time Warning شناخته می شوند. به طور کلی این دسته از هشدار ها به مهمی Error ها نمی باشند. در واقع زمانیکه محیط برنامه نویسی اکلیپس شاهد مسئله مشکوکی باشد، یک آیکون زرد رنگ با علامت تعجب مقابل خطی که به آن مشکوک است نمایش می دهد. به مثال زیر توجه فرمایید:

در مثال فوق، ما یک متغییر از جنس int ایجاد کرده ایم که نام آن test است و یک Value به میزان 100 برای آن در نظر گرفته شده است. در مقابل خطی که متغییر در آن قرار دارد یک علامت زرد رنگ با یک علامت تعجب قرار دارد. به عبارت دیگر این یک هشدار از طرف نرم افزار اکلیپس است که می خواهد به ما بگوید که این متغییر در هیچ کجای برنامه مورد استفاده قرار نگرفته است و دیگر اینکه آیا مطمئن هستید که می خواهید این متغییر را در کد خود نگه دارید. در واقع هر موقع که ما با چنین هشدار هایی مواجه شویم می توانیم نشانگر موس خود را روی آن علامت زرد رنگ نگه داشته و پیشنهادی را که اکلیپس به ما می دهد را مطالعه کنیم. به تصویر زیر توجه فرمایید:

نوشته ای که در قسمت زرد رنگ دیده می شود حاکی از آن است که Value متغییری تحت عنوان test در هیچ کجای برنامه مورد استفاده قرار نگرفته است. به طور کلی مشکلات برنامه نویسی اصطلاحاً Bug نامیده می شوند و فرایند مشکل یابی و رفع آن اصطلاحاً Debugging گفته می شوند که تسلط به Debugging خیلی می تواند ما را در برنامه نویسی کمک کند. اضافه کردن Comment به کدهای خود در حین برنامه نویسی، به طرز چشمگیری می تواند ما را در برنامه نویسی کمک کند. در حقیقت برنامه نویسان با اینکار راه را برای ویرایش کد خود در آینده آسان می کنند. همانطور که قبلاً هم اشاره شد در زبان برنامه نویسی جاوا سه مدل Comment وجود دارد که عملکرد هر کدام از آن ها را مورد بررسی قرار خواهیم داد.

1. class FirstProgram {
2. /*
3. * This is a multi-line comment for you!
4. */
5. public static void main(String[] args) {
6. String text = "In the name of God";
7. System.out.println(text);
8. }
9. }

 نوع اول از Comment ها چند خطی می باشند. به عبارت دیگر چنانچه ما بخواهیم چند خط از کد خود را از دید Complier پنهان سازیم در خط اول علامت /* و در خط آخر علامت */ را قرار می دهیم و هر آنچه که فی مابین قرار گیرد جزو Comment حساب خواهد شد. نکته ای که در مورد این نوع از Comment ها می بایست به خاطر داشته باشیم این است که ما به عنوان برنامه نویس جاوا نمی توانیم یک Comment چند خطی را درون یک Comment چند خطی دیگر قرار دهیم چرا که با اینکار در حین اجرای برنامه با مشکل مواجه خواهیم شد. نوع دوم از Comment ها به Comment های پایان خط معروف هستند. در واقع چنانچه در انتهای خطی که کدی را در آن نوشته ایم بخواهیم جهت یادآوری خود چیزی یادداشت کنیم از این Comment با قرار دادن علامت // استفاده خواهیم کرد. مثالی از این Comment را در کد زیر مشاهده خواهید کرد:

1. class FirstProgram {
2. public static void main(String[] args) { // This is the
3. main method
4. String text = "In the name of God";
5. System.out.println(text);
6. }
7. }

 آنچه در مورد این نوع از Comment ها بسیار جالب توجه است این است که چنانچه بخشی از برنامه شما دچار مشکل باشد و شما به اصطلاح بخواهید برنامه را Debug کنید می توانید از این Comment استفاده کنید به این صورت که نشانگر موس خود را روی بخشی از کد که تصور می کنید مشکل زا است قرار داده، سپس دکمه کنترل را با علامت / فشار دهید. خواهید دید که آن بخش از کد شما Comment شده و به رنگ متفاوتی در خواهد آمد. حال می توانید برنامه را Compile کنید و ببینید که آیا مشکل رفع شده است یا خیر. چنانچه مشکل رفع شده بود متوجه خواهید شد که آن بخشی از کد که Comment شده است دارای مشکل است پس نیاز است که آن را رفع نمایید. چنانچه رفع نشده بود مجدداً با انتخاب آن بخش از کد دکمه کنترل و علامت / را فشار دهید تا از حالت Comment درآید و این کار را تا زمانی می توانید انجام دهید که مشکل برنامه خود را پیدا نمایید(اگر چه نام این Comment ها تحت عنوان Comment های پایان خط معروف است، اما ما می توانیم آن ها را در ابتدای یک خط از کد نیز مورد استفاده قرار دهیم). نوع سوم از Comment ها از نوع javadoc می باشند به این معنی که با قرار دادن علامت /** در ابتدای خطی که تمایل داریم به Comment تبدیل شود و قرار دادن علامت */ در انتهای خطی Comment ما به پایان می رسد، ما توضیحاتی را در داخل کد خود درج می کنیم که برای دیگران که می خواهند کد ما مطالعه کنند ولی دانش زبان جاوا ندارند بسیار مفید خواهد بود به این صورت که از کلیه Comment های برنامه خود که از نوع javadoc هستند خروجی HTML می گیریم و کلیه Comment ها به صورت یک صفحه وب در اختیار علاقمندان قرار می گیرد (نحوه ایجاد javadoc برای برنامه نویسان مبتدی ضروری نیست بنابراین از توضیح در این باره خودداری می شود).

1. class FirstProgram {
2. /**
3. * This is a javadoc comment for you!
4. */
5. public static void main(String[] args) {
6. String text = "In the name of God";
7. System.out.println(text);
8. }
9. }

در این آموزش با انواع Error ها و همچنین با نحوه صحیح Comment کردن بخشی از کد خود آشنا شدیم. در آموزش بعدی با انواع متغییر های در زبان برنامه نویسی جاوا و نحوه اختصاص یک Value یا مقدار به آن ها و غیره آشنا خواهیم شد.

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

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


حال اگر یک Statement حاوی محاسبات ریاضیاتی باشد و بالتبع نتیجه ای را در بر داشته باشد به آن Expression می گوییم(اگر توجه کرده باشید تا حد ممکن از ترجمه اینگونه اصطلاحات خودداری می کنیم چرا که به طور مثال دانستن معادل فارسی واژه ای مثل Statement به معنی عبارت کمکی به تقویت مهارت ما در برنامه نویسی نخواهد کرد.)

ما برای اینکه بتوانیم در زبان برنامه نویسی جاوا از متغییر ها استفاده کنیم می بایست سه نکته را همواره مد نظر داشته باشیم: هر Variable یا متغییر شامل نوع متغییر، نام و مقدار متغییر می باشد. در واقع اگر متغییر ما هر یک از این سه مورد را نداشه باشد ما یک متغییر ناقص ایجاد کرده ایم. نام هر متغییر واژه ای از جنس Identifier می باشد(برای آشنایی با واژگان زبان برنامه نویسی جاوا به جلسه دوم آموزش مراجعه فرمایید). برای درک بهتر مفهوم متغییرها، در این جلسه یک برنامه جدید تحت عنوان Fifth Session خواهیم ساخت. همانطور که در جلسه اول آموزش داده شد، یک برنامه جدید جاوا ایجاد کنید و نام آن را Fifth Session بگذارید. حال یک فایل Class داخل آن ایجاد کرده و نام آن را Variable بگذارید(لازم به ذکر است این اسامی دلخواه هستند فقط نکته ای که لازم است مد نظر قرار داده شود این است که حرف اول نام Class به صورت بزرگ نوشته شود).

در واقع ما برای وارد کردن اطلاعاتی از جنس اعداد صحیح داخل برنامه خود می توانیم از یک متغییر از جنس int استفاده کنیم(لازم به ذکر است برای این نوع داده انواع دیگری هم از متغییر ها وجود دارند که عبارتند ازbyte, short, long ). همچنین برای ذخیره سازی اطلاعاتی از جنس اعداد اعشاری از یک متغییر از جنس double استفاده خواهیم کرد (لطفا به حروف بزرگ و کوچک واژگان int و double توجه فرمایید چرا که قبلاً هم گفته شد که زبان برنامه نویسی جاوا case-sensitive است یا به عبارت دیگر به حروف بزرگ و کوچک حساس می باشد). علاوه بر متغییر double ما از متغییر float هم می توانیم استفاده کنیم با این تفاوت که دقت متغییر double به مراتب بیشتر است. (لازم به ذکر است در این سری از آموزش ها برای اعداد صحیح و اعشاری به ترتیب از متغییر های int و double استفاده خواهیم کرد).

نکته ای که در مورد متغییرها می بایست مد نظر قرار داد این است که ما برای جلوگیری از طولانی شدن کد خود می توانیم متغییرها را با یکدیگر ادغام نماییم. اما در حین ادغام متغییر ها بایستی توجه داشته باشیم که نوع متغییرهایی که می خواهیم با یکدیگر ادغام کنیم می بایست از یک جنس باشد. به طور مثال نمی توانیم یک متغییر از جنس int و یک متغییر از جنس double را با یکدیگر ادغام کنیم. به مثال زیر توجه کنید:

1. int apple= 8, banana = 10, orange= 12;

در مثال فوق ما سه متغییر از جنس int خواهیم داشت که مقادیر آن ها هم مشخص شده است. چنانچه توجه کرده باشید در مثال فوق متغییر ها بوسیله کاما از یکدیگر جدا شده اند و پس از آخرین متغییر یک علامت ; قرار گرفته است. حال زمان هایی در برنامه نویسی پیش خواهد آمد که ما نیاز داریم تا مقادیری از جنس حرف یا کاراکتر را در یک متغییر ذخیره سازیم. برای این منظور می توانیم از متغییر char استفاده کنیم. به منظور وارد کردن صرفاً یک کاراکتر یا یکسری از علائم خاص در برنامه خود ما می بایست از متغییر char استفاده کنیم. نکته ای که اینجا می بایست حتماً مد نظر قرار داده شود این است که مقدار مد نظر برای این نوع متغییر حتماً می بایست داخل علامت های ' ' قرار گیرد (توجه داشته باشیم که برای نوشتن یک کلمه که حاوی بیش از یک کاراکتر باشد به هیچ وجه نمی توان از متغییر char استفاده کنیم). پس از آشنایی با تعدادی از پرکاربرد ترین متغییر ها در زبان جاوا، این نکته را هم می بایست مد نظر داشته باشیم که برای اختصاص دادن یک Value یا مقدار به هر متغییری ما نیاز داریم تا از علامت = پس از نام متغییر و قرار دادن علامت ; در انتهای Statement استفاده کنیم. گاهی اوقات در برنامه نویسی برای اندروید و یا Desktop Application ما با شرایطی من جمله آیا کاربر رمز خود را صحیح وارد کرده است؟ آیا کاربر دکمه را فشار داده است؟ و ... رو به رو خواهیم شد. در واقع در چنین شرایطی ما به برنامه خود می گوییم که آری رمز صحیح وارد شده و یا آری کاربر دکمه Enter را فشار داده است. در چنین شرایطی متغییری نیاز داریم تا true و یا false بودن و به عبارتی درست یا اشتباه بودن یک رویداد را برای ما مشخص کند. متغییری از جنس boolean دقیقاً این کار را برای ما انجام خواهد داد(نکته ای که در اینجا می بایست مد نظر قرار داده شود این است که گرچه مقادیر این نوع متغییر true و یا false هستند، اما ما این اجازه را نداریم تا همانند متغییر های char و String آن ها را داخل علامت های ' ' و یا " " قرار دهیم.) یکی از بخش هایی که می تواند در برنامه نویسی به ما کمک کند، نحوه نام گذاری Class ها، Method ها و Variable ها است. در این بخش راه کارهایی ارائه خواهد شد که در نام گذاری متغییر ها می تواند اثر بخش باشد. هر متغییر نیاز دارد که یک نام داشته باشد. حال این نام می بایست با یک حرف کوچک شروع شود. نام که ما برای متغییر های خود انتخاب می کنیم بایستی مرتبط با اطلاعاتی که قرار است در متغییر ما ذخیره شود باشد. به طور مثال اگر قرار است که ما یک متغییری از جنس int ایجاد کنیم که اطلاعات مربوط به تعداد مسافرین یک هتل را در خود ذخیره سازد نوشتن یک Statement مثل int people = 300; اصلاً کار درستی نیست. درست است که Compiler به هیچ وجه از ما ایرادی نمی گیرد، اما این در حالی است که نام people که ما برای متغییر خود انتخاب کرده ایم توصیف کننده ماهیت متغییر نمی باشد. در عوض نوشتن این Statement به صورت int guestNumber = 300; به مراتب بهتر است چرا که این نام نشان دهنده اطلاعاتی است که قرار است در برنامه خود ذخیره سازیم. در نام گذاری اگر نامی که برای متغییر خود انتخاب می کنیم بیش از یک کلمه باشد ما اجازه نداریم که از فاصله استفاده کنیم بلکه واژگان باید به یکدیگر چسبیده باشند. حال اگر کلیه واژگان به یکدیگر چسبیده باشد خواندن آن ها به مراتب دشوار تر از حالت معمولی خواهد بود. برای این منظور از واژه اول به بعد حرف اول کلیه واژگان را به صورت بزرگ می نویسیم که این کار خواندن نام متغییر ها را به مراتب آسان تر خواهد ساخت. به طور مثال به جای نوشتن guestnumber می نویسیم guestNumber . نکته دیگری که در نام گذاری متغییر ها می بایست مد نظر قرار داده شود این است که ما اجازه نداریم از علائم punctuation مثل – و . و , در نام گذاری استفاده کنیم. حال برای روشن شدن مطالب کلیه متغییر ها را در قالب یک مثال به صورت زیر نمایش می دهیم:

1. class Variable {
2. int appleNumber = 100;
3. double moneyAmount = 22.3;
4. char letterName = 'A';
5. Boolean myBoolean = true;
6. }

در کد فوق مشاهده می کنیم که ما یک متغییر از جنس int داریم که برای ذخیره سازی اعداد صحیح مورد استفاده قرار می گیرد. نام این متغییر appleNumber است به معنی تعداد سیب و مقدار آن 100 است. توجه داشته باشیم که مقداری که برای این متغییر در نظر گرفته شده است پس از علامت مساوی قرار گرفته و در انتهای این Statement یک علامت ; قرار گرفته است که به معنای پایان Statement می باشد(همانطور که در نامه نگاری با گذاشتن نقطه جمله خود را به پایان می رسانیم در به پایان رساندن یک Statement هم در زبان برنامه نویسی جاوا ما از علامت ; استفاده می کنیم). متغییر دوم از جنس double است به عبارتی می تواند اعداد اعشاری را در خود جای دهد. نامی که برای این متغییر در نظر گرفته شده است moneyAmount به معنای مقدار پول است و Value اختصاص داده شده به آن هم 22.3 است. متغییر سومی که ما در برنامه خود استفاده خواهیم کرد از جنس char است و به عبارت دیگر ما فقط و فقط می توانیم یک حرف یا علامت را در آن جای دهیم. نام این متغییر letterName یا نام حرف است و مقدار آن حرف A است که داخل دو علامت ' ' قرار گرفته است. در نهایت یک متغییر از جنس boolean ایجاد می کنیم که نام آن myBoolean است(خیلی تلاش کردم یک نام معنی دار پیدا کنم متاسفانه چیزی به ذهنم نرسید. برنامه نویسان عزیز می توانند هر نامی که برای ایشان ملموس تر است را انتخاب نمایند). مقداری که برای این متغییر انتخاب می کنیم true است. به عبارت دیگر هر کجای برنامه که ما نام این متغییر را فرا بخواهیم، این هشدار را به برنامه خود می دهیم که این متغییر true است. به خاطر داشته باشیم که برخلاف متغییر های char و String متغییر boolean مقدار خود را داخل علامت های ' ' و " " قرار نمی دهد. به طور خلاصه در زبان برنامه نویسی جاوا هشت نوع متغییر اولیه Primitive Type وجود دارد که عبارتند از byte, short, int, long, float, double, char, boolean که از میان این هشت نوع متغییر، متغییرهای int, double, char, boolean از اهمیت بیشتری برخوردار می باشند. پس از آشنایی با متغییر های Primitive Type نوب به فراگیری اصول به کار گیری String ها در زبان برنامه نویسی جاوا به منظور به نمایش درآوردن تعدادی کاراکتر پشت سر هم یا به عبارت دیگر به نمایش درآوردن یک جمله روی مانیتور می رسد که در آموزش آتی به طور مفصل مورد بررسی قرار خواهد گرفت.

اگر به خاطر داشته باشید در اولین برنامه جاوا که طراحی کردیم عبارت In the Name of God را در یک String ذخیره ساخته سپس آن را نمایش دادیم.
عناصر تشکیل دهنده String ها کاراکترها، اعداد و علائم می باشند که با کنار یکدیگر قرار گرفتن یک جمله را تشکیل می دهند. چنانچه بخواهیم جمله ای را در برنامه خود داشته باشیم، یکی از دو گزینه ای که این کار را برای ما انجام خواهد داد کلاسی از جنس String است (توجه داشته باشید که این متغییر بر خلاف دیگر متغییر ها با حرف بزرگ شروع می شود). در حقیقت این Class در API زبان برنامه نویسی جاوا ایجاد شده است و ما فقط آن را فرا می خوانیم. از سوی دیگر کلاس String از جنس Reference Type است. به عبارت دیگر چنانچه ما متغییری داشته باشیم که جنس آن یک از هشت نوع Primitive Type نباشد، ما متغییری از جنس یک Class خواهیم داشت که نوع آن Reference Type می باشد. برای روشن تر شدن این مطلب می توانیم فرض کنیم که String یک Class است و نامی که ما برای آن در نظر می گیریم نام آن Class است. به مثال زیر در ادامه مطلب توجه فرمایید:

1. String myString = "My Name Is Behzad";

واژه String به یک Class اشاره می کند که قبلاً توسط تیم طراحان زبان برنامه نویسی جاوا در Java API طراحی شده است. واژه myString به منزله یک Instance یا نمونه ای از کلاس String است. در واقع myString یک Object یا شیئ است (در صورت درک ناقص این مسئله، به مفاهیم شئی گرایی در آموزش های پیشین مراجعه فرمایید). حال مقدار این String را جمله My Name Is Behzad در نظر می گیریم که داخل دو علامت " " قرار می گیرد (لازم به ذکر است که علامت های " " در حین اجرا نمایش داده نخواهند شد). یکی از ابتدایی ترین راه کارهای نمایش دادن جمله ای در محیط جاوا، به کار گیری فرمان زیر است که قبلاً با عناصر تشکیل دهنده آن آشنا شده ایم:

1. System.out.println();

هم اکنون برای به نمایش در آوردن مقدار String خود تحت عنوان myString می بایست کدی به این شکل داشته باشیم:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. String myString = "My Name Is Behzad";
5. System.out.println(myString);
6.  
7. }
8. }

در این مرحله با اجرای فرمان Run جمله داخل " " در بخش Console نرم افزار اکلیپس به نمایش در خواهد آمد (چنانچه بخواهیم از طولانی شدن کد خود جلوگیری به عمل آوریم، به جای تعریف کردن یک Class از جنس String و اختصاص دادن یک Value به آن و سپس فرا خواندن String در System.out.println(); به راحتی می توانیم جمله مد نظر خود را داخل پرانتز مقابل println بنویسیم). به عبارت دیگر کد فوق را به شکل زیر هم می توانیم داشته باشیم:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.println("My Name Is Behzad");
5.  
6. }
7. }

در حقیقت خروجی هر دو کد یک چیز خواهد بود (با استفاده از این دو روش ما می توانیم جمله ای را در زبان جاوا به نمایش در آوریم). دانستن نکته ای که در این جا حائز اهمیت است این است که ما می توانیم چندین Statement از این نوع را پشت سر هم داشته باشیم. برای روشن تر شدن این مطلب به مثال زیر توجه کنید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.println("My Name Is Behzad");
5. System.out.println("My Last Name is Moradi");
6.  
7. }
8. }

در این مثال ما هر دو جمله داخل " " را در بخش Console نرم افزار اکلیپس در دو خط جداگانه خواهیم دید.

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

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.print("My Name Is Behzad ");
5. System.out.print("My Last Name is Moradi");
6.  
7. }
8. }
9.  

خروجی این کد به شکل زیر خواهد بود:

در حقیقت از آن جا که ما دستور صادر کرده ایم که هر دو Statement یکی پس از دیگری در یک خط قرار گیرند، Console یک خط بیشتر نمایش نخواهد داد. همانطور که قبلاً اشاره شد علامت های " " در Console مشاهده نخواهند شد. اما زمان هایی برای ما پیش می آید که نیاز داریم کلمه ای را داخل " " قرار دهیم. برای این منظور می توانیم از ترکیب علامت های \" استفاده کنیم. به مثال زیر توجه کنید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.print("I like the \"Java\" Programming Language");
5.  
6. }
7. }

خروجی این کد به شکل زیر خواهد بود:

با این کار واژه Java داخل علامت " " قرار می گیرد. با استفاده از این تکنیک می توانیم برای قرار دادن یک Tab بعد از کلمه ای از \t و همچنین فرستادن بخشی از جمله به خط بعد از \n نیز استفاده کنیم. به عنوان مثال اگر بخواهیم دو کلمه Programming Language را به خط بعد ارسال کنیم، از دستور زیر استفاده خواهیم کرد:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.print("I like the \"Java\" \nProgramming Language.");
5.  
6. }
7. }

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

مفهوم Concatenation در زبان برنامه نویسی جاوا به زمانی اطلاق می گردد که ما دو چیز را به یکدیگر مرتبط می سازیم. به طور مثال زمان هایی در حین استفاده از دستورات فوق پیش می آید که ما نیاز داریم تا یک عبارت بسیار طولانی را در Console به نمایش در آوریم که در این صورت می بایست از علامت + که یک Operator است استفاده کنیم (در آموزش های آتی به طور مفصل پیرامون Operator ها صحبت خواهد شد). برای روشن شدن این مطلب به مثال زیر توجه نمایید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. System.out.print("I like the \"Java\" Programming Language."
5. + "This language is used to create android apps.");
6.  
7. }
8. }

در مثال فوق مشاده می شود که دو گروه از کلماتی که در کنار یکدیگر داخل " " قرار گرفته با استفاده از علامت + دنبال هم قرار گرفته اند(لازم به ذکر است علامت + در مورد متغییرهایی همچون int که دارای داده ای از جنس عددی هستند منجر به جمع شدن مقادیر آن متغییرهای می شود اما در مورد string ها به این شکل است که آن ها را در کنار یکدیگر قرار می دهد.) گاهی اوقات ما نیاز داریم تا متنی از جنس string را در کنار دیگر متغییرها مثلاً متغییری از جنس int یا double در محیط Console به نمایش در آوریم. به مثال زیر توجه نمایید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. int studentNumber = 12;
5. int teacherNumber = 3;
6. System.out.println("The number of students is " + studentNumber);
7. System.out.println("The number of teachers is " + teacherNumber);
8.  
9. }
10. }

در مثال فوق ما دو متغییر از جنس int تحت عناوین studentNumber و teacherNumber داریم که به ترتیب دارای مقادر 12 و 3 هستند. حال می خواهیم تا متغییری از جنس int را با یک string یا به عبارت دیگر جمله ای ترکیب کنیم. برای این منظور پس از علامت " یک علامت + قرار داده سپس نام متغییر خود را قرار می دهیم. در حین Compile شدن، پس از به نمایش در آوردن string در محیط Console حال علامت + مقدار عددی متغییر int را به متن اضافه می کند. در واقع خروجی برنامه به این شکل خواهد بود:

در آموزش آینده با مباحث تکمیلی String ها همچون نحوه مقایسه دو String با یکدیگر، شمردن تعداد کاراکترهای یک String و همچین تغییر حروف بزرگ به کوچک و بالعکس بحث خواهیم کرد.

در این جلسه پیش از تکمیل مبحث String ها در زبان برنامه نویسی جاوا می خواهیم یکی از خصوصیات کلیدی محیط برنامه نویسی اکلیپس را مورد بررسی قرار دهیم. این خصیصه نام های مختلفی همچون Auto Complete, Code Assist, Code Completion, Content Assist دارد. به طور خلاصه اگر بخواهیم در حین کدنویسی از خود محیط برنامه نویسی اکلیپس کمک بگیریم می توانیم از ترکیب کلید های Ctrl و Space استفاده کنیم. با این کار زمانیکه ما در حین نوشتن چیزی مثلاً نام یک متغییر که قبلاً ایجاد کرده ایم هستیم، با هم زمان زدن کلید هایی که در بالا گفته شد از محیط برنامه نویسی اکلیپس می خواهیم تا کد را برای ما تکیمل کند. برای روشن شدن مطلب به مثال ادامه مطلب توجه کنید:

1. public class Test {
2. public static void main(String[] args) {
3. String myFistName;
4. }
5. }

ما یک String تحت عنوان myFirstName ایجاد کرده ایم که فاقد هرگونه Value یا مقدار است. حال در خط بعد می خواهیم که مقداری برای آن درج کنیم. از این رو شروع به نوشتن نام String خود می کنیم به این صورت که می نویسیم my . حال در این مرحله اصلاً نیازی نیست که کل نام را به صورت دستی وارد کنیم بلکه می توانیم پس از نوشتن دو کاراکتر my کلید های Ctrl و Space را به صورت هم زمان فشار دهیم که در این صورت نام myFirstName به صورت خودکار نوشته می شود. از مزایای استفاده از این ویژگی محیط برنامه نویسی اکلیپس می توان گفت که نه تنها زمان کد نویسی را کاهش داده بلکه میزان خطاهای تایپی نیز به حداقل می رساند. در واقع این ویژگی اکلیپس صرفاً برای تکمیل کردن نام ها و ... نیست بلکه جایی که این قابلیت خیلی زیاد به برنامه نویسان کمک می کند برای تکمیل کد است. در حقیقت از آنجا که قسمت های تشکیل دهنده API زبان برنامه نویسی جاوا بسیار گسترده است(بیش از 4000 مورد)، به سادگی می توان از این ویژگی برای تکمیل کد خود استفاده کنیم به این صورت که صرفاً نیاز است ابتدای نام Method و یا Class مد نظر و یا هر چیزی را به خاطر داشته باشیم و با زدن کلید های Ctrl و Space محیط برنامه نویسی اکلیپس پیشنهادات خود را برای تکمیل کد به ما می دهد و ما به سادگی می توانیم از میان پیشنهادات ارائه شده گزینه مد نظر خود را انتخاب کنیم. حال که با این ویژگی ارزشمند اکلیپس آشنا شدیم می توانیم به مبحث تکمیلی String ها در زبان برنامه نویسی جاوا بپردازیم. در واقع زمان هایی برای برنامه نویسان جاوا پیش می آید که نیاز دارند تا کلاسی از جنس String را با یکدیگر مقایسه کنند که در این صورت از Method خاصی تحت عنوان equal استفاده می کنند. در واقع در زبان برنامه نویسی جاوا Method راهی برای به انجام رساندن کاری است و کاری که در اینجا مد نظر ما است این است که ببینیم آیا مقدار دو کلاس از جنس String یکی است یا خیر. برای روشن تر شدن مطلب به مثال زیر توجه کنید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. String name = "Behzad";
5. String lastName = "Moradi";
6. System.out.println("My first name is " + name);
7. System.out.println("Is my last name Behzad: "
8. +lastName.equals(name));
9.  
10. }
11. }

در اینجا ما دو کلاس از جنس String داریم که دارای مقادیر Behzad و Moradi هستند. حال در اولین System.out.println(); ما نیاز داریم تا جمله My name is Behzad به نمایش در آید، برای همین منظور با قرار دادن علامت + و نام String که در برگیرنده مقدار “Behzad” است به راحتی این جمله را در بخش Console به نمایش در می آوریم. در مرحله بعدی ما می خواهیم تا مقدار دو String را با یکدیگر مقایسه کنیم. برای این منظور نام String که می خواهیم با String دیگر مقایسه شود را نوشته سپس یک Method تحت عنوان .equals() به آن اضافه کرده و داخل پرانتز این Method نام String یی را می نویسیم که می خواهیم String قبلی را با آن مقایسه کنیم. به طور خلاصه به صورت lastName.equals(name) می نویسیم. حال چنانچه برنامه را اجرا کنیم، خروجی زیر را مشاهده خواهیم کرد:

در واقع خروجی Method ما چیزی از جنس boolean خواهد بود که مقدار آن یا true است و یا false و در اینجا از آن رو که مقادیر متغیرهای ما با یکدیگر متفاوت هستند مقدار false به نمایش در خواهد آمد. حال اگر بخواهیم جواب true شود به راحتی می توانیم مقدار متغییر lastName را همانند مقدار متغییر name کنیم و مشاهده می کنیم که جواب true خواهد بود. در واقع کد ما به شکل زیر تغییر پیدا خواهد کرد:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. String name = "Behzad";
5. String lastName = "Behzad";
6. System.out.println("My first name is " + name);
7. System.out.println("Is my last name Behzad: "
8. +lastName.equals(name));
9.  
10. }
11. }

و در نهایت خروجی برنامه ما پس از اجرا به شکل زیر خواهد بود:

گاهی اوقات برای ما در برنامه نویسی پیش می آید که نیاز داریم تا تعداد کاراکتر های یک String را بشماریم که برای این منظور می توانیم از Method یی تحت عنوان .lenght() استفاده کنیم. برای روشن شدن مطلب به مثال زیر توجه کنید:

1. public class Test {
2.  
3. public static void main(String[] args) {
4. String sentence = "This is a short sentence.";
5.  
6. System.out.println(sentence);
7. System.out.println("The number of its characters equals to "
8. + sentence.length());
9.  
10. }
11. }

در مثال فوق ما یک کلاس از جنس String داریم که نام آن sentence است و مقدار آن جمله This is a short sentence. می باشد. حال در Statement اول ما متغییر خود را به نمایش در می آوریم اما در Statement دوم جمله The number of its characters equals to را به علاوه Method یی می کنیم که تعداد کاراکتر های String ما را بشمارد. برای همین منظور نام String خود را نوشته و نام Method خود که در اینجا .lenght() است که قرار است تعداد کاراکتر ها را بشمارد ضمیمه آن می کنیم.( توجه داشته باشیم که این Method حتی جاهای خالی، نقطه، کاما و غیره را نیز در String می شمارد.) خروجی برنامه به شکل زیر خواهد بود:

اگر توجه کرده باشید تعداد کاراکتر های جمله ما 20 عدد است اما خروجی برنامه عدد 25 را به نمایش در می آورد و این از آنجا ناشی می شود که Method یی که استفاده کردیم نقطه و فضاهای خالی را نیز شمرده است. گاهی اوقات ما نیاز داریم تا کاراکتر های یک String را به حروف بزرگ و یا کوچک تبدیل کنیم. از این رو می توانیم از Method های toUpperCase. و .toLowerCase به ترتیب برای بزرگ کردن و کوچک کردن حروف استفاده کنیم. در حقیقت یکی از کاربردهای این Method این است که گاهی اوقات ما نیاز داریم تا کلیه ورودی ها را به صورت حروف بزرگ و یا حروف کوچک ذخیره سازیم. برای این منظور از این Method استفاده می کنیم تا این کار به صورت خودکار انجام شود. (در آموزش های آتی بیشتر از این Method استفاده خواهی کرد). حال فرض کنیم مقدار متغییر name که در مثال های قبلی استفاده کردیم معادل با EhSan AzimI باشد و ما نیاز داریم تا بی دقتی صورت گرفته در حین وارد کردن این متغییر را جبران کنیم. برای این منظور به صورت زیر عمل می کنیم:

1. public class Test {
2. public static void main(String[] args) {
3. String name = "EhSan AzimI";
4. System.out.println(name.toLowerCase());
5. }
6. }
7.  

در حقیقت با نوشتن نام متغییر و ضمیمه کردن Method یی تحت عنوان .toLowerCase کلیه حروف متغییر را به حروف کوچک تبدیل می کنیم.

عکس این قضیه هم صادق است. به عبارت دیگر برای تبدیل کلیه حروف از Method دیگری تحت عنوان .toUpperCase استفاده می کنیم و خروجی برنامه ما به شکل زیر خواهد بود:

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

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

فرض کنیم که ما یک متغیر از جنس int تحت عنوان studentNumber داریم. مقدار اختصاص داده شده به متغیر ما 121 می باشد:

1. int studentNumber = 121;

حال اگر بخواهیم عددی مثل 10 را به مقدار متغیر studentNumber که معادل با 121 است اضافه کنیم به این صورت عمل می کنیم:

1. int studentNumber = 121;
2. studentNumber = studentNumber + 10;

روش دیگری که از آن طریق می توان 10 واحد به 121 اضافه کرد به صورت زیر است:

1. int studentNumber = 121;
2. studentNumber +=10;
3.  

در این صورت عدد 10 به مقدار متغیر که 121 است اضافه شده، حال از این پس مقدار متغیر studentNumber عدد 131 خواهد بود. چنان چه بخواهیم عدد 10 را از مقدار متغیرمان کم کنیم به صورت زیر عمل می کنیم:

1. int studentNumber = 121;
2. studentNumber = studentNumber - 10;

روش دیگری که از آن طریق می توان 10 واحد از 121 کم کرد به صورت زیر است:

1. int studentNumber = 121;
2. studentNumber -=10;
3.  

حال مقدار نهایی متغیر studentNumber عدد 111 خواهد بود. چنانچه بخواهیم مقدار متغیر studentNumber را در عددی ضرب کنیم به صورت زیر عمل می کنیم:

1. int studentNumber = 121;
2. studentNumber = studentNumber * 10;
3.  

روش دیگری که از آن طریق می توان 10 را در 121 ضرب کرد به صورت زیر است:

1. int studentNumber = 121;
2. studentNumber *=10;

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

1. int studentNumber = 121;
2. studentNumber = studentNumber / 10;

لازم به ذکر است که علامت / نمی بایست با علامت \ اشتباه گرفته شود. روش دیگری که از آن طریق می توان 121 را بر 10 تقسیم کرد به صورت زیر است:

1. int studentNumber = 121;
2. studentNumber /=10;

که در این صورت مقدار متغیر ما که 121 است بر عدد 10 تقسیم خواهد شد و عدد 12.1 به دست خواهد آمد.(توجه داشته باشیم که در اینجا جاوا عدد 12 را به ما نشان خواهد داد چرا که به صورت خودکار عدد حاصله را رند می کند). حال مواقعی برای ما پیش می آید که تمایل داریم مقدار متغیر خود را به میزان یک عدد بیشتر افزایش یا کاهش دهیم که در این صورت بایستی اصطلاحاتی همچون Incrementing و Decrementing را مورد استفاده قرار دهیم. معنای لغوی این واژگان به ترتیب افزایش دادن و کاهش دادن خواهد بود. به طور مثال چنانچه بخواهیم مقدار عددی متغیر studentNumber به میزان یک عدد افزایش دهیم به صورت زیر عمل می کنیم:

1. int studentNumber = 121;
2. studentNumber++;
3.  

حال مقدار عددی متغیر ما عدد 122 خواهد بود. به همین منوال می توانیم یک عدد نیز از مقدار متغیر خود به صورت زیر کم نماییم:

1. int studentNumber = 121;
2. studentNumber--;

حال مقدار نهایی متغیر studentNumber عدد 120 خواهد بود. در مورد Incrementing و Decrementing نکته مهمی را همواره می بایست مد نظر قرار دهیم و آن هم این که چنانچه علامت های + و – قبل از نام متغیر قرار بگیرند(مثلاً ++studentNumber ) اصطلاحاً Pre-incrementing نامیده می شوند و چنانچه پس از نام متغیر قرار بگیرند ( مثلاً studentNumber ++ ) Post-incrementing نامیده می شوند(در مورد علامت – به ترتیب Pre-decrementing و Post-decrementing نامیده می شوند). تفاوتی که مابین Pre و Post وجود دارد از آنجا ناشی می شود که در مورد Pre یک واحد به مقدار متغیر قبل از نمایش دادن آن اضافه می شود. به عبارت دیگر:

1. class test {
2.  
3. public static void main(String[] args) {
4. int studentNumber = 121;
5.  
6. System.out.println(++studentNumber);
7.  
8. }
9. }

در واقع قبل از آنکه مقدار متغیر ما در بخش Console نمایش داده شود یک واحد به آن اضافه می شود و عدد 122 نمایش داده خواهد شد. حال اگر علامت ++ را بعد از نام متغیر قرار دهیم، مقدار یک واحد به مقدار متغیر ما اضافه خواهد شد اما پس از آنکه برنامه یک بار اجرا شد. در واقع کد زیر

1. class test {
2.  
3. public static void main(String[] args) {
4. int studentNumber = 121;
5.  
6. System.out.println(studentNumber++);
7.  
8. }
9. }

یک واحد به متغیر studentNumber پس از آنکه برنامه اجرا شد اضافه می کند که در این صورت ما در بخش Console همان عدد 121 را مشاهده خواهیم کرد چرا که برنامه اجرا می شود، مقدار 121 نمایش داده می شود، سپس یک واحد به آن اضافه می شود و تبدیل به 122 می شود. هم اکنون اگر بخواهیم برنامه خود را تست کنیم که ببینیم آیا یک واحد اضافه شده است یا خیر یک Statement دیگر به کد خود به صورت زیر اضافه می کنیم:

1. class test {
2.  
3. public static void main(String[] args) {
4. int studentNumber = 121;
5.  
6. System.out.println(studentNumber++);
7. System.out.println(studentNumber);
8.  
9. }
10. }

حال پس از آنکه یک واحد در Statement اول به مقدار متغیر ما اضافه شد، پس از فراخوانی مجدد متغیر مقدار جدید آن که 122 است در بخش Console نمایش داده خواهد شد. زمان هایی در برنامه نویسی برای ما اتفاق می افتد که نیاز داریم بیش از یک عمل ریاضیاتی را در کد خود اعمال کنیم که در این صورت دانستن این نکته که جاوا اول کدام عمل اصلی را محاسبه خواهد کرد از اهمیت بسزایی برخوردار خواهد بود. فرض کنیم که دو متغیر از جنس int به نام های x و y داریم که متغیر x دارای هیچ داده ای نمی باشد اما متغیر y دارای مقدار 10 است:

1. int x;
2. int y = 10;

حال در نظر بگیریم که مقدار متغیر x قرار است حاصلضرب مقدار متغیر y در عدد 2 و سپس به علاوه عدد 6 باشد. به عبارت دیگر کد فوق به صورت زیر تغییر خواهد یافت:

1. int x;
2. int y = 10;
3. x = y * 2 + 6;

نتیجه متغیر x هم می تواند عدد 26 و هم 80 باشد بسته به اینکه اول عمل ضرب انجام شود یا عمل جمع. در زبان برنامه نویسی جاوا اعمال Incrementing و Decrementing اول رخ می دهند، سپس اعمال ضرب و تقسیم صورت گرفته و در نهایت اعمال جمع و تفریق اعمال می شوند. حال با دانستن این قوانین می توان گفت که نتیجه متغیر x در مثال فوق 26 خواهد بود. گاهی اوقات ما به عنوان برنامه نویس مجبور هستیم در قواعد زبان برنامه نویسی جاوا دخل و تصرف کنیم. به طور مثال گاهی اوقات ما نیاز داریم تا عمل جمع قبل از عمل ضرب صورت گیرد. به عبارت دیگر در مثال فوق ما نیاز داریم تا اول عددهای 2 و 6 با یکدیگر جمع شده سپس حاصلجمع آن ها در مقدار متغیر y که برابر با 10 است ضرب شود. در چنین مواقعی به راحتی می توان دو عددی که می خواهیم با یکدیگر جمع شوند و یا از یکدیگر کم شوند را داخل علامت های ( ) قرار دهیم:

1. int x;
2. int y = 10;
3. x = y * (2 + 6);

حال نتیجه ای که به دست خواهد آمد عدد 80 خواهد بود. نکته ای که در اینجا می بایست حتماً به خاطر بسپاریم این است که نمی توانیم این اعمال را (ضرب، تقسیم، جمع و تفریق) مابین یک متغیر از جنس int و یک متغیر از جنس double اجرا کنیم که در این صورت Compiler در حین اجرای برنامه Error خواهد داد. پس از آشنایی با انواع متغیر ها در آموزش پیشین و همچین آشنایی با Operator ها در این جلسه، خواهیم توانست مهارت کدنویسی خود را یک پله ارتقاء داده و برنامه هایی کمی پیچیده تر بنویسیم. در قسمت آموزشی آتی خواهیم دید که چگونه با استفاده از همین اصول ابتدایی Operator ها می توان پروژه ای طراحی کرد که وزن ما را روی دیگر سیارات منظومه شمسی مثل مشتری و زحل محاسبه کند.

سناریویی که در این جلسه قرار است بر آن اساس یک برنامه بنویسیم به این شکل است که می خواهیم وزن کنونی خود را که روی کره زمین قرار داریم را وارد برنامه کرده سپس ببینیم که وزن ما روی سیارات دیگری مثل مشتری و زحل چه قدر است.
بر اساس روشی در که در جلسه اول آموزش توضیح داده شد یک پروژه جدید جاوا به نام 9th Session به معنی جلسه نهم ایجاد می کنیم و یک Class با نام Operator در آن ایجاد می کنیم. پس از باز کردن فایل، کدی همچون کد زیر را مشاهده خواهیم کرد که در ادامه مطلب قرار گرفته است:

1. public class Operator {
2. /**
3. * @param args
4. */
5. public static void main(String[] args) {
6. // TODO Auto-generated method stub
7. }
8.  
9. }
10.  

همانطور که در آموزش های پیشین توضیح داده شد در زبان برنامه نویسی جاوا سه نوع Comment وجود دارد که در کد بالا ما دو نوع از Comment ها را مشاهده می کنیم. حال کلیه Comment ها را حذف کرده و کد ما به شکل زیر در خواهد آمد:

1. public class Operator {
2.  
3. public static void main(String[] args) {
4.  
5. }
6.  
7. }
8.  

به خاطر داشته باشیم که برای حذف یک خط از کد می توانیم نشانگر موس خود را روی خطی از کد که می خواهیم حذف کنیم قرار داده سپس کلید کنترل را هم زمان با دکمه E فشار دهیم. به خاطر داشته باشیم که در زبان انگلیسی معادل مشتری Jupiter و معادل زحل Saturn می باشد. نکته ای که در همین ابتدای برنامه نویسی می بایست جزو عادات خود به عنوان یک برنامه نویس حرفه ای قرار دهیم این است که برای هر بخش از کد خود که می نویسیم یک Comment قرار دهیم که در آینده دچار سردرگمی نشویم(روالی که در این سری از آموزش ها پیش گرفته شده، انتقال کامل مفاهیم با کمترین حجم مطلب ممکن است. از این رو فقط در موارد خیلی ضروری از Comment ها استفاده خواهیم کرد). اگر علاقمندان به برنامه نویسی با زبان انگلیسی آشنایی نداشته باشند، هم می توانند Comment های خود را به صورت فینگلیش بنویسند و هم می توانند به صورت فارسی بنویسند. فقط بایستی به خاطر داشته باشیم که اگر Comment های خود را به صورت فارسی بنویسیم، حتماً می بایست در حین Save کردن فایل جاوای خود گزینه Save as UTF-8 را انتخاب نماییم. پس از نوشتن Comment در مورد اولین خط از کد، می خواهیم اولین جمله را در بخش Console نمایش دهیم. به همین منظور طبق کد زیر عمل می کنیم:

1. public class Operator {
2.  
3. public static void main(String[] args) {
4. // این بخش از کد مربوط وزن من روی کره زمین است
5. System.out.print("My weight on the Earth");
6. }
7. }

از آنجا که خیلی از دوستان ممکن است دوست داشته باشند که از وزن خود در سیارات دیگر مطلع شوند، توصیه می کنیم که مقدار متغیر وزن روی کره زمین را وزن دقیق خودشان وارد نمایند. برای همین منظور یک متغیر از جنس double ایجاد می کنیم. علت اینکه متغیری از جنس int ایجاد نکردیم این است که ممکن است وزن برخی از ما دارای اعشار باشد که در این صورت حتماً نیاز داریم تا متغیری از جنس اعشاری را در نظر بگیریم. حال کد ما به صورت زیر خواهد بود:

1. public class Operator {
2.  
3. public static void main(String[] args) {
4. // این بخش از کد مربوط وزن من روی کره زمین است
5. System.out.print("My weight on the Earth ");
6. double myWeightOnEarth = 85.5;
7. System.out.println(myWeightOnEarth);
8. }
9. }

اولین دستور نوشته شده بعد از Comment وظیفه دارد که جمله My weight on the Earth به معنی وزن من روی کره زمین را روی صفحه مانیتور به نمایش در آورد. متد print() این وظیفه را دارا است که چیزی را روی صفحه نمایش نشان دهد. چیزی که در مورد این متد حائز اهمیت است این است که پس از نمایش دادن متن داخلش، برنامه به خط بعد نرفته و هر آنچه که بخواهد در پنجره Console به نمایش در آید در ادامه آن خط قرار خواهد گرفت(در قسمت های آتی به طور مفصل پیرامون متدها در زبان برنامه نویسی جاوا صحبت خواهد شد). در خط بعد ما اقدام به تعریف یک متغیر از جنس double کرده ایم که این قابلیت را دارا است که اعداد اعشاری را در خود ذخیره سازد. پس از در نظر گرفتن نامی برای متغیر خود پس از علامت = عددی را به عنوان مقدار آن در نظر گرفته و علامت ; را در انتهای Statement خود قرار می دهیم(بنده در اینجا وزن خودم که 85 و نیم است را در نظر گرفته ام). در خط بعد مجدداً دستور System.out را نوشته اما این بار به جای متد print() از متد println() استفاده می کنیم و در نهایت یک علامت ; می گذاریم و نام متغیر خود را داخل آن می نویسیم تا از این طریق روی صفحه به نمایش در آید(در واقع فرق مابین کلمه print با کلمه println در این است که متد print() متن ما را روی صفحه چاپ می کند اما خط را به اتمام نمی رساند و مابقی نوشته های ما را در بخش های بعدی پس از نوشته ما قرار می دهد اما این در حالی است که متد println() همانند Enter در نرم افزار Word عمل می کند که جمله را نوشته و به خط بعدی می رود.) علت اینکه بنده در مورد اول از متد print() استفاده کردم این بود که می خواستم مقدار عددی متغیر myWeightOnEarth به معنی وزن من روی کره زمین بلافاصله پس از جمله My weight on the earth قرار گیرد. علت این هم که یک فاصله بعد از کلمه Earth قرار دادم این بود که عدد 85.5 به واژه Earth نچسبد. حال چنانچه ما فرمان اجرا را از طریق منوی اصلی گزینه Run و مجدداً زیرشاخه Run یا کلید Fn + F5 صادر کنیم، در بخش Console نرم افزار اکلیپس جمله My weight on the earth 85.5 به نمایش در خواهد آورد. در این بخش از برنامه نویسی می خواهیم وزن خود را در سیارات مشتری و زحل محاسبه نماییم. با یک سرچ ساده در اینترنت بنده میزان جاذبه دو سیاره دیگر را نسبت به کره زمین پیدا کرده که عبارتند از مشتری معادل با 2.54 و زحل معادل با 1.08 (لازم به ذکر است که این نوع محاسبه و اعداد ممکن است تا حدودی با واقعیت تفاوت داشته باشند. نکته ای که در این تمرین مد نظر ما است به کار گیری Operator ها یا اعمال اصلی ریاضیاتی در زبان برنامه نویسی جاوا می باشد). حال به صورت زیر کد های مرتبط با دو سیاره دیگر را می نویسیم:

1. public class Operator {
2.  
3. public class Operator {
4.  
5. public static void main(String[] args) {
6. // این بخش از کد مربوط وزن من روی کره زمین است
7. System.out.print("My weight on the Earth ");
8. double myWeightOnEarth = 85.5;
9. System.out.println(myWeightOnEarth);
10. // این بخش از کد مربوط به وزن من روی سیاره مشتری است
11. System.out.print("My weight on the Jupiter ");
12. double myWeightOnJupiter = myWeightOnEarth * 2.54;
13. System.out.println(myWeightOnJupiter);
14.  
15. // این بخش از کد مربوط به وزن من روی سیاره زحل است
16. System.out.print("My weight on the Saturn ");
17. double myWeightOnSaturn = myWeightOnEarth * 1.08;
18. System.out.println(myWeightOnSaturn);
19.  
20. }
21. }

در بخش بعدی از کد خود یک Comment قرار می دهیم تا متوجه شویم که کد مربوط به وزن ما روی سیاره مشتری در کجای برنامه قرار گرفته است. سپس همچون مراحل قبل عمل کرده اما این بار جمله My weight on the Jupiter به معنی وزن من روی سیاره مشتری را داخل علامت “ “ می نویسیم. همانطور که در کد فوق مشاهده می شود ما مقدار متغیر myWeightOnEarth را قبلاً ذخیره کرده ایم. حال می خواهیم مقدار متغیر مرتبط با مشتری را ایجاد کنیم برای این منظور متغیر ی از جنس double به نام myWeightOnJupiter به معنی وزن من روی سیاره مشتری ایجاد کرده و مقدار اولیه آن را نام متغیر myWeightOnEarth ضرب در عدد 2.54 می کنیم(در واقع نام این متغیر حاکی از عدد 85.5 است). اکنون وزن ما روی سیاره مشتری به دست آمده است و با قرار دادن نام متغیر مرتبط با مشتری در دستور System.out.println(); می توانیم وزن خود را روی صفحه مانیتور نمایش دهیم. به همین روشن متغیری برای سیاره زحل ایجاد کرده به این شکل که همان طور که در کد فوق مشاهده می شود متغیری از جنس double به نام myWeightOnSaturn به معنی وزن من روی سیاره زحل ایجاد کرده و مقدار اولیه آن را نام متغیر مرتبط با وزن ما روی کره زمین ضرب در عدد 1.08 قرار می دهیم و با قرار دادن نام متغیر مرتبط با زحل در دستور System.out.println(); مقدار آن را روی صفحه مانیتور نمایش می دهیم. پس از اجرای برنامه در بخش Console نتیجه زیر مشاهده خواهد شد:(لازم به ذکر است چنانچه شما هم وزن نگارنده این آموزش باشید نتایج زیر را مشاهده خواهید کرد و در صورتیکه وزن شما چیزی دیگری مثلاً 76 کیلو باشد نتایج کاملاً متفاوت خواهند بود.

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

فرض کنیم که در یک برج مسکونی زندگی می کنیم و علیرغم اینکه مدیر ساختمان از سکنه درخواست کرده است که بیش از 10 نفر باهم سوار آسانسور نشوند باز هم مشاهده می کند که سکنه رعایت نمی کنند. با توجه به اینکه ایشان می دادند که ما یک برنامه نویس هستیم از ما درخواست می کند که یک برنامه برای ظرفیت مجاز آسانسور بنویسیم. ما هم از درخواست ایشان استقبال کرده و اقدام به نوشتن برنامه می کنیم. پس زمان رفتن طبقه پایین! (ادامه مطلب) رسیده است. دکمه را فشار دهید.

برای نوشتن چنین برنامه ای اول یک پروژه جدید در اکلیپس ایجاد می کنیم و نام آن را 10th Session به معنی جلسه دهم می گذاریم. حال یک Class تحت عنوان ElevatorCapacity به معنی ظرفیت آسانسور ایجاد می کنیم. به خاطر داشته باشیم که در حین ایجاد Class گزینه public static void main را تیک بزنیم. حال می بایست کدی به شکل زیر داشته باشیم:

1. public class ElevatorCapacity {
2.  
3. /**
4. * @param args
5. */
6. public static void main(String[] args) {
7. // TODO Auto-generated method stub
8.  
9. }
10.  
11. }

اگر بخواهیم می توانیم Comment ها را حذف کنیم. در این برنامه ما یک Method از جنس main داریم که به منزله بخشی از برنامه ما است که برنامه از آن جا شروع می شود. اکنون به نظر می رسد که اگر بخواهیم که یک جمله روی صفحه مانیتور نمایش دهیم که عنوان برنامه ما را نمایش دهد با توجه به تمرین های پیشین هیچ مشکلی نداشته باشیم. برای این منظور کد فوق را به صورت زیر تکمیل می کنیم:

1. public class ElevatorCapacity {
2.  
3. public static void main(String[] args) {
4. // عنوان برنامه ظرفیت آسانسور
5. System.out.println("How many people should get on?");
6. }
7.  
8. }
9.  

به خاطر داشته باشید که برای وارد کردن Comment به زبان فارسی پس از Save کردن برنامه پیغامی روی صفحه ظاهری می شود که در این مرحله می بایست گزینهUTF-8 Save as را انتخاب نماییم. حال به بررسی تک تک کلید واژه هایی از زبان برنامه نویسی جاوا می پردازیم که بعد از Comment در کد آمده اند. در حقیقت واژه System یکی از کلاس ها یا آجرهای سازنده API در زبان برنامه نویسی جاوا است. این برنامه داخلی جاوا به بخش هایی از کامپیوتر ما دسترسی پیدا خواهد کرد که خارج از کنترل مستقیم ماشین مجازی جاوا یا JVM است(این توضیحات فقط جهت آگاهی بیشتر آمده است و از برنامه نویسان مبتدی درخواست می شد خیلی ذهن خود را درگیر مسائلی از این دست نکنند). واژه out نشانگر جایی در برنامه اکلیپس است که متن را در آن به نمایش در می آورد. در واقع در محیط برنامه نویسی اکلیپس این مکان همان پنجره Console است که نمونه اجرا شده برنامه خود را می توانیم در آن مشاهده کنیم. متد print این دستور را به کامپیوتر می دهد که یک خط از کد را روی صفحه به نمایش در آورد. اهمیت بسیار زیاد آن در زبان برنامه نویسی جاوا، علت توضیح مجدد موضوعی که می خواهم هم اکنون عرض کنم. زبان برنامه نویسی جاوا به حروف بزرگ و کوچک حساس است از اینرو اگر واژه System را با حرف کوچک به صورت system بنویسیم برنامه ما اجرا نخواهد شد. این مسئله در موارد مابقی کلمات Statement فوق نیز صدق می کند. حال که با معنای تک تک کلید واژه های فوق آشنا شدیم بایستی گفت هر آنچه که در داخل پرانتز در مقابل متد println قرار گیرد روی صفحه مانیتور ما در حین اجرای برنامه چاپ خواهد شد. نکته ای که در اینجا می بایست مد نظر قرار دهیم این است که اگر بخواهیم یک جمله را روی صفحه مانیتور چاپ نماییم، در داخل پرانتز می بایست دو علامت “ “ قرار داده و متن خود را داخل آن تایپ کنیم اما در صورتی که بخواهیم فقط به طور مثال مقدار یک متغیر را روی صفحه به نمایش در آوریم می بایست صرفاً نام آن متغیر را درون پرانتز مقابل println بنویسیم که در این صورت هر آنچه مقداری که برای آن متغیر از پیش تعیین کرده باشیم روی صفحه نمایش داده خواهد شد. حال پس از اجرای برنامه جمله How many people should get on? به معنای چند نفر می بایست سوار شوند؟ روی صفحه مانیتور ظاهر شود. هم اکنون می بایست یک متغیر از جنس int برای ذخیره سازی وزن هر شخص که به طور متوسط 75 کیلو است را تعریف نماییم. برای اینکار به صورت زیر عمل می کنیم:

1. int weightOfEachPerson = 75;

در واقع نام این متغیر را weightOfEachPerson به معنی وزن هر فرد می گذاریم و Value آن را 75 کیلو در نظر می گیریم(توجه داشته باشیم که واحد کیلو فقط در ذهن ما به عنوان برنامه نویس است و هیچ جایی در int آن را تعریف نمی کنیم. از سوی دیگر فرض را در این برنامه بر آن می گذاریم که وزن افراد یک عدد صحیح خواهد بود. اگر بخواهیم چنین امکانی را فراهم کنیم که وزن افراد به صورت اعشاری وارد برنامه شود(مثلاً 75.5 ) صرفاً نیاز است تا از متغیری از جنس double استفاده کنیم). نحوه نام گذاری این متغیر هم به این شکل است که اولین کلمه که weight است با یک حرف کوچک شروع شده و حرف اول کلمات بعدی با حرف بزرگ شروع شده اند(در حقیقت شما هر نامی به هر شکلی را می توانید برای خود در نظر بگیرید اما نکته این جا است که این نوع نامگذاری یک روش رایج مابین برنامه نویسان حرفه ای است و به امید خدا چنانچه روزی شما هم به یک برنامه نویس حرفه ای جاوا و اندروید مبدل شدید و خواستید عضوی از یک تیم برنامه نویسی شوید دیگر مشکلی در رابطه با نحوه نامگذاری نخواهید داشت. از سوی دیگر این روش نام گذاری که اصطلاحاً camelCase نامیده می شود منجر به راحت خواندن اسامی در محیط برنامه نویسی جاوا می شود زیرا اگر به طور مثال نام خود را به صورت عادی و به شکل weightofeachperson بنویسیم به دشواری آن را می توانیم بخوانیم. در زبان انگلیسی واژه Camel به معنای شتر است و این سبک نوشتن به این خاطر به camelCase معرف شده است که نامی که ما در نظر می گیریم یک شمایی از کوهان شتر را خواهد داشت). در مرحله بعد یک دیگر از جنس int برای ظرفیت آسانسور به شکل زیر تعریف می کنیم:

1. int elevatorCapacity = 750;

نام این متغیر را elevatorCapacity به معنی ظرفیت آسانسور با Value به میزان 750 کیلو تعریف می کنیم. حال بایستی یک متغیر دیگر از جنس int ایجاد کنیم که در آن مقدار elevatorCapacity را بر مقدار weightOfEachPerson تقسیم کنیم. نام این متغیر آخر را numberOfPeople به معنی تعداد افراد می گذاریم و به صورت زیر آن را می نویسیم:

1. int numberOfPeople = elevatorCapacity / weightOfEachPerson;

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

1. boolean doorClosingOrder = numberOfPeople > 10;

به طور خلاصه ما به این متغیر دستور می دهیم که اگر مقدار numberOfPeople که حاصل تقسیم مقادیر elevatorCapacity بر weightOfEachPerson می باشد بیش از 10 شود بایستی مقدار boolean که دو حالت بیشتر ندارد true شود یعنی تعداد افراد سوار شده در آسانسور بیش از 10 نفر است و در غیر این صورت مقدار false در نظر گرفته شود به این معنی که تعداد افراد سوار شده در آسانسور کمتر از 10 نفر است. حال کد خود را به شکل زیر تکمیل می کنیم:

1. public class ElevatorCapacity {
2.  
3. public static void main(String[] args) {
4. // عنوان برنامه ظرفیت آسانسور
5. System.out.println("How many people should get on?");
6. //وزن هر شخص
7. int weightOfEachPerson = 75;
8. //ظرفیت آسانسور
9. int elevatorCapacity = 750;
10. //تقسیم کردن ظرفیت آسانسور بر وزن هر شخص و اختصاص آن به یک متغییر
11. int numberOfPeople = elevatorCapacity / weightOfEachPerson;
12. //تعیین اینکه آیا ظرفیت بیش از 10 نفر است یا خیر؟
13. boolean doorClosingOrder = numberOfPeople > 10;
14. //نمایش جمله ای به معنای اینکه آیا تعداد افراد بیش از ده نفر است؟
15. System.out.println("Is the number of people more than 10?");
16. //نمایش نتیجه متغییر بولین
17. System.out.println(doorClosingOrder);
18.  
19. }
20.  
21. }
22.  

در نهایت جمله Is the number of people more than 10? را از طریق دستور System.out.println(); روی صفحه نمایش می دهیم و پس از آن نتیجه متغیر boolean را در خط آخر کد خود روی صفحه نمایش می دهیم.حال برنامه خود را اجرا کرده و خروجی برنامه را روی صفحه مانیتور مشاهده می کنیم. همانطور که در تصویر زیر مشاهده می شود پس از اجرای برنامه در بخش Console کلمه false نمایش داده خواهد شد.

در واقع برای روشن تر شدن مطلب، کد خود را تفسیر می کنیم. در ابتدا وزن هر فرد را به طور متوسط 75 کیلو در نظر می گیریم و ظرفیت آسانسور را 750 کیلو. سپس ظرفیت آسانسور را بر 75 تقسیم می کنیم که عدد 10 به دست می آید. حال در boolean محاسبه می کنیم که اگر مقدار numberOfPeople بیش از 10 باشد مقدار این متغیر true شود و اگر کمتر از 10 باشد مقدار این false شود. سپس جمله Is the number of people more than 10? به معنی آیا تعداد افراد بیش از 10 نفر است؟ را روی صفحه مانیتور نمایش می دهیم و بعد از آن نتیجه boolean خود را روی صفحه نمایش نشان می دهیم. در واقع با محاسباتی که انجام می دهیم در پاسخ به سوال فوق، برنامه نتیجه false به معنای نادرست یا خیر را به ما می دهد. پس حال که پاسخ به سوال فوق خیر است این اجازه به درب آسانسور داده می شود تا بسته شود.

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

برای این منظور می بایست با کلاس Scanner در زبان برنامه نویسی جاوا آشنا شویم. در حقیقت این کلاس در API زبان برنامه نویسی جاوا طراحی شده است و ما صرفاً با Import کردن این کلاس و همچنین ساخت یک شیئ از روی آن می توانیم از قابلیت های آن استفاده کنیم. برای روشن شدن این مطلب پروژه جدید در اکلیپس تحت عنوان 11th Session به معنی جلسه یازدهم ایجاد می کنیم. سپس کلاسی تحت عنوان Project به معنی پروژه در آن ایجاد می کنیم. (کلیه نام ها اختیاری می باشند). در ابتدا برنامه ما می بایست به شکلی باشد که در ادامه مطلب آمده.

1. class Project {
2.  
3. public static void main(String[] args) {
4.  
5. }
6. }

در حقیقت از آنجا که نیاز داریم تا برنامه ما یک نقطه شروع داشته باشد، همانطور که در جلسا ت گذشته توضیح داده شد در حین ایجاد کلاس گزینه public static void main را تیک می زنیم. حال ما نیاز داریم تا این امکان را به کاربر خود بدهیم تا بتواند از طریق صفحه کلید اطلاعات را وارد برنامه کند، از اینرو کلاس Scanner را وارد برنامه خود می کنیم و نامی به دلخواه همچون myScanner برای آن در نظر می گیریم. به عکس زیر توجه کنید:

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

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

1. import java.util.Scanner;
2. class Project {
3. public static void main(String[] args) {
4. Scanner myScanner = new Scanner(System.in);
5. }
6. }

(لازم به ذکر است که به جای Import کردن توسط محیط برنامه نویسی اکلیپس، می توانیم خود کد های Import مورد نیاز را به صورت دستی وارد برنامه کرده و یا پس از استفاده از یکی از کلاس های API جاوا همچون کلاس Scanner کلیدهای Ctrl و Shift و حرف O را به طور هم زمان فشار دهیم که با این کار فرآیند Import انجام خواهد شد). پس از Import کردن همانطور که در کد فوق مشاهده می شود یک خط کد import java.util.Scanner; به ابتدای کد ما اضافه می شود. از این پس بعد هر چند بار که نیاز داشته باشیم می توانیم بدون هیچ مشکلی از روی کلاس Scanner یک شیئ جدید ساخته و آن را مورد استفاده قرار دهیم(نحوه ساخت اشیاء در زبان جاوا به طور مفصل در آموزش سی و یکم مورد بررسی قرار خواهد گرفت). واژه Scanner نشانگر یک Class در جاوا است که از پیش نوشته شده است و ما صرفاً آن را وارد برنامه خود می کنیم. واژه myScanner یک نام است به معنی کلاس اسکنر من که ما به صورت دلخواه برای نام شیئ ساخته شده از روی کلاس Scanner در نظر می گیریم. پس از علامت = با نوشتن واژه new ما از اکلیپس می خواهیم که یک شیئ جدید از کلاس Scanner تحت عنوان myScanner برای ما ایجاد کند. حال پارامترهایی که داخل پرانتز قرار دارند عبارتند از کلید واژه System که حاکی از کلاسی است که این امکان را به جاوا می دهد که هرآنچه خارج از اختیار JVM بود وارد برنامه شود و کلید واژه in که موجب می گردد ورودی کامپیوتر یا لپ تاپ ما مورد استفاده این کلاس قرار گیرد که این ورودی همان صفحه کلید می باشد. حال می توانیم برنامه خود را تست کنیم. برای این منظور کد خود را به شکل زیر تکمیل می کنیم:

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. System.out.println(myScanner.nextLine());
8.  
9. }
10. }

در حقیقت با این Statement جدید که وارد برنامه خود کردیم، قصد داریم هر آنچه را که از طریق صفحه کلید وارد می کنیم برای ما مجدد نمایش داده شود. داخل دستور System.out.println(); ما نام شیئ که از روی کلاس Scanner ایجاد کردیم را نوشته سپس متدی تحت عنوان nextLine() ضمیمه آن می کنیم. به طور خلاصه کار این متد آن است که هر نوع ورودی از طریق صفحه کلید را وارد برنامه کند. حال اگر بخواهیم ورودی خاصی از صفحه کلید را مد نظر داشته باشیم بایستی از متد مخصوص همان داده ورودی استفاده کنیم. متد nextLine() حاکی از آن است که هر آنچه را وارد صفحه کلید کنیم به شکل یک string یا متن روی صفحه مانیتور نمایش داده شود. برای مثال برنامه را اجرا کرده، سپس در بخش Console نشانگر موس خود را مشاهده می کنیم که چشمک می زند به معنی اینکه می توانیم در آن چیزی وارد نماییم. حال جمله ای به دلخواه مثل My name is Behzad Moradi به معنی نام من بهزاد مرادی هست را وارد می کنیم سپس دکمه Enter را می زنیم و مشاهده می کنیم که دقیقاً همان چیزی را که از طریق صفحه کلید وارد برنامه کردیم را نمایش خواهد داد:

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

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

ادامه مطلب را از دست ندهید.

برای شروع کار پروژه ای تحت عنوان 12th Session به معنی جلسه دوازدهم ایجاد کرده و کلاسی تحت عنوان ScannerClass در آن می سازیم. در ابتدا کد ما می بایست به شکل زیر باشد:

1. class ScannerClass {
2.  
3. public static void main(String[] args) {
4. }
5. }
6.  

اکنون همانطور که در جلسات گذشته آموزش داده شد یک شیئ از روی کلاس Scanner ساخته و نام آن را keyboardInput به معنی ورودی کیبورد می گذاریم. حال کد تکمیل شده ما می بایست به صورت زیر باشد:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6.  
7. }
8. }

در این قسمت از آموزش قصد داریم تا انواع متدهایی را که می توان به همراه کلاس Scanner مورد استفاده قرار داد را مورد بررسی قرار دهیم. متدی که در جلسه گذشته مورد استفاده قرار دادیم عبارت بود از nextLine() به طوریکه یک خط از نوشته را برای ما در پنجره Console به نمایش در آورد. به عبارت دیگر این متد تا زمانیکه ما دکمه Enter را نزنیم، هر داده ای را در خود ذخیره خواهد ساخت. به منظور به کار گیری این متد کد خود را به شکل زیر تکمیل می کنیم:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6. System.out.println(keyboardInput.nextLine());
7.  
8. }
9. }
10.  

در کد فوق در دستور System.out.println(); که وظیفه دارد هر آنچه داخل آن قرار گرفت را روی صفحه مانیتور به نمایش در آورد، نام شیئ خود که از روی کلاس Scanner ساختیم را وارد کرده یک نقطه قرار می دهیم و متد nextLine() را به آن ضمیمه می کنیم. در این متد حتی اگر ترکیبی از متن و عدد هم وارد کنیم نمایش داده خواهد شد. به تصویر زیر توجه کنید:

همانطور که در تصویر فوق مشاهده می شود با استفاده از این متد می توان ترکیبی از حروف، کلمات، اعداد و حتی علائم را وارد برنامه خود کرد. این متد زمان هایی که از کاربر بخواهیم مثلا یک رمز عبور برای خودش تعییین کند بسیار کاربرد خواهد داشت. به طور خلاصه این متد هرآنچه را که کاربر از طریق کیبورد وارد برنامه کند را تا زمانیکه کاربر دکمه Enter را بزند دریافت می کند. متد بعدی متد next() است. از این متد هم می توان برای گرفتن هر نوع ورودی استفاده کرد با این تفاوت که این متد گرفتن داده ها را از کیبورد تا زمانی ادامه می دهد که یک Space مشاهده کند و به محض اینکه یک Space مشاهده شد، گرفتن داده های ورودی متوقف خواهد شد. برای استفاده از این متد کد خود را به شکل زیر بازنویسی می کنیم:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6. System.out.println(keyboardInput.next());
7.  
8. }
9. }
10.  

حال برنامه را اجرا کرده و تعدادی کاراکتر و عدد پشت سر هم نوشته و یک فاصله قرار می دهیم و سپس تعدادی کاراکتر و عدد دیگر می نویسیم سپس دکمه Enter را می زنیم:

همانطور که در تصویر فوق مشاهده می شود، در خط اول عبارت ABC123 وارد شده و سپس عبارت EFG456 و در آخر دکمه Enter را زده ایم. چیزی که متد next() از ورودی برنامه گرفته است به این شکل است که از ابتدای خط شروع به خواندن ورودی کرده تا جاییکه به یک فاصله رسیده است و بلافاصه پس از رسیدن به یک فاصله فرایند گرفتن ورودی متوقف شده است(به عبارت دیگر فاصله ها در این متد نقش Separator یا جدا کننده را بازی می کنند). از اینجا به بعد اگر ما هزاران کاراکتر هم وارد برنامه خود کنیم در برنامه ذخیره نخواهد شد. حال پس از زدن دکمه Enter برنامه فقط داده اول را نمایش می دهد. اکنون اگر بخواهیم کاری کنیم که برنامه ما قادر گردد ورودی هایی که پس از یک فاصله نیز وارد می شوند را دریافت کند، صرفا نیاز است تا یک بار دیگر شیئ ساخته شده از روی کلاس Scanner به همراه یک متد next() دیگر ایجاد کنیم. به کد تکمیل شده زیر توجه کنید:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6. System.out.println(keyboardInput.next());
7. System.out.println(keyboardInput.next());
8.  
9. }
10. }

در این کد ما دو بار از متد next() استفاده کرده ایم که با اینکار به برنامه خود دستور می دهیم که متد اول ورودی از طریق کیبورد را دریافت کند تا جاییکه یک فاصله مشاهده کند. متد دوم به دنبال یک Space می گردد و به محض اینکه اولین فاصله ورودی را پیدا کرد حال هر آنچه پس از آن فاصله وارد شده باشد را گرفته و ذخیره می سازد تا جاییکه یک فاصله دیگر مشاهده کند. به خروجی کد فوق توجه کنید:

در اجرای فوق تعدادی کاراکتر و عدد تصادفی وارد کرده سپس یک فاصله قرار داده و تعدادی کاراکتر و عدد تصادفی دیگر وارد می کرده ایم و سپس دکمه Enter را زده ایم. کاراکترها و اعداد تصادفی اول تا قبل از فاصله توسط متد next() اول ذخیره شده اند و کاراکترها و اعداد تصادفی پس از فاصله توسط متد next() دوم ذخیره شده اند. پس از زدن دکمه Enter ورودی متد اول در خط دوم نمایش داده می شود و ورودی متد دوم در خط سوم نمایش داده می شود. به همین روال می تواند به تعداد نامحدود از متد next() استفاده کرد. متد دیگری که می توان مورد استفاده قرار داد متد nextInt() است که صرفاً از طریق آن می توان اعداد صحیح را از طریق کیبورد وارد برنامه خود کرد. برای روشن شدن این مطلب کد خود را به شکل زیر تغییر می دهیم:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6. System.out.println(keyboardInput.nextInt());
7.  
8. }
9. }

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

همانطور که گفتیم داده ورودی از جنس عدد صحیح گرفته شده و مجدداً روی صفحه مانیتور نمایش داده می شود. هم اکنون می خواهیم ببینیم که اگر داده ای به غیر از عدد صحیح وارد برنامه کنیم چه اتفاقی خواهد اتفاد. برای همین منظور یک بار دیگر برنامه را اجرا کرده و این بار به جای یک عدد صحیح داده ی دیگری مثلا یک عدد اعشاری وارد مثل عدد 12.5 را وارد می کنیم:

می بینیم که برنامه ما با یک خطا مواجه شد. در واقع عبارت آبی رنگ java.util.InputMismatchException در تصویر فوق حاکی از آن است که داده ورودی با متد به کارگرفته شده هم خوانی ندارد. اکنون می بینیم که این نکته چه قدر اهمیت دارد که نوع داده ورودی با متد استفاده شده در کلاس Scanner می بایست اصطلاحاً با یکدیگر Match باشند. متدی دیگری که آشنایی با آن اهمیت دارد متد nextDouble() است به طوریکه این متد مسئول ذخیره سازی اعداد اعشاری می باشد. برای امتحان کردن این متد کل خود را به شکل زیر بازنویسی می کنیم:

1. import java.util.Scanner;
2.  
3. class ScannerClass {
4. public static void main(String[] args) {
5. Scanner keyboardInput = new Scanner(System.in);
6. System.out.println(keyboardInput.nextDouble());
7.  
8. }
9. }

اکنون پس از اجرای برنامه و وارد کردن یک عدد اعشاری مثل 12.5 خواهیم دید که متد nextDouble() ورودی اعشاری را در خود ذخیره کرده و سپس از طریق کلاس Scanner آن را نمایش می دهد:

اگر به خاطر داشته باشید زمانیکه در متد nextInt() یک عدد اعشاری وارد کردیم، برنامه از ما خطا گرفت چرا که نوع داده ورودی با نوع متد هم خوانی نداشت. حال ببینیم اگر در متد nextDouble() یک عدد صحیح وارد کنیم چه اتفاقی خواهد افتاد(برای مثال عدد 100 را وارد می کنیم):

می بینیم که برنامه به درستی کار کرده و حتی عدد صحیح ما را هم به یک عدد اعشاری تبدیل کرده است که مقدار آن عدد اعشاری همانند عدد صحیحی بود که از طریق کیبورد وارد برنامه کردیم با این تفاوت که یک ممیز پس از عدد ورودی قرار داده و یک صفر پس از ممیز گذاشته شده است. در واقع ما به عنوان یک برنامه نویس حرفه ای این اجازه را نداریم تا برنامه ای طراحی کنیم که در صورت ورود داده اشتباه برنامه Crash کرده و از ادامه باز ایستد. به عبارت دیگر ما موظف هستیم از متدهایی استفاده کنیم که هم خوانی داده ورودی با نوع متغیر را سنجیده و در صورت عدم تطابق به کاربر اخطار دهد. از آنجا که این مبحث نیازمند آشنایی با دستورات if نیز می باشد، مبحث مربوط به متدهای boolean مرتبط با کلاس Scanner پس از آشنایی با دستورات if در قالب آموزش هفدهم بیان خواهد شد. در قسمت آینده به منظور درک بهتر مفاهیم تئوری، پروژه ای تعریف کرده و کلاس Scanner را در آن مورد استفاده قرار می دهیم.

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

فرض کنیم که ما نیاز داریم تا برنامه ای شخصی طراحی کنیم که این امکان را به ما می دهد تا درآمد ماهیانه خود را وارد آن کنیم، سپس مخارج خود همچون اقساط، بدهی ها، هزینه آب و برق و تلفن و غیره را از آن کم کنیم و در نهایت موجودی باقیمانده را به ما نشان دهد. برای این منظور پروژه ای جدید تحت عنوان 13th Session به معنی جلسه سیزدهم ایجاد کرده و به ادامه مطلب بروید. کلاسی تحت عنوان Project به معنی پروژه در آن می سازیم. برای این منظور کد خود را به این صورت شروع می کنیم:

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. System.out.println("My Financial Turnover");
8.  
9. }
10. }
11.  

در ابتدا یک شیئ از روی کلاس Scanner به نام myScanner می سازیم سپس از آنجا که نیاز داریم تا عنوان نرم افزاری که طراحی می کنیم روی صفحه به نمایش در آید در دستور System.out.println(); جمله My Financial Turnover به معنی گردش مالی من را نوشته تا در بخش Console به نمایش درآید. حال نیاز داریم تا متغیری از جنس عددی برای میزان درآمد و هزینه های جاری خود در نظر بگیریم. برای این منظور یکی از دو گزینه int و یا double را که قبلا در آموزش انواع متغیرها توضیح داده شد را می توانیم استفاده کنیم(برای آشنایی بیشتر به آموزش پنجم مراجعه نمایید). چنانچه بخواهیم این امکان را به خود بدهیم که اعداد اعشاری برای میزان حقوق خود وارد کنیم می بایست از متغیر double استفاده کنیم(مثلا قبض آب معادل با 23000.120 تومان) ولی اگر بخواهیم ورودی های ما به صورت عدد صحیح باشند بایستی از متغیر int استفاده کنیم(مثلاً 2340000 تومان). در این برنامه ما از متغیر int استفاده خواهیم کرد. حال نیاز داریم تا متغیرهایی برای درآمد ماهیانه، اقساط و هزینه های جاری ایجاد کنیم. به منظور جلوگیری از طولانی شدن کد خود کلیه متغیرها را با یکدیگر ادغام خواهیم کرد و به صورت int monthlyIncome, loanPayment, currentExpenses; می نویسیم. حال یک Statement دیگر مبنی بر نوشتن جمله Please enter your monthly income: به معنی لطفا درآمد ماهیانه خود را وارد نمایید به کد خود به همراه Comment های مورد نیاز می نویسیم و کد ما به صورت زیر در خواهد آمد:

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. // The title of the program
8. System.out.println("My Financial Turnover");
9. // Variables
10. int monthlyIncome, loanPayment, currentExpenses;
11. // Text to ask for entering your income
12. System.out.println("Please enter your monthly income:");
13.  
14. }
15. }

جمله Please enter your monthly income: به معنی لطفا درآمد ماهیانه خود را وارد نمایید از ما می خواهد تا عددی را وارد برنامه کنیم، از این رو می بایست مقدار متغیر monthlyIncome که در خط بالا ایجاد کردیم را با استفاده از کلاس Scanner وارد برنامه خود کنیم. برای این منظور کد خود را به شکل زیر تکمیل خواهیم کرد:

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. // The title of the program
8. System.out.println("My Financial Turnover");
9. // Variables
10. int monthlyIncome, loanPayment, currentExpenses;
11. // Code to ask for entering your income
12. System.out.println("Please enter your monthly income:");
13. monthlyIncome = myScanner.nextInt();
14.  
15. }
16. }

در حقیقت ما یک متغیر از جنس int یا عدد صحیح تحت عنوان monthlyIncome ایجاد کرده ایم اما هیچ گونه مقداری برای آن در نظر نگرفته ایم. حال با نوشتن کد monthlyIncome = myScanner.nextInt(); به برنامه می گوییم که با استفاده از شیئ ساخته شده از روی کلاس Scanner که قبلاً به اسم myScanner ایجاد کردیم مقداری را از طریق صفحه کلید برای متغیر monthlyIncome در حافظه ذخیره سازد. از سوی دیگر واژه nextInt() نشانگر نوع ورودی است که ما اجازه داریم به برنامه بدهیم و از آنجا که نوع متغیر ما از جنس int است، نوع ورودی هم می بایست از نوع nextInt() باشد.( به طور مثال اگر نوع متغیر ما از جنس double بود می بایست از متد nextDouble() استفاده کنیم). حال به همین صورت برای متغیرهای loadPayment و currentExpenses به معنی به ترتیب پرداخت وام و هزینه های جاری، از کلاس Scanner استفاده می کنیم که اطلاعات وارد برنامه شود:

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. // The title of the program
8. System.out.println("My Financial Turnover");
9. // Variables
10. int monthlyIncome, loanPayment, currentExpenses;
11. // Code to ask for entering your income
12. System.out.println("Please enter your monthly income:");
13. monthlyIncome = myScanner.nextInt();
14. // Code to ask for entering your loan payment
15. System.out.println("Please enter your loan payment:");
16. loanPayment = myScanner.nextInt();
17. // Code to ask for entering your current expenses
18. System.out.println("Please enter your durrent expenses:");
19. currentExpenses = myScanner.nextInt();
20.  
21. }
22. }

حال چنانچه برنامه را اجرا کنیم تصویر زیر را مشاهده خواهیم کرد:

برنامه طراحی شده منتظر خواهد ماند تا ما میزان درآمد ماهیانه خود را وارد کنیم و به مجرد اینکه عددی از جنس عدد صحیح وارد کردیم، مرحله بعد اجرا می شود و از ما می خواهد تا میزان اقساط وام را مشخص کنیم و در نهایت از ما می خواهد تا میزان هزینه های جاری را وارد کنیم. فرض کنیم که فردی ماهیانه 1000000 تومان درآمد دارد و 120000 تومان قسط وام دارد و هزینه های جاری وی 400000 تومان است. در این صورت خروجی برنامه به شکل زیر خواهد بود:

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

1. import java.util.Scanner;
2.  
3. class Project {
4.  
5. public static void main(String[] args) {
6. Scanner myScanner = new Scanner(System.in);
7. // The title of the program
8. System.out.println("My Financial Turnover");
9. // Variables
10. int monthlyIncome, loanPayment, currentExpenses;
11. // Code to ask for entering your income
12. System.out.println("Please enter your monthly income:");
13. monthlyIncome = myScanner.nextInt();
14. // Code to ask for entering your loan payment
15. System.out.println("Please enter your loan payment:");
16. loanPayment = myScanner.nextInt();
17. // Code to ask for entering your current expenses
18. System.out.println("Please enter your durrent expenses:");
19. currentExpenses = myScanner.nextInt();
20. // Calculating the remainder
21. int result = monthlyIncome - (loanPayment + currentExpenses);
22. System.out.println("The left over money equals to: " + result);
23.  
24. }
25. }
26.  

در حقیقت یک متغیر از جنس int تحت عنوان result به معنی نتیجه ایجاد می کنیم. مقدار این متغیر را درآمد ماهیانه منهای حاصلجمع میزان قسط وام و هزینه های جاری قرار می دهیم. از آنجا که می خواهیم دو عمل اصلی جمع و تفرین با یکدیگر تداخل نداشته باشند حاصلجمع loanPayment و currentExpenses را داخل پرانتز قرار می دهیم که در این صورت برنامه اول مقدار داخل پرانتز را محاسبه کرده و سپس مقدار آن را از monthlyIncome کم می کند. سپس با قرار دادن System.out.println("The left over money equals to: " + result); جمله The left over money equals to: به معنی میزان پول باقیمانده معادل است با: را در بخش Console به نمایش در می آوریم. یکی از ویژگی های Operator ها یا همان اعمال اصلی ادغام کردن چند چیز علاوه بر محاسبات ریاضیاتی است، از همین رو با قرار دادن علامت + پس از جمله “The left over money equals to;” و نوشتن نام متغیر result می توانیم نتیجه نهایی را به صورت یک string یا جمله به شکل زیر نمایش دهیم:

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

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

در زبان برنامه نویسی جاوا برای انجام اینکار از دستورات شرطی if, else, switch استفاده می کنیم. در واقع رایج ترین نوع شرط در زبان برنامه نویسی جاوا استفاده از دستورات if است. در حقیقت با استفاده از چنین دستوراتی ما از برنامه می خواهیم که بسنجد که آیا یک شرط true یا false است و بسته به اینکه true یا false باشد دستور مد نظر ما را اجرا کند.

برای روشن شدن مطالب فوق همانطور که قبلاً آموزش داده شد یک پروژه جدید در محیط برنامه نویسی اکلیپس تحت عنوان 14th Session به معنی جلسه چهاردهم ایجاد کرده و کلاسی به اسم IfClass در آن ایجاد می کنیم (لازم به ذکر است این نام ها اختیاری هستند فقط می بایست توجه داشته باشیم که نحوه نام گذاری صحیح باشد). فراموش نکنیم که در حین ساخت این کلاس گزینه public static void main را تیک بزنیم و بعد به ادامه مطلب برویم!

پیش از نوشتن هرگونه دستوری کد ما به شکل زیر خواهد بود:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. }
6.  
7. }

حال نیاز داریم تا متغیری از جنس int در برنامه خود با مقدار Value اولیه ایجاد کنیم تا بتوانیم به وسیله آن دستورات if را اجرا کنیم. برای همین منظور کد فوق را به صورت زیر تکمیل می کنیم:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6. }
7.  
8. }

متغیر ما تحت عنوان waterAmount به معنی مقدار آب می باشد که Value آن معادل با 11 است(می توانیم به طور فرضی واحد آب را لیتر یا بطری در نظر بگیریم). حال در این مرحله از برنامه نویسی با استفاده از جملات شرطی if می خواهیم مقدار آب را با شرایطی که در نظر می گیریم مقایسه کرده و با توجه به نتیجه به دست آمده چیزی مرتبط را در بخش Console محیط برنامه نویسی اکلیپس چاپ کنیم. اکنون کد خود را به شکل زیر تکمیل می کنیم:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6.  
7. if(){
8.  
9. }
10. }
11. }

به منظور استفاده از دستورات if می بایست همانطور که در کد بالا مشاهده می شود از ساختار if(){} استفاده کنیم به این صورت که شرط خود را داخل پرانتزها نوشته و دستوری که می بایست در صورت true بودن شرط if اجرا گردد را داخل دو علامت {} قرار می دهیم. در حقیقت ما در این برنامه خود می خواهیم به کامپیوتر دستور دهیم که اگر تعداد بطری های آب از 20 عدد کمتر بود، جمله ای مبنی بر اینکه بایستی آب خریداری شود در بخش Console نمایش داده شود. برای همین منظور به صورت زیر کد خود را تکمیل می کنیم:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6.  
7. if (waterAmount < 20) {
8. System.out.println("Go and buy some water!");
9. }
10. }
11. }

در کد فوق waterAmount < 20 نشانگر این مطلب است که اگر Value متغیر waterAmount از عدد 20 کمتر بود دستور زیر که حاکی از نمایش جمله Go and buy some water! به معنی برو و مقداری آب بخر! روی صفحه مانیتور می باشد.(علامت < به معنی کمتر از می باشد). برنامه ما پس از اجرا به صورت زیر مشاهده خواهد شد:

حال اگر عدد 20 را به عدد 7 تغییر دهیم مشاهده خواهیم کرد که در بخش Console هیچ چیزی نمایش داده نخواهد شد چرا که جواب شرط waterAmount < 7 به صورت false است زیرا مقدار اولیه که برای مقدار آب در نظر گرفته شده است معادل با 11 می باشد و از آنجا که 11 از 7 بزرگتر است پس جواب شرط ما true نخواهد شد که دستور داخل { } اجرا شود. حال زمان هایی برای ما پیش خواهد آمد که نیاز داریم تا مقدار یک متغیر را به گونه ای بسنجیم که ببینیم آیا کمتر از یا مساوی با یک مقدار خاصی است یا خیر که برای این منظور از علامت <= استفاده می کنیم. در واقع اگر بخواهیم ببینیم که آیا تعداد بطری های آب موجود کمتر از 11 یا مساوی با 11 است یا خیر کد خود را به شکل زیر بازنویسی می کنیم:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6.  
7. if (waterAmount <= 11) {
8. System.out.println("Go and buy some water!");
9. }
10. }
11. }

در پرانتز مقابل if دیده می شود که waterAmount <= 11 نوشته شده است به این معنی که اگر تعداد بطری های آب موجود کمتر از 11 بطری بود دستور داخل { } را نمایش بده و اگر تعداد بطری های آب برابر با 11 هم بود باز هم جمله برو و مقداری آب بخر! را روی صفحه مانیتور نمایش بده. با اجرای برنامه فوق ما مجدداً می بینیم که جمله شرطی در بخش Console به نمایش در می آید چرا که شرطی که ما معین کرده ایم true است. حال ممکن است بخواهیم شرطی را در برنامه خود تعیین کنیم مبنی بر اینکه اگر تعداد بطری های آب دقیقاً معادل با 11 بود جمله We do not need water! به معنی ما به آب نیاز نداریم! را در بخش Console نمایش دهد. برای این منظور خیلی از برنامه نویسان مبتدی جاوا ممکن است که کد فوق را به صورت زیر بازنویسی کنند:

به محض اینکه ما کد خود را به صورت فوق بازنویسی کنیم، مشاهده خواهیم کرد که اکلیپس از ما ایراد خواهد گرفت و دور عبارت waterAmount = 11 خط چین قرار می دهد. این بدان معنا است که برنامه ما دچار مشکل است. در واقع در زبان برنامه نویسی جاوا بر خلاف قوانین ریاضیاتی علامت = نشانگر برابر بودن نبوده و صرفاً جهت اختصاص دادن مقادیر به متغیرها مورد استفاده قرار می گیرد. به طور مثال اگر بخواهیم مقدار 11 را به متغیری از جنس int تحت عنوان waterAmount اختصاص دهیم از علامت = استفاده می کنیم. حال اگر بخواهیم در زبان برنامه نویسی جاوا برابر بودن را نشان دهیم می بایست از دو علامت مساوی پشت سر هم به صورت = = استفاده کنیم. اکنون با دانستن این نکته کد فوق را می توانیم به شکل زیر بازنویسی کنیم و مشاهده می کنیم که کلیه خطاهای برنامه رفع خواهند شد:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6.  
7. if (waterAmount == 11) {
8. System.out.println("We don not need water!");
9. }
10. }
11. }

در این مرحله پس از اجرای برنامه، شرطی که ما در برنامه خود قرار داده ایم می سنجد که آیا مقدار بطری های آب آیا دقیقاً برابر با 11 است یا خیر، اگر پاسخ true بود جمله We do not need water! نمایش داده خواهد شد:

حال اگر مقدار متغیر waterAmount که در بخش بالای کد خود تعریف کردیم را به عددی به غیر از عدد 11 تغییر دهیم(خواه این عدد کمتر از 11 باشد خواه بیشتر) جواب شرط ما false خواهد شد و چیزی در بخش Console به نمایش در نخواهد آمد. علاوه بر علامت = = علامت دیگری نیز وجود دارد که در برنامه نوسی جاوا و اندروید به کرات مورد استفاده قرار می گیرد و آن هم != به معنی نابرابر با می باشد. به طور مثال اگر در برنامه خود بخواهیم یک Statement یا دستوری را اجرا کنیم مبنی بر اینکه اگر مقدار متغیر waterAmount معادل با 100 نبود جمله The no of water bottles in not 100! به معنی تعداد بطری های آب معدل با 100 نیست! کد خود را به صورت زیر بازنوسی می کنیم:

1. public class IfClass {
2.  
3. public static void main(String[] args) {
4.  
5. int waterAmount = 11;
6.  
7. if (waterAmount != 100) {
8. System.out.println("The no of water bottles is not 100!");
9. }
10. }
11. }

در حقیقت عبارت waterAmount != 100 می سنجد که آیا مقدار Value اختصاص داده شده به متغیر waterAmount معادل با 100 است یا خیر و چنانچه این مقدار معادل با 100 نباشد جواب شرط ما true خواهد بود چرا که در شرط خود قید کرده ایم waterAmount != 100 به معنی اگر مقدار متغیر waterAmount مخالف با 100 باشد که در این صورت جواب این شرط true است چرا که مقدار متغیر ما معادل با 11 است از این رو جمله داخل دو علامت " " در بخش Console به نمایش در خواهد آمد و چیزی همچون تصویر زیر مشاهده خواهیم کرد:

همانطور که در تصویر فوق مشاهده می شود عبارت The no of water bottles is not 100! به معنی تعداد بطری های آب صد عدد نیست! نمایش داده می شود. به منظور اینکه بخواهیم شرطی قرار دهیم مبنی بر اینکه مقدار متغیری بیشتر از، بیشتر و یا معادل با مقدار خاصی باشد به ترتیب از > و >= نیز استفاده می کنیم. نکته ای که حتماً می بایست به خاطر داشته باشیم این است که به منظور مقایسه کردن string ها همانطور که قبلاً آموزش داده شد می بایست از متد equals() استفاده کرد و به هیچ وجه نمی توان از علائم < > و غیره استفاده کرد. در حقیقت زمان هایی در برنامه نویسی رخ می دهد که ما تمایل داریم که اگر جواب به شرطtrue بود دستوری انجام شود و اگر جواب false بود کار دیگری انجام شود که این کار را به سهولت با ادغام دستورات if و else می تواند انجام داد که در جلسه آتی با این مسئله در عبارت شرطی آشنا خواهیم شد.

برای شروع این آموزش نیاز داریم تا پروژه ای تحت عنوان 16th Session به معنی "جلسه شانزدهم" ایجاد کرده سپس کلاسی با نام NestedIfStatement در آن ایجاد کنیم(در واقع هدف از انتخاب این نام صرفاً مرتبط بودن با موضوع آموزش است). حال برای درک بهتر موضوع آموزش این بخش نیاز به یک سناریو داریم".

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

برای این منظور نیاز داریم تا دو متغیر یکی برای IQ و دیگری برای معدل ترم قبل ایجاد کنیم ولی از آنجا که ممکن است مقادیر این متغیرها رند نباشند از متغیری از جنس double استفاده می کنیم که می تواند اعداد اعشاری را در خود جای دهد(لازم به ذکر است که از متغیری از جنس float هم می توان برای اعداد اعشاری استفاده کرد اما نکته اینجا است که دقت متغیر double بیشتر است). برای شروع کار کدی به شکل زیر خواهیم داشت:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. double intelligenceQuotient = 100;
4. double termMean = 17.3;
5. }
6. }

در کد فوق متغیر اول تحت عنوان intelligenceQuotient دارای مقدار 100 بوده و متغیر دوم تحت عنوان termMean دارای مقداری معادل با 17.3 می باشد(در حقیقت واژه IQ مخفف واژگان Intelligence Quotient به معنی "میزان هوش" بوده و نام termMean از واژگان term به معنی "ترم" و mean به معنی "میانگین" می باشد). حال کد خود را به شکل زیر تکمیل می کنیم:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. double intelligenceQuotient = 100;
4. double termMean = 17.3;
5. if (intelligenceQuotient > 110 && termMean > 18) {
6. System.out.println("You have 30 percent discount.");
7. } else if (intelligenceQuotient > 100 && termMean > 17) {
8. System.out.println("You have 20 percent discount.");
9. } else {
10. System.out.println("You have no discount.");
11. }
12. }
13. }

در کد فوق چند نکته جدید وجود دارد که به تفصیل مورد بررسی قرار خواهند گرفت. در واقع جمله شرطی که برای اولین if نوشته شده است حاوی علامت && می باشد که به معنای "و" می باشد (این علامت مابین برنامه نویسان تحت عنوان Ampersand شناخته می شود). به طور خلاصه ما در این شرط دستور می دهیم که اگر IQ بیش از 110 بود "و" میانگین ترمی بیش از 18 بود دستور System.out.println(“You have 30 percent discount.”) که به معنای "شما 30 درصد تخفیف دارید" اجرا گردد.

حال به بررسی دومین نکته جدید در کد فوق می رسیم که عبارت است از else if که به طور خلاصه به معنای "و یا اینکه اگر" می باشد. شرطی که برای else if در نظر گرفته شده است حاکی از آن است که اگر IQ بیش از 100 بود "و" میانگین ترمی بیش از 17 بود دستور System.out.println(“You have 20 percent discount.”) که به معنای "شما 20 درصد تخفیف دارید" اجرا گردد.

نکته ای که در اینجا می بایست مد نظر قرار داده شود این است که ما به هر تعداد که نیاز داشته باشیم می توانیم از شروط else if در برنامه خود استفاده کنیم. حال در نهایت یک شرط else قرار می دهیم مبنی بر اینکه اگر کلیه شروط فوق چه از if گرفته چه از هر تعداد else if که داشته باشیم که دارای جواب false باشند، دستور قرار گرفته در else اجرا خواهد شد که در مثال فوق معادل با System.out.println(“You have no discount.”) به معنای "به شما هیچ تخفیفی تعلق نمی گیرد" می باشد. حال اگر کد فوق را اجرا کنیم با نتیجه ای مشابه تصویر زیر رو به رو خواهیم شد:

در واقع از آنجا که میزان IQ معادل با 100 است و میزان معدل معادل با 17.3 است مسلماً دستور شرط if که اجرا نخواهد شد چرا که در شرط آمده است که میزان IQ بیش از 110 باشد و میزان معدل بالای 18 باشد. از سوی دیگر دستور شرط else if هم دارای جواب false خواهد بود چرا که میزان IQ در نظر گرفته شده بیش از 100 است و این در صورتی است که میزان IQ در متغیر ما خود عدد 100 است و دیگر اینکه میزان معدل بالای 17 در نظر گرفته شده است.(اگر چه که شرط در مورد معدل دارای جواب true است، اما از آنجا که ما در شرط خود قید کرده ایم که هم جواب شرط IQ "و" هم جواب شرط معدل بایستی true باشد پس این شرط در کل false خواهد شد). در نهایت وقتی جواب به شروط if و else if معادل با false باشد برنامه به سراغ آخرین گزینه که else می باشد می رود و هر دستوری که در آن باشد را اجرا خواهد کرد. حال با تغییر مقادیر متغیرهای این برنامه خواهیم توانست کلیه شروط برنامه را مورد بررسی قرار دهیم.

یکی از نکات جدیدی که در این آموزش مورد بررسی قرار گرفت استفاده از علامت && به معنای "و" در داخل شرط بود. حال زمانی را تصور کنیم که روسای دانشگاه تصمیم گرفته اند تا کمی در مورد سیاست تخفیف شهریه سهل گیرتر عمل کنند و برای همین منظور گفته اند که اگر کسی بخواهد که 30 درصد تخفیف بگیرد یا بایستی دارای IQ بیش از 110 باشد و یا دارای معدل بیش از 18 باشد. از سوی دیگر کسانیکه بخواهند 20 درصد تخفیف شامل ایشان شود می بایست یا دارای IQ بیش از 100 باشند و یا معدل ایشان بیش از 17 باشد. در نهایت کسانیکه هیچ یک از این چهار حالت شامل حال ایشان نشود هیچ گونه تخفیف شهریه ای نخواهند گرفت. در این صورت می بایست کد خود را به شکل زیر بازنویسی کنیم:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. double intelligenceQuotient = 100;
4. double termMean = 17.3;
5. if (intelligenceQuotient > 110 || termMean > 18) {
6. System.out.println("You have 30 percent discount.");
7. } else if (intelligenceQuotient > 100 || termMean > 17) {
8. System.out.println("You have 20 percent discount.");
9. } else {
10. System.out.println("You have no discount.");
11. }
12. }
13. }

در کد فوق تنها بخشی که بازنویسی شده است استفاده از علامت || به جای علامت && داخل شروط if و else if می باشد. به عبارت دیگر علامت || که از فشردن هم زمان دو بار کلید Shift و دکمه ای که بالای دکمه Enter در کیبوردهای استاندارد قرار دارد ایجاد می شود به معنای "یا" می باشد. حال دانشجویی که در کد پیشین هیچ گونه تخفیفی شامل حالش نمی شد، در این برنامه جدید 20 درصد تخفیف خواهد گرفت چرا که یکی از دو شرط else if شامل حال وی می شود(به عبارت دیگر از آنجا که معدل ایشان معادل با 17.3 است شرط معدل که می بایست بالای 17 باشد در مورد ایشان صدق کرده و بالتبع دستور شرط else if برای ایشان که همان 20 درصد تخفیف است اجرا خواهد شد). نتیجه برنامه جدید همانند نتیجه ای است که در تصویر زیر مشاهده می شود:

در قسمت پایانی این آموزش به توضیح Nested If Statement ها می رسیم. به طور خیلی ساده می توان گفت که Nested If Statement ها به شرط های if گفته می شود که داخل یک شرط if دیگر قرار می گیرند. حال برای توضیح Nested If Statement ها کد فوق را به صورت زیر تغییر می دهیم:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. int age = 30;
4.  
5. }
6. }

در کد فوق یک متغیر از جنس int تحت عنوان age به معنای "سن" داریم که Value اختصاص داده شده به آن معادل با 30 است. حال می خواهیم شرطی قرار دهیم مبنی بر اینکه اگر مقدار متغیر ما بیش از 40 بود دستوری اجرا شود مبنی بر اینکه جمله You are older than 40. به معنای "شما بیش از 40 سال سن دارید" در بخش Console نمایش داده شود و در غیر این صورت جمله You are not older than 40. به معنای "شما بیش از 40 سال سن ندارید" نمایش داده شود. برای همین منظور کد خود را به شکل زیر تکمیل می کنیم:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. int age = 30;
4. if (age > 40) {
5. System.out.println("You are older than 40.");
6. } else {
7. System.out.println("You are not older than 40.");
8. }
9. }
10. }

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

از آنجا که مقدار متغیر age معادل با 30 تعریف شده است و در شرط خود قرار داده ایم age > 40 پس جواب به این شرط false بوده و در نهایت دستور قرار گرفته در else اجرا می شود. حال می خواهیم تا یک شرط دیگر را داخل شرط اصلی بگنجانیم مبنی بر اینکه ببینیم با اینکه شما بیش از 40 سال سن ندارید آیا زیر 20 سال می باشید یا بالای 20 سال. از این رو کد خود را به شکل زیر تکمیل می کنیم:

1. public class NestedIfStatement {
2. public static void main(String[] args) {
3. int age = 30;
4. if (age > 40) {
5. System.out.println("You are older than 40.");
6. } else {
7. System.out.println("You are not older than 40.");
8. if (age < 20) {
9. System.out.println("You are under 20.");
10. } else {
11. System.out.println("You are over 20.");
12. }
13. }
14. }
15. }

در صورت false بودن شرط if که درکد فوق مشاهده می شود، در بخش else دستوری آمده است که جمله You are not older than 40. را نشان خواهد داد. حال بلافاصله یک دستور شرطی دیگر پس از else قرار گرفته مبنی بر اینکه حالا که شما بیش از 40 سال سن ندارید می خواهیم ببینیم که سن شما زیر 20 سال است یا بالای 20 سال. به همین خاطر در شرط مقابل if دوم برنامه می نویسیم age < 20 که اگر جواب به آن true باشد جمله You are under 20. به معنای "شما زیر 20 سال سن دارید" نمایش داده خواهد شد و در غیر این صورت دستور else دوم که You are over 20. که به معنای "شما بیش از 20 سال سن دارید" می باشد اجرا خواهد شد. پس از اجرای برنامه نتیجه زیر مشاهده خواهد شد:

به طور خلاصه در شرط اول مشخص می شود که "سن شما بیش از 40 سال نیست" و در if دومی که داخل if اصلی قرار گرفته است مشخص می شود که "شما بیش از 20 سال سن دارید". همانطور که در آموزش دوازدهم گفتیم، به منظور درک بهتر متدهای boolean کلاس Scanner نیاز به آشنایی با دستورات if داریم. حال که به دستورات if تسلط پیدا کرده ایم، خواهیم توانست تا در قالب پروژه ای این متدها را مورد بررسی قرار دهیم. در حقیقت در آموزش آتی پروژه ای به این صورت تعریف می کنیم که کاربر می بایست برای ورود به حساب کاربری خود یک رمز عبور وارد کند. حال برنامه ما می سنجد که آیا این عدد از جنس یک عدد صحیح است یا خیر اگر عدد صحیح است آیا با رمز برنامه نیز خوانی دارد یا خیر که در صورت true بودن هر دو شرط کاربر خواهد توانست وارد حساب کاربری خود شود.