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

 
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۴۷: نحوه به کارگیری از کلید واژه static در متغیرها در پروژه باشگاه و


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

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

فرض کنیم که در یک باشگاه بدنسازی(مخصوص برنامه نویسان آقا) یا یک باشگاه ایروبیک(مخصوص برنامه نویسان خانم) ورزش می کنیم. از آنجا که مدیر این باشگاه می داند که ما یک برنامه نویس هستیم از ما می خواهد که یک برنامه ثبت نام برای برای باشگاه ورزشی بنویسم. ما هم از این پیشنهاد استقبال کرده و نرم افزار اکلیپس را باز می کنیم!

برای این منظور یک پروژه جدید در محیط اکلیپس تحت عنوان 47th Session ایجاد کرده و کلاسی به نام Athlete به معنی "ورزشکار" در آن ایجاد می کنیم (به خاطر داشته باشیم که برای این کلاس نمی بایست گزینه public static void main را در حین ساخت این کلاس تیک دار نماییم.)

کد ما می بایست به شکل زیر باشد:

  1. public class Athlete {
  2.  
  3. }

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

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. int registrationNumber;
  6. }

همانطور که در کد فوق ملاحظه می شود، دو شیئ از روی کلاس String تحت عناوین name و lastName به معنی به ترتیب "نام" و "نام خانوادگی" ایجاد کرده سپس یک متغیر از جنس عدد صحیح تحت عنوان dateOfBirth به معنی "تاریخ تولد" و یک متغیر دیگر هم از همان نوع تحت عنوان registrationNumber به معنی "شماره عضویت" ایجاد کرده ایم. اکنون ما به هر تعداد ورزشکار که داشته باشیم به همان تعداد می بایست شیئی از روی این کلاس برای آنها ایجاد کنیم و این در حالی خواهد بود که هر کدام از آن شیئ ها دارای name و lastName و dateOfBirth و registrationNumber مخصوص به خود خواهد بود که جایی در حافظه سیستم ذخیره خواهند شد. زمانیکه یک ورزشکار جدید در باشگاه ثبت نام می کند مسلماً دارای نام، نام خانوادگی و تاریخ تولد مختص به خود است اما این در حالی است که شماره عضویت ایشان به هیچ وجه تحت کنترل وی نبوده و به طور مثال نمی تواند برای خود شماره عضویت 7 را در نظر بگیرد. برای این منظور روشی که از آن طریق می توان چنین محدودیتی را ایجاد کرد استفاده از کلید واژه static برای متغیر registrationNumber است. به عبارت دیگر با قرار دادن کلید واژه static پیش از نام یک متغیر این امکان را فراهم خواهیم ساخت که متغیر مد نظر را به متغیری تبدیل کنیم که در همه شیئ های ساخته شده از روی کلاسی که حاوی آن متغیر هستند ثابت باشد. در زبان جاوا به چنین متغیرهایی Static Field گفته می شود. در واقع این دسته از متغیرها مرتبط با شیئ ساخته شده از روی کلاس نبوده بلکه مستقیماً مرتبط با خود کلاس هستند که جای ثابتی را در حافظه سیستم به خود اختصاص می دهند. برای ایجاد چنین محدودیتی کد فوق را به شکل زیر تکمیل می کنیم:

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. static int registrationNumber;
  6. }

همانطور که در کد فوق ملاحظه می شود پیش از کلید واژه int کلید واژه static را نوشته ایم. همانطور که در ادامه آموزش خواهیم دید، بخشی از برنامه ما این مسئولیت را خواهد داشت که برای اولین نفر ثبت نامی عدد 1 و برای دهمین نفر ثبت نامی عدد 10 را در نظر خواهد گرفت. برای این منظور کد فوق را به شکل زیر تکمیل می کنیم:

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. static int registrationNumber = 0;
  6. }

همانطور که در کد فوق ملاحظه می شود مقدار اولیه برای متغیری که از جنس static است معادل با 0 قرار داده شده است و علت این مسئله هم آن است که در حال حاضر هیچ کسی عضو باشگاه نیست. برای ادامه کار نیاز است تا یک Constructor از روی کلاس خود ایجاد کنیم(برای مطالعه بیشتر پیرامون مفهوم Constructor به آموزش چهل و یکم مراجعه نمایید):

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. static int registrationNumber = 0;
  6.  
  7. public Athlete(String nameOfAthlete, String lastNameOfAthlete,
  8. int dateOfBirthOfAthlete) {
  9. name = nameOfAthlete;
  10. lastName = lastNameOfAthlete;
  11. dateOfBirth = dateOfBirthOfAthlete;
  12. registrationNumber++;
  13. }
  14. }

همانظور که در کد فوق مشاهده می شود یک Constructor ایجاد کرده و برای آن سه پارامتر ورودی تحت عناوین nameOfAthlete و lastNameOfAthlete و dateOfBirthOfAthelte به ترتیب به معانی " نام ورزشکار" و "نام خانوادگی ورزشکار" و "تاریخ تولد ورزشکار" در نظر گرفته ایم. سپس در ادامه کد مربوط به این Constructor مقدار Field خود تحت عنوان name را برابر با nameOfAthlete و مقدار lastName را برابر با lastNameOfAthlete و در نهایت مقدار dateOfBirth را معادل با dateOfBirthOfAthelte قرار داده ایم. به عبارت دیگر کلیه مقادیر مرتبط با پارامترهای شیئ های ساخته شده از روی این کلاس به Field ها یا همان متغیرهای مرتبط با آنها انتقال خواهد یافت. در نهایت با اضافه کردن registrationNumber++ این دستور را به برنامه می دهیم که در هر بار ساخته شدن یک شیئ جدید از روی این کلاس یک واحد به مقدار اولیه این متغیر اضافه کند. در ادامه نیاز داریم تا متدی تعریف کنیم که اطلاعات هر ورزشکار را روی صفحه نمایش دهد. برای این منظور کد فوق را به شکل زیر تکمیل می کنیم:

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. static int registrationNumber = 0;
  6.  
  7. public Athlete(String nameOfAthlete, String lastNameOfAthlete,
  8. int dateOfBirthOfAthlete) {
  9. name = nameOfAthlete;
  10. lastName = lastNameOfAthlete;
  11. dateOfBirth = dateOfBirthOfAthlete;
  12. registrationNumber++;
  13. }
  14. public void showAthleteInfo() {
  15. System.out.println("Your name is " + name);
  16. System.out.println("Your last name is " + lastName);
  17. System.out.println("Your date of birth is " + dateOfBirth);
  18. System.out.println("Your registration No is "
  19. + registrationNumber);
  20.  
  21. }
  22. }
  23.  
  24.  

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

چهارشنبه 2 بهمن 1392  12:15 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۴۸: نحوه به کارگیری از کلید واژه static در متدها


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

برای ادامه آموزش، پروژه ای که در قسمت پیش تحت عنوان 47th Session ایجاد کردیم را مد نظر قرار می دهیم. حال کلاس دیگری تحت عنوان ActionClass به معنی "کلاس عملیاتی" ایجاد کنیم و خاطرمان باشد که در حین ساخت آن حتماً گزینه public static void main را تیک دار می کنیم چرا که همانطور که قبلاً آموزش داده شد هرکجا که متد main قرار گیرد به منزله نقطه شروع برنامه ما خواهد بود و ما هم نیاز داریم تا برنامه خود را از داخل این کلاس آغاز کنیم:

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

لازم به ذکر است که برای سهولت کار می توان کامنت های فوق را حذف کرد. اکنون در بخش متد main می خواهیم یک شیئ از روی کلاس Athlete ایجاد کنیم. برای این منظور کد فوق را به شکل زیر تکمیل می کنیم:

920720-j48-IMAGE 1.jpg

همانطور که در تصویر فوق مشاهده می شود برای ساخت یک شیئ جدید از روی کلاس Athlete اول واژه Athlete را نوشته سپس نامی برای آن در نظر می گیریم که در اینجا نام personOne به معنی "نفر اول" را در نظر گرفته ایم. سپس یک علامت مساوی قرار داده و کلید واژه new را می نویسیم و پس از قرار دادن یک فاصله مجدد نامی کلاسی که می خواهیم از روی آن یک شیئ ایجاد کنیم را می نویسیم. همانطور که در تصویر فوق مشاهده می شود انتهای واژه Athlete با یک فلش قرمز رنگ مشخص شده است. در واقع با قرار دادن نشانگر موس خود در آن نقطه و فشردن هم زمان کلید های Ctrl و Space با تصویر زیر مواجه خواهیم شد:

920720-j48-IMAGE 2.jpg

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

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. }
  5. }

در حقیقت از آنجا که جنس دو پارامتر اول String است از اینرو مقدار آنها را می بایست داخل دو علامت " " قرار داد و از آنجا که جنس پارامتر سوم int است می بایست یک عدد صحیح برای آن در نظر گرفت که در مثال فوق عدد 1362 برای آن در نظر گرفته شده است. اکنون نیاز داریم تا به متد قرار گرفته در کلاس Athlete دست پیدا کنیم. برای این منظور کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. personOne.showAthleteInfo();
  5. }
  6. }

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

920720-j48-IMAGE 3.jpg

می بینیم که پارامترهای در نظر گرفته شده به نمایش درآمده اما مسئله ای که جالب توجه است این است که شماره عضویت 1 برای Behzad در نظر گرفته شده است و علت آن هم این است که ما مقدار اولیه شماره عضویت را برابر با 0 قرار دادیم و این دستور را به Constructor برنامه دادیم که برای هر شیئ ساخته شده از روی کلاس آن یک واحد به مقدار اولیه اضافه کند و از همین رو است که عدد 1 در اجرای فوق در نظر گرفته شده است. حال دو شیئ دیگر از روی کلاس Athlete می سازیم:

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. personOne.showAthleteInfo();
  5.  
  6. Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
  7. personTwo.showAthleteInfo();
  8.  
  9. Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
  10. personThree.showAthleteInfo();
  11. }
  12. }

همانطور که مشاهده می شود دو شیئ دیگر تحت عناوین personTwo و personThree به معنی به ترتیب "نفر دوم" و "نفر سوم" ایجاد کرده ایم. حال مجدد برنامه را اجرا می کنیم:

920720-j48-IMAGE 4.jpg

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

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. personOne.showAthleteInfo();
  5.  
  6. // Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
  7. // personTwo.showAthleteInfo();
  8.  
  9. Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
  10. personThree.showAthleteInfo();
  11.  
  12. }
  13. }

اکنون مجدد برنامه را اجرا می کنیم:

920720-j48-IMAGE 5.jpg

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

  1. static int registrationNumber = 100;

اکنون مجدد برنامه را اجرا می کنیم:

920720-j48-IMAGE 6.jpg

می بینیم که از آنجا که Field مرتبط با شماره عضویت از جنس static است هر تغییری که در آن ایجاد کنیم در کلیه کلاس های ساخته شده از روی آن کلاس اعمال خواهد شد. علاوه بر استفاده کلید واژه static به همراه متغیرها، در زبان برنامه نویسی جاوا این امکان را داریم تا متدها را نیز static سازیم. برای درک بهتر این موضوع مجدد به کلاس Athlete رجوع می کنیم:

  1. public class Athlete {
  2. String name;
  3. String lastName;
  4. int dateOfBirth;
  5. static int registrationNumber = 0;
  6.  
  7. public Athlete(String nameOfAthlete, String lastNameOfAthlete,
  8. int dateOfBirthOfAthlete) {
  9. name = nameOfAthlete;
  10. lastName = lastNameOfAthlete;
  11. dateOfBirth = dateOfBirthOfAthlete;
  12. registrationNumber++;
  13. }
  14.  
  15. public void showAthleteInfo() {
  16. System.out.println("Your name is " + name);
  17. System.out.println("Your last name is " + lastName);
  18. System.out.println("Your date of birth is " + dateOfBirth);
  19. System.out.println("Your registration No is " + registrationNumber);
  20. }
  21.  
  22. public static int showAllAthletes() {
  23. return registrationNumber;
  24. }
  25.  
  26. }

همانطور که در کد فوق ملاحظه می شود در انتهای کد اقدام به ساخت یک متد جدید تحت عنوان showAllAtheltes به معنی "همه ورزشکاران را نشان بده" نموده ایم. از آنجا که قرار است این متد یک عدد به ما نشان دهد، از این رو آن را از جنس int قرار می دهیم. زمانیکه ما در ساخت یک متد از کلید واژه void استفاده نمی کنیم به بدان معنا است که این متد همواره داده ای را return خواهد کرد پس می بایست کلید واژه return را نوشته و چیزی که قصد داریم این متد بازگرداند را مقابل آن قرار می دهیم. در این مثال می خواهیم این متد همواره تعداد کل ثبت نامی ها را به مدیر باشگاه نشان دهد پس می بایست نام متغیر registrationNumber را مقابل آن بنویسیم. اکنون مجدد به کلاس ActionClass باز می گردیم. از آنجا که می خواهیم پس از به نمایش در آمدن اطلاعات کلیه شیئ های ساخته شده از روی کلاس Athlete در پنجره Console عبارت The number of all registrations is به معنی "تعداد کل ثبت نامی ها معادل است با" روی صفحه به نمایش درآید، از این رو کد خود را به شکل زیر تکمیل می کنیم:

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. personOne.showAthleteInfo();
  5.  
  6. Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
  7. personTwo.showAthleteInfo();
  8.  
  9. Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
  10. personThree.showAthleteInfo();
  11.  
  12. System.out.println("The number of all registrations is "
  13. + personOne.showAllAthletes());
  14.  
  15. }
  16. }

همانطور که در بخش آخر کد مشاهده می کنیم، عبارت مد نظر را داخل دستور System.out.println داخل دو علامت " " نوشته پس از آن یک علامت + قرار داده و در نهایت نام یکی از شیئ های ساخته شده از کلاس Athlete را می نویسیم که در این مثال مورد اول که personOne نام داشت را مد نظر قرار داده ایم. پس از نوشتن نام شیئ و قرار دادن یک نقطه حال به کلیه متدهای موجود در کلاس اصلی دسترسی خواهیم داشت. از اینرو نام متد showAllAthletes() را می نویسیم. حال برنامه را مجدد اجرا می کنیم:

920720-j48-IMAGE 7.jpg

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

  1. System.out.println("The number of all registrations is "
  2. + personTwo.showAllAthletes());

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

920720-j48-IMAGE 8.jpg

باز هم می بینیم که حاصل متدی که از جنس static بود جدای از شیئ مرتبط با آن یکی است و این همان خاصیت کلید واژه static است که این امکان را به ما داده است تا متد showAllAthletes را در میان همه شیئ ها اصطلاحاً Share کنیم یا "به اشتراک" بگذاریم. حال برای آنکه مجدد برنامه خود را تست کنیم از قصد یکی از شیئ های ساخته شده خود مثلاً شیئ سوم خود را مجدد کامنت می کنیم:

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
  4. personOne.showAthleteInfo();
  5.  
  6. Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
  7. personTwo.showAthleteInfo();
  8.  
  9. // Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
  10. // personThree.showAthleteInfo();
  11.  
  12. System.out.println("The number of all registrations is "
  13. + personOne.showAllAthletes());
  14.  
  15. }
  16. }

اکنون برنامه را اجرا می کنیم:

920720-j48-IMAGE 9.jpg

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

چهارشنبه 2 بهمن 1392  12:18 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۴۹: آشنایی با کلید واژه final


پس از آشنایی با کلید واژه static در دو آموزش پیشین، در این آموزش قصد داریم تا کلید واژه final را مورد بررسی قرار دهیم.

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

مورد اول استفاده از این کلید واژه برای کلاس ها است. در واقع زمانیکه یک کلاس را final کنیم دیگر امکان ایجاد Subclass از آن کلاس وجود نخواهد داشت.

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

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

مورد سوم استفاده از کلید واژه final در ارتباط با Local Variable ها، Instance Variable ها و پارامترها است. در حقیقت زمانیکه final را در کنار یک متغیری بنویسیم که دارای یک مقدار اولیه است، مقدار اولیه آن متغیر نهایی شده و دیگر به هیچ وجه امکان اختصاص یک مقدار جدید به آن را نخواهیم داشت.

حال به منظور درک بهتر مطالب تئوری فوق پروژه ای تحت عنوان 49th Session ایجاد کرده و کلاسی در آن تحت عنوان WhatIsFinal به معنی "کلید واژه final چیست؟" ایجاد می کنیم. به خاطر داشته باشیم که در حین ساخت این کلاس گزینه public static void main را تیک نزنیم چرا که این کلاس به منزله کلاس اجرایی ما نخواهد بود:


  1. public class WhatIsFinal {
  2.  
  3. }

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

  1. public class WhatIsFinal {
  2.  
  3. public void showData() {
  4. String name = "Behzad";
  5. String lastName = "Moradi";
  6. int dateOfBirth = 1362;
  7. System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
  8. }
  9. }

همانطور که در کد فوق ملاحظه می شود متدی تحت عنوان showData به معنی "اطلاعات را نشان بده" ایجاد کرده و دو کلاس String تحت عناوین name و lastName به ترتیب به معنی "نام" و "نام خانوادگی" در آن ایجاد کرده ایم و در نهایت یک متغیر از جنس int تحت عنوان dateOfBirth به معنی "تاریخ تولد" اضافه نموده ایم. اکنون برای اختصاص مقادیر به آنها می توانیم اطلاعات شخصی خود را در نظر بگیریم. سپس به منظور نمایش دادن این اطلاعات روی صفحه مانیتور از دستور System.out.println استفاده کرده به این صورت که اول name را نوشته سپس دستور \n را می نویسیم(کاری که این دستور انجام می دهد این است که ادامه اطلاعات را به خط بعد منتقل می کند). به همین منوال مابقی اسامی را هم داخل دستور System.out.println قرار می دهیم. حال کلاس دیگری تحت عنوان ActionClass به معنی "کلاس عملیاتی" ایجاد کرده و در حین ساخت آن گزینه public static void main را تیک دار می کنیم چرا که این کلاس قرار است به عنوان نقطه شروع برنامه ما باشد:

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

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

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. WhatIsFinal objectOne = new WhatIsFinal();
  4. objectOne.showData();
  5. }
  6. }

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

920722-j49-IMAGE 1.jpg

می بینیم که متد showData که وظیفه داشت اطلاعات ما را نشان دهد کار خود را به درستی انجام داد. حال نیاز است تا یک کلاس دیگر تحت عنوان Change به معنی "تغییر" ایجاد کنیم اما این در حالی است که این کلاس می بایست از کلاس WhatIsFinal ارث بری کند. برای این منظور کد خود را به شکل زیر تکمیل می کنیم(برای آشنایی بیشتر با مفهوم وراثت در زبان برنامه نویسی جاوا به آموزش های سی و دوم و سی سوم مراجعه نمایید):

  1. public class Change extends WhatIsFinal {
  2.  
  3. }
  4. }

همانطور که قبلاً توضیح داده شد به منظور ارث بری یک کلاس از کلاس دیگر می بایست پس از نام کلاس خود کلید واژه extends را نوشته سپس نام کلاسی را بنویسیم که می خواهیم از آن ارث بری کنیم. در ادامه کار خود نیاز داریم تا درکلاس Change متدی که قبلا ایجاد کرده بودیم را Override را رونویسی کنیم. برای این منظور کد فوق را به شکل زیر تکمیل می کنیم:

  1. public class Change extends WhatIsFinal {
  2. @Override
  3. public void showData() {
  4. String name = "Iman";
  5. String lastName = "Ahmadi";
  6. int dateOfBirth = 1364;
  7. System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
  8. }
  9. }

همانطور که در کد فوق ملاحظه می شود برای رونویسی یک متد نیاز است تا ابتدا دستور @Override را نوشته سپس نام متد خود را می نویسیم. تغییری که در این متد انجام داده ایم این است که مقادیر کلاس String و متغیر int را به مقادیر جدیدی تغییر داده ایم. حال مجدد به کلاس ActionClass بازگشته و یک شیئ جدید از روی کلاس Change ایجاد می کنیم:

  1. public class ActionClass {
  2. public static void main(String[] args) {
  3. WhatIsFinal objectOne = new WhatIsFinal();
  4. objectOne.showData();
  5. System.out.println();
  6. Change objectTwo = new Change();
  7. objectTwo.showData();
  8. }
  9. }

همانطور که در کد فوق مشاهده می شود پس از شیئ اولی که ساختیم دستور System.out.println را می نویسیم. در حقیقت این دستور هیچ تاثیری در روند اجرای برنامه ما نداشته و صرفا جهت خوانایی بیشتر خروجی برنامه اضافه شده است چرا که مابین خروجی شیئ اول و خروجی شیئ دوم یک خط فاصله ایجاد خواهد کرد. حال همانطور که شیئ اول را از روی کلاس WhatIsFinal ایجاد کردیم، اکنون یک شیئ جدید تحت عنوان objectTwo به معنی "شیئ دوم" از روی کلاس Change ایجاد می کنیم. حال مجدد برنامه را اجرا می کنیم:

920722-j49-IMAGE 2.jpg

می بینیم که هر دو شیئ ساخته شده در برنامه اجرا شده اند. اکنون می خواهیم تاثیر کلید واژه final را در روند اجرای برنامه تست کنیم. برای این منظور به کلاس WhatIsFinal بازگشته و آن را به صورت زیر تغییر می دهیم:

  1. public class WhatIsFinal {
  2. public final void showData() {
  3. String name = "Behzad";
  4. String lastName = "Moradi";
  5. int dateOfBirth = 1362;
  6. System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
  7. }
  8. }

همانطور که در کد فوق ملاحظه می شود در بخش نام متد پس از کلید واژه public کلید واژه final را نوشته ایم. به طور خلاصه final این معنی را اطلاق می کند که ما به هیچ وجه امکان ایجاد تغییری را در این متد نخواهیم داشت و به عبارت دیگر نمی توانیم این متد را Override کنیم. در واقع به محض آنکه فایل خود را Save کنیم با تصویر زیر مواجه خواهیم شد:

920722-j49-IMAGE 3.jpg

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

920722-j49-IMAGE 4.jpg

می بینیم که در این باکس زرد رنگ نوشته شده است که "ما نمی توانیم یک متد final که در کلاس WhatIsFianl قرار دارد را Override کنیم" و راه کاری هم که به ما پیشنهاد می شود این است که کلید واژه final را از کنار نام متد showData حذف کنیم که با انجام این کار مشکل برنامه ما هم رفع خواهد شد. اکنون اگر با وجود این ایراد در برنامه اقدام به اجرای آن نماییم با تصویر زیر رو به رو خواهیم شد:

920722-j49-IMAGE 5.jpg

در این پنجره اکلیپس به ما اخطار می دهد که در پروژه خود دارای مشکلی هستیم اما امکان ادامه کار را نیز باوجود این مشکل برای ما فراهم کرده است. در واقع با کلیک بر وری کلید Proceed می توانیم برنامه خود را Compile کنیم که در این صورت اجرای برنامه ما به این شکل خواهد بود:

920722-j49-IMAGE 6.jpg

می بینیم که شیئ ساخته شده اول ما به خوبی نمایش داده شده است اما شیئ دوم ما که در آن یک متد final را Override کرده بودیم با مشکل مواجه شده است.

چهارشنبه 2 بهمن 1392  12:19 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۵۰: معرفی Constant ها در زبان برنامه نویسی جاوا‎


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

برای شروع کار پروژه ای تحت عنوان 50th Session ایجاد کرده و کلاسی در آن به نام JavaConstants ایجاد می کنیم (به خاطر داشته باشیم که در حین ساخت این کلاس گزینه public static void main را تیک دار کنیم):


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

در دنیای واقعی همواره چیزهایی وجود دارند که مقادیر آنها ثابت است که از آن جمله می توان به تعداد ساعات یک روز اشاره کرد که همواره 24 ساعت است و یا تعداد اضلاع یک مربع را مد نظر قرار داد که هیچ وقت بیش از 4 ضلع نخواهد بود. در ادامه آموزش تعداد ساعات یک روز را مد نظر قرار داده و برنامه خود را بر اساس آن می نویسیم:

  1. public class JavaConstants {
  2. public static void main(String[] args) {
  3. int numberOfHoursInADay = 24;
  4. }
  5. }

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

  1. public class JavaConstants {
  2. public static void main(String[] args) {
  3. int numberOfHoursInADay = 24;
  4. System.out.println(numberOfHoursInADay);
  5. }
  6. }

به طور خلاصه با نوشتن دستور System.out.println و قرار دادن نام متغیر خود در آن این امکان را خواهیم داشت که مقدار اولیه متغیر خود را در پنجره Console به نمایش در آوریم:

920730-j50-IMAGE 1.jpg

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

  1. public class JavaConstants {
  2. public static void main(String[] args) {
  3. int numberOfHoursInADay = 24;
  4. numberOfHoursInADay = 25;
  5. System.out.println(numberOfHoursInADay);
  6. }
  7. }

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

920730-j50-IMAGE 2.jpg

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

  1. public class JavaConstants {
  2. public static void main(String[] args) {
  3. final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  4. System.out.println(NUMBER_OF_HOURS_IN_A_DAY);
  5. }
  6. }

در کد فوق دو تغییر عمده دیده می شود اول اینکه کلید واژه final را به متغیر خود اضافه کرده ایم که این تضمین را به ما خواهد داد که مقدار اختصاص داده شده به این متغیر هرگز تغییر نخواهد کرد، دوم آنکه نحوه نوشتن نام متغیر خود به صورت camelCase را تغییر داده و کلیه حروف را به صورت بزرگ نوشته و آنها را با یک _ از یکدیگر مجزا ساخته ایم (برای آشنایی بیشتر با مفهوم camelCase به آموزش دهم مراجعه نمایید). به خاطر داشته باشیم که نام متغیر خود داخل پرانتز در دستور System.out.println هم می بایست مطابق با نام جدید متغیر باشد. در این مرحله می توان گفت که ما موفق شده ایم که یک Constant در برنامه خود ایجاد کنیم. واژه انگلیسی Constant دارای معانی متعددی همچون ثابت، پایدار، دائمی، استوار و غیره است و به نظر می رسد طراحان زبان برنامه نویسی جاوا نام مناسبی برای متغیرهایی که همواره دارای مقدار ثابتی می باشند انتخاب کرده اند. از سوی دیگر علت تغییر در نوع نوشتن یک Constant نسبت به یک Variable در برنامه های جاوا این است که در برنامه خود بتوانیم به سادگی Constant ها را از Variable ها تشخیص دهیم و این یک سبک قراردادی در میان برنامه نویسان جاوا در سرتاسر جهان است اما این در حالی است که می توان برای Constant ها هم از همان سبک نامگذاری camelCase بدون هیچ مشکلی استفاده کرد. اکنون مجدد برنامه خود را اجرا می کنیم:

920730-j50-IMAGE 3.jpg

می بینیم که برنامه مثل قبل بدون هیچ مشکلی اجرا خواهد شد. اکنون برای آنکه ببینیم آیا می توان مقدار اولیه یک Constant و یا به عبارت دیگر یک متغیر از جنس final را تغییر داد یا خیر، کد خود را به صورت زیر بازنویسی می کنیم:

920730-j50-IMAGE 4.jpg

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

920730-j50-IMAGE 5.jpg

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

920730-j50-IMAGE 6.jpg

در این پنجره اکلیپس به ما اخطار می دهد که در پروژه خود دارای مشکلی هستیم اما امکان ادامه کار را نیز با وجود این مشکل برای ما فراهم کرده است. در واقع با کلیک بر وری کلید Proceed می توانیم برنامه خود را Compile کنیم که در این صورت اجرای برنامه ما به این شکل خواهد بود:

920730-j50-IMAGE 7.jpg

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

  1. public class JavaConstants {
  2. final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  3. }

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

  1. public class JavaConstants {
  2. public void showConstant() {
  3. final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  4. }
  5. }

از سوی دیگر اگر بخواهیم که Constant ما توسط دیگر بخش های برنامه قابل دسترسی باشد می توان از کلید واژه public در کنار آن استفاده کرد:

  1. public class JavaConstants {
  2. public final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  3. }

اگر بخواهیم Constant ما فقط محدود به کلاسی باشد که در آن Constant در آن قرار گرفته است می بایست از کلید واژه private استفاده کرد:

  1. public class JavaConstants {
  2. private final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  3. }

و در پایان اگر بخواهیم که Value این Constant با دیگر بخش های برنامه خود به اشتراک گذاشته شود به صورت زیر از کلید واژه static استفاده خواهیم کرد:

  1. public class JavaConstants {
  2. static final int NUMBER_OF_HOURS_IN_A_DAY = 24;
  3. }

برای آشنایی بیشتر با سطوح دسترسی در زبان برنامه نویسی جاوا به آموزش به آموزش سی و ششم و برای آشنایی بیشتر با کلید واژه static با آموزش های چهل و هفتم و چهل و هشتم مراجعه نمایید.

چهارشنبه 2 بهمن 1392  12:21 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۵۱: معرفی کلاس Thread در جاوا‎


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

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

 

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

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

حال پس از آشنایی با مفهوم Thread در برنامه نویسی لازم است این نکته را نیز متذکر شویم که انجام هم زمان چند کار در زبان برنامه نویسی جاوا اصطلاحاً Concurrency نامیده می شود (این واژه در زبان فارسی به "هم زمانی" و "تقارن" ترجمه می شود).


آشنایی با Interface ها

پیش از ادامه آموزش پیرامون ماهیت Thread ها نیاز به آشنایی با Interface ها در زبان برنامه نویسی جاوا داریم. واژه انگلیسی Interface به معنی "رابط" و "واسطه" می باشد. برای روشن شدن این مطلب مثالی ذکر می کنیم:

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

 

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

شباهت های Interface ها با Class ها را می توان در موارد زیر خلاصه کرد:

1. یک Interface به هر تعداد که بخواهد می توان متد داشته باشد.
2. نام فایلی که یک Interface در آن قرار دارد می بایست با نام مد نظر برای Interface یکی باشد و این در حالی است که پسوند فایل همانند کلاس ها java است. مثلا MyInterface.java

در زبان برنامه نویس جاوا Interface ها همانند کلاس ها می باشند اما این در حالی است که در موارد زیر با کلاس ها متفاوت می باشند:

1. یک کلاس فقط و فقط می تواند از یک کلاس دیگر وارثت داشته باشد اما این در حالی است که یک کلاس می تواند بیش از یک Interface را اجرا کند.
2. یک کلاس می تواند کلاس دیگر را extends کند اما این در حالی است که یک کلاس می تواند اقدام به implements کردن یک Interface کند (در ادامه آموزش بیشتر با کلید واژه implements آشنا خواهیم شد).
3. همانطور که در آموزش سی و هفتم توضیح داده شد، یک متد دارای Body و Signature است. کلاس ها می توانند حاوی متدهایی به همراه Body باشند اما این در حالی است که Interface ها فقط می توانند حاوای متدهایی با Signature آنها باشند. به عبارت دیگر متدهای قرار گرفته در Interface ها به صورت Abstract یا "انتزاعی" هستند.
4. بر خلاف کلاس ها، از روی Interface ها نمی توان Object یا شیئ ساخت.
5. به طور کلی Interface ها می توانند از روی دیگر Interface ها وارثت داشته باشند.
در آموزش آتی با نحوه ساخت یک Interface بیشتر آشنا خواهیم شد.

چهارشنبه 2 بهمن 1392  12:23 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا- قسمت ۵۲: نحوه ساخت یک Interface در جاوا


پس از آشنایی با مفهوم Interface در آموزش قبل، در این آموزش قصد داریم ببینیم به چه شکل می توان یک Interface ایجاد کرد. برای این منظور پروژه ای تحت عنوان 52nd Session ایجاد کرده و فایلی در آن تحت عنوان ProgrammerOne ایجاد می کنیم.

  1. public interface ProgrammerOne {
  2. public void designTheUI();
  3. }

همانطور که در کد فوق ملاحظه می شود برای ساخت یک Interface می بایست از کلید واژه interface استفاده کنیم. سپس بایستی یک نام برای آن انتخاب کنیم که در مثال فوق نام ProgrammerOne به معنی "برنامه نویس یک" انتخاب شده است (اگر به خاطر داشته باشیم در آموزش گذشته مثالی زدیم مبنی بر این که فرض کنیم که عضو یک تیم برنامه نویسی هستیم که در آن هر برنامه نویس وظیفه ای خاص دارد). کلید واژه public هم که پیش از کلید واژه interface قرار گرفته است حاکی از آن است که این Interface توسط هر کلاسی که در هر پکیجی قرار داشته باشد قابل استفاده است. لازم به ذکر است همانطور که در آموزش پیش توضیح داده شد نام فایلی که حاوی این Interface است می بایست با نام انتخابی ما یکی باشد بنابراین نام این Interface معادل با ProgrammerOne.java است. سپس همانند ساخت یک کلاس از دو علامت {} استفاده کرده و متدهایی که نیاز داشته باشیم را میان آن دو تعریف می کنیم. به طور مثال در کد فوق یک متد تحت عنوان designTheUI به معنی "طراحی کردن رابط گرافیکی کاربر" تعریف کرده ایم. اگر توجه کرده باشیم متدی که داخل Interface ایجاد کرده ایم بر خلاف متدهایی که داخل کلاس تعریف می کنیم دارای {} نیست و این مسئله از آنجا ناشی می شود که متدهای داخل یک Interface فقط دارای Signature هستند. به عبارت دیگر متدهای داخل Interface فقط به صورت انتزاعی تعریف می شوند سپس داخل کلاسی که قرار است آن Interface را اجرا کند وظایف متد را داخل دو علامت {} مرتبط با آن تعریف می کنیم. جالب است بدانیم کلیه متدهایی که داخل یک Interface ایجاد می شوند public خواهند بود بنابراین نوشتن یا ننوشتن این کلید واژه برای متدهای داخل یک Interface تفاوتی ایجاد نخواهد کرد. حال نیاز داریم کلاسی ایجاد کنیم که این وظیفه را دارا است تا Interface یی که ایجاد کرده ایم را "اجرا" کند. برای این منظور کلاسی تحت عنوان ActionClass به معنی "کلاس اجرایی" ایجاد می کنیم (به خاطر داشته باشیم که در حین ساخت این کلاس گزینه public static void main را تیک دار نماییم):

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

در زبان برنامه نویسی جاوا هر زمانیکه بخواهیم به یک کلاس دستور دهیم که یک Interface را اجرا کند می بایست از کلید واژه implements به معنی "اجرا کردن" استفاده نماییم. در واقع همانطور که از کلید واژه extends به منظور وراثت داشتن استفاده می کنیم، کلید واژه implements را نوشته سپس نام Interface را که تمایل داریم کلاس ما آن را اجرا کند را می نویسیم:

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

اکنون نیاز داریم تا متدی که به صورت انتزاعی در Interface خود ایجاد کردیم را فرا خوانده و وظیفه ای برای آن تعریف کنیم:

  1. public class ActionClass implements ProgrammerOne {
  2. @Override
  3. public void designTheUI() {
  4. System.out.println("Programmer one has to design the UI");
  5. }
  6.  
  7. public static void main(String[] args) {
  8.  
  9. }
  10. }

همانطور که در کد فوق ملاحظه می شود در داخل کلاس اصلی برنامه متدی تحت عنوان designTheUI را که داخل Interface خود ایجاد کرده ایم را فرا خوانده ایم. اگر توجه کرده باشیم ما داخل Interface فقط این متد را به صورت انتزاعی ایجاد کردیم و وظیفه ای برای آن تعریف نکردیم اما این در حالی است که داخل کلاس وظیفه آن را به صراحت مشخص می کنیم که حاکی از آن است که عبارت Programmer one had to design the UI به معنی "برنامه نویس شماره یک بایستی رابط گرافیکی را طراحی کند" را روی صفحه به نمایش در آورد. نکته ای که در اینجا حائز اهمیت است این است که پس از وارد کردن این متد داخل برنامه اکلیپس از ما ایراد خواهد گرفت که بایستی متد را Override کرد (برای آشنایی بیشتر با دستور Override به آموزش سی و سوم مراجعه نمایید). به طور خلاصه علت اجباری بودن Override این است که از ایجاد مشکلات احتمالی جلوگیری به عمل آید. حال کد خود را به صورت زیر تکمیل می کنیم:

  1. public class ActionClass implements ProgrammerOne {
  2. @Override
  3. public void designTheUI() {
  4. System.out.println("Programmer one has to design the UI");
  5. }
  6.  
  7. public static void main(String[] args) {
  8. ActionClass test = new ActionClass();
  9. test.designTheUI();
  10.  
  11. }
  12. }

در واقع برای آنکه برنامه ما اجرا شود نیاز داریم تا به تکمیل متد main بپردازیم زیرا همانطور که قبلاً توضیح داده شده است این متد به منزله نقطه شروع برنامه خواهد بود. کاری که در متد main انجام داده ایم این است که یک شیئ تحت عنوان test از روی کلاس ActionClass ایجاد کرده ایم. در واقع برای این منظور می بایست اول نام کلاس خود را نوشته سپس نامی برای آن در نظر بگیریم و یک علامت مساوی قرار می دهیم. حال از آنجا که می خواهیم یک شیئ جدید ایجاد کنیم می بایست کلید واژه new را بنویسیم و سپس مجدد نام کلاسی که می خواهیم از روی آن یک شیئ جدید ایجاد کنیم را خواهیم نوشت و یک علامت (); در انتها قرار می دهیم. از این پس به کلیه متدها، Interface ها و دیگر کلاس های مرتبط با این کلاس دسترسی خواهیم داشت. حال نام شیئ ساخته شده از روی کلاس ActionClass را نوشته یک نقطه قرار می دهیم و سپس نام متدی که در Interface ایجاد کردیم را می نویسیم. پس از اجرای برنامه خروجی زیر مشاهده خواهد شد:

920805-j52-IMAGE 1.jpg

همانطور که می بینیم با موفقیت توانستیم یک Interface ایجاد کنیم سپس آن را در کلاس خود اصطلاحاً implements کرده و در نهایت با ساخت یک Object از روی کلاس خود توانستیم برنامه ای که حاوی یک Interface و یک Class و یک Method بود را اجرا نماییم. در پایان این نکته را فراموش نکنیم که کلاسی که دست به اجرای یک Interface می زند می بایست کلیه متدهای موجود در آن Interface را نیز اجرا نماید.

چهارشنبه 2 بهمن 1392  12:24 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۵۳: نحوه ایجاد یک Thread


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

1. روش اول به این صورت است که کلاسی ایجاد کرده سپس آن کلاس ویژگی های خود را از کلاس Thread جاوا به ارث ببرد.

2. روش دوم به این صورت است که کلاسی ایجاد کرده و آن کلاس به اجرای یک Interface تحت عنوان Runnable بپردازد (لازم به ذکر است کلاسی که اقدام به اجرای Runnable نماید بدون آنکه خصوصیتی را از کلاس Thread به ارث ببرد خواهد توانست اقدام به ساخت یک Thread نماید).

در ادامه آموزش هر دو روش را مورد بررسی دقیق قرار خواهیم داد.

برای شروع یک پروژه جدید تحت عنوان 53rd Session ایجاد کرده و کلاسی در آن تحت عنوان MyThread ایجاد می کنیم:

  1. public class ThreadA extends Thread {
  2.  
  3. }

همانطور که در کد فوق مشاهده می شود کلاسی که تحت عنوان ThreadA ایجاد کردیم کلیه خصوصیات، ویژگی ها و متدهای کلاس Thread جاوا را به ارث خواهد برد. حال کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ThreadA extends Thread {
  2. @Override
  3. public void run() {
  4. System.out.println("Thread A");
  5. for (int i = 1; i <= 5; i++) {
  6. System.out.println("From thread A loop no= " + i);
  7. }
  8. }
  9. }

همانطور که در کد فوق ملاحظه می شود ابتدا متدی تحت عنوان run را وارد برنامه خود کرده ایم. لازم به ذکر است زمانیکه یک کلاس از کلاس Thread ارث بری می کند می بایست این متد را Override کرد که در غیر این صورت اکلیپس دوره واژه run را نقطه چین قرار خواهد داد و چنانچه نشانگر موس خود را روی نقطه چین قرار دهیم، اکلیپس به ما پیشنهاد می دهد که این متد را Override کنیم. حال از آنجا که قصد داریم علاوه بر کلاسی تحت عنوان ThreadA کلاس دیگری تحت عنوان ThreadB نیز ایجاد کنیم، در متد run دستوری را می نویسیم مبنی بر اینکه عبارت Thread A را در پنجره Console به نمایش در آورد تا بدانیم که خروجی برنامه متعلق به کدام Thread است. حال یک Loop از جنس for تعریف می کنیم (برای آشنایی بیشتر با for به آموزش بیست و دوم مراجعه نمایید). در واقع هر کاری که بخواهیم Thread ما انجام دهد می بایست داخل متد run نوشته شود. متغیری از جنس int تحت عنوان i ایجاد می کنیم به این شکل که نقطه شروع Loop عدد یک خواهد بود، نقطه پایان Loop کوچکتر یا برابر با 5 و در هر بار Loop شدن یک واحد به متغیر i اضافه خواهد شد. سپس داخل for دستور System.out.println را نوشته سپس داخل پرانتز متد println عبارت From Thread A loop no: را می نویسیم که حاکی از آن است که "از Thread A به همراه Loop شماره:" را در پنجره Console به نمایش در آورد. سپس یک علامت به علاوه قرار داده و نام متغیری که داخل for ایجاد کردیم را می نویسیم. حال کلاس دیگری تحت عنوان ThreadB ایجاد کرده و آن را به شکل زیر تکمیل می کنیم:

  1. public class ThreadB extends Thread {
  2. @Override
  3. public void run() {
  4. System.out.println("Thread B");
  5. for (int i = 1; i <= 5; i++) {
  6. System.out.println("From thread B: loop no = " + i);
  7. }
  8. }
  9. }

همانطور که ملاحظه می شود این کلاس نیز از کلاس Thread ارث بری می کند و تنها تفاوتی که با کلاس ThreadA دارد این است که هر کجا که حرف A داشتیم به حرف B تغییر یافته است. حال مجدد اقدام به کلاس دیگری تحت عنوان ActionClass می نماییم و به خاطر داشته باشیم که در حین ساخت این کلاس حتماً گزینه public static void main را تیک بزنیم چرا که این کلاس به منزله نقطه شروع برنامه ما خواهد بود:

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

حال نیاز است تا از روی هر کدام از کلاس های ThreadA و ThreadB یک شیئ ایجاد کنیم. برای این منظور کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ActionClass {
  2. public static void main(String args[]) {
  3. ThreadA a = new ThreadA();
  4.  
  5. ThreadB b = new ThreadB();
  6. }
  7. }

همانگونه که در آموزش های پیشین توضیح داده شد، ابتدا نام کلاس مد نظر را نوشته سپس نامی برای شیئی که می خواهیم از روی آن کلاس ایجاد کنیم در نظر می گیریم. سپس یک علامت مساوی قرار داده و از آنجا که می خواهیم یک شیئ جدید ایجاد کنیم می بایست از کلید واژه new استفاده نماییم. سپس مجدد نام کلاس مد نظر را نوشته و یک علامت (); پس از آن قرار می دهیم. اکنون برای آنکه بتوانیم شیئ های ساخته شده از روی کلاس Thread را اجرا نماییم نیاز به متدی تحت عنوان start داریم. برای این منظور همانطور که در کد زیر مشخص است متد start را به شیئ های ساخته شده از روی کلاس های ThreadA و ThreadB ضمیمه می کنیم:

  1. public class ActionClass {
  2. public static void main(String args[]) {
  3. ThreadA a = new ThreadA();
  4. a.start();
  5. ThreadB b = new ThreadB();
  6. b.start();
  7.  
  8. }
  9. }

به طور خلاصه شیئ ساخته شده از روی کلاس ThreadA نامش a است و شیئ ساخته شده از روی کلاس ThreadB نامش b است. حال متد start را به هر دوی این Object ها ضمیمه می کنیم. اکنون اگر برنامه خود را اجرا کنیم با خروجی زیر مواجه خواهیم شد:

920809-j53-IMAGE 1.jpg

همانطور که در اجرای فوق می بینیم اول Thread مرتبط با کلاس ThreadB اجرا شده است سپس Thread مرتبط با کلاس ThreadA . حال یک بار دیگر برنامه را اجرا می کنیم:

920809-j53-IMAGE 2.jpg

می بینیم که این بار ترتیب اجرای Thread ها عکس اجرای قبل است. در حقیقت علت این مسئله از آنجا ناشی می شود که در یک برنامه جاوا Thread نه تنها به صورت هم زمان اجرای می شوند بلکه این در حالی است که هر دو Thread مستقل از یکدیگر اجرا می شوند و به همین دلیل نیز می باشد که هر کدام ابتدا شانس اجرا شدن را پیدا کند اول اجرا خواهد شد. حال فرض کنیم که می خواهیم یک Thread به روش دومی که در بالا به آن اشاره شد ایجاد کنیم. برای این منظور پروژه دیگری تحت عنوان Runnable ایجاد کرده و کلاسی در آن به نام MyThread ایجاد می کنیم:

  1. public class MyThread {
  2.  
  3. }

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

  1. public class MyThread implements Runnable {
  2.  
  3. @Override
  4. public void run() {
  5. for (int i = 1; i <= 5; i++) {
  6. System.out.println("From My Thread loop no:" + i);
  7. }
  8.  
  9. }
  10. }

همانطور که در کد فوق مشاهده می شود ابتدا کلاس MyThread با استفاده از کلید واژه implements اقدام به اجرای Runnable خواهد کرد. سپس متد مرتبط با ایجاد یک Thread که run نام دارد را وارد برنامه خود می کنیم (به خاطر داشته باشیم برای آنکه بتوانیم از این متد استفاده کنیم می بایست آنرا Override کنیم). سپس همانند Thread های قبلی یک Loop از جنس for ایجاد کرده و کدهای قبلی را برای آن در نظر می گیریم. حال نیاز است تا کلاس دیگری تحت عنوان ActionClass ایجاد کنیم که به منزله نقطه شروع برنامه ما خواهد بود (به خاطر داشته باشیم که گزینه public static void main را تیک دار نماییم):

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

حال بایستی یک شیئ از روی کلاسی که تحت عنوان MyThread ایجاد کردیم در این کلاس ایجاد نماییم. برای این منظور کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ActionClass {
  2.  
  3. public static void main(String[] args) {
  4. MyThread test = new MyThread();
  5.  
  6. }
  7. }

نام شیئی که از روی کلاس MyThread ایجاد کرده ایم test است. اگر خاطرمان باشد در روش اول ساخت یک Thread نام شیئ ساخته شده از روی کلاس خود را مستقیماً به متدی start ضمیمه می کردیم و Thread ما اجرا می شود اما این در حالی است که زماینکه از Runnable برای ایجاد یک Thread استفاده می کنیم می بایست شیئی از روی کلاس Thread نیز ایجاد کرده، آن شیئ را به شیئی که از روی کلاس خود ساختیم مرتبط ساخته و در نهایت شیئ ساخته شده از روی کلاس Thread را به متد start ضمیمه کنیم. برای این منظور کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ActionClass {
  2.  
  3. public static void main(String[] args) {
  4. MyThread test = new MyThread();
  5. Thread thread = new Thread(test);
  6. thread.start();
  7. }
  8. }

همانطور که ملاحظه می شود یک Object از روی کلاس Thread جاوا تحت عنوان thread ایجاد کرده ایم (اگر توجه کنیم می بینیم که شیئ ساخته شده از روی کلاس Thread با حرف کوچک نوشته شده است. به جای این نام می توانیم از هر نام دیگری نیز استفاده کنیم). سپس داخل پرانتز مرتبط با کلاس Thread نام شیئی تحت عنوان test که از روی کلاس MyThread ایجاد کردیم را نوشته و در نهایت شیئ thread را به متد start که وظیفه دارد یک Thread را ایجاد کند ضمیمه می کنیم. حال اگر برنامه خود را اجرا کنیم با خروجی زیر مواجه خواهیم شد:

920809-j53-IMAGE 3.jpg

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

چهارشنبه 2 بهمن 1392  12:25 PM
تشکرات از این پست
hosseinb68
hosseinb68
کاربر طلایی1
تاریخ عضویت : بهمن 1389 
تعداد پست ها : 1269
محل سکونت : بوشهر

آموزش برنامه نویسی جاوا - قسمت ۵۴: آشنایی با مفهوم Exception در زبان برنامه نویسی جاوا


در این آموزش با مفهومی تحت عنوان Exception در زبان برنامه نویسی جاوا آشنا خواهیم شد. به طور کلی در زبان جاوا به منظور مواجهه با Error ها از چیزی تحت عنوان Exception استفاده می کنیم. معادل فارسی واژه Exception برابر است با "استثناء" و در زبان جاوا به "رویدادی گفته می شود که در پروسه اجرای یک برنامه یا اپلیکیشن بوجود می آید و از اجرای طبیعی برنامه جلوگیری به عمل می آورد".

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

به طور کلی در زبان برنامه نویسی جاوا وقتی این احتمال وجود داشته باشد که ممکن است با یک Exception مواجه شویم، بایستی کد خود را داخل دستوری تحت عنوان try بنویسیم که در این صورت اگر Error هم داخل برنامه یا اپلیکیشن ما وجود داشته باشد برنامه به هیچ وجه Crash نخواهد کرد.

برای روش شدن این مطلب پروژه تحت عنوان 54th Session در محیط اکلیپس ایجاد کرده و کلاسی تحت عنوان ExceptionsInJava ایجاد می کنیم (به خاطر داشته باشیم که در حین ساخت این کلاس گزینه public static void main را تیک بزنیم):

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

همانطور که ملاحظه می شود پس از حذف کامنت ها کد ما به صورت بالا خواهد بود. برای درک بهتر روابط مابین بخش های مختلف Exception ها کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ExceptionsInJava {
  2.  
  3. public static void main(String[] args) {
  4.  
  5. try{
  6. // کدی که می خواهیم اجرا شود
  7. }catch(){
  8. //کدی که در صورت بروز مشکل می خواهیم اجرا شود
  9. }finally{
  10. //کدی که در پایان اجرای مراحل فوق می خواهیم اجرا شود
  11. }
  12.  
  13. }
  14.  
  15. }

همانطور که در کد فوق می بینیم مابین دو {} مرتبط با دستور try بخشی از برنامه خود را می نویسیم که می خواهیم اجرا شود. حال این بخش از کد ما ممکن است که برنامه را با Error یی مواجه سازد. از این رو داخل دو {} مرتبط با دستور catch کدی را می نویسیم که در صورت بروز هر گونه مشکلی اجرا شود. در نهایت داخل دو {} مرتبط با دستور finally کدی را می نویسیم که در انتهای برنامه قصد داریم اجرا شود. حال اگر کدی که داخل دستور try است هیچ گونه مشکلی ایجاد نکرد، برنامه ما مستقیم به سراغ کدی خواهد دارد که داخل دستور finally قرار دارد و اگر هم کدی که داخل دستور try بود مشکلی ایجاد کرد، برنامه ابتدا دستور داخل catch را اجرا خواهد نمود سپس به سراغ اجرای دستور داخل finally خواهد رفت. اگر توجه کرده باشیم خواهیم دید که مقابل دستور catch دو پرانتز قرار دارد. کاری که این دو پرانتز انجام می دهند این است که می بایست داخل آنها نوع Exception یی که قصد داریم سیستم تشخیص دهد را بنویسیم. به عبارت دیگر چیزی که می بایست داخل پرانتزها نوشت نام یک کلاس از پیش تعریف شده در API زبان جاوا است که مرتبط با Exception ها می باشد به علاوه نام شیئی که برای آن کلاس در نظر می گیریم (در ادامه آموزش به خوبی به توضیح این مسئله خواهیم پرداخت). اکنون برای آنکه به طور عملی با کارکرد Exception ها آشنا شویم کد فوق را به صورت زیر تکمیل می کنیم:

  1. public class ExceptionsInJava {
  2.  
  3. public static void main(String[] args) {
  4.  
  5. System.out.println("This is my first output!");
  6.  
  7. int numberOne = 10;
  8. int numberTwo = 0;
  9. int result = numberOne / numberTwo;
  10.  
  11. System.out.println(result);
  12.  
  13. System.out.println("This is my final output!");
  14.  
  15. }
  16. }

همانطور که در کد بالا مشاهده می کنیم در ابتدا با استفاده از دستور System.out.println عبارت This is my first output! به معنی "این اولین خروجی من است!" را در پنجره Console به نمایش در خواهیم آورد. سپس اقدام به تعریف چند متغیر از جنس int نموده که این وظیفه را دارا هستند که اعدادی از جنس عدد صحیح را در خود ذخیره سازند. متغیر اول ما numberOne به معنی "عدد شماره یک" است که مقدار اولیه آن معادل با 10 است. متغیر دوم ما numberTwo به معنی "عدد شماره دو" است که مقدار اولیه آن معادل با صفر است. متغیر سوم ما result به معنی "نتیجه" نام دارد که عددی به عنوان Value آن در نظر نگرفته ایم بلکه Value آن را حاصل تقسیم مقدار متغیر numberOne بر numberTwo قرار داده ایم (به منظور آشنایی بیشتر با اعمال ریاضیاتی در جاوا به آموزش هشتم مراجعه نمایید). همانطور که منطق ریاضی حکم می کند ما نمی توانیم عددی همچون ده را بر صفر تقسیم کنیم. علیرغم اینکه از این نکته اطلاع داریم می خواهیم ببینم که عکس العمل ماشین مجازی جاوا یا همان JVM چیست. حال یک بار دیگر دستور System.out.println را نوشته و این بار با قرار دادن نام متغیر result داخل پرانتز این دستور، از سیستم می خواهیم که پس از به نمایش در آوردن عبارت This is my first output! اقدام به نمایش مقدار متغیر result نماید. در نهایت یک بار دیگر دستور System.out.println را نوشته و این بار عبارت This is my final output! به معنی "این خروجی پایانی من است!" را می خواهیم در پنجره Console به نمایش در آوریم. پس از اجرای برنامه خروجی زیر مشاهده خواهد شد:

920819-54j-IMAGE 1.jpg

همانطور که در اجرای بالا می بینیم، اولین دستوری که نوشته بودیم بدون هیچ مشکلی اجرا شده و عبارت This is my first output! در پنجره Console به نمایش در آمده است. سیستم پس از اجرای اولین دستور به سراغ دستور دوم خواهد رفت و از آنجا که در دستور دوم از برنامه خود خواسته ایم که عدد ده را به عدد صفر تقسیم کند و این چنین عملی خارج از منطق ریاضیاتی است، از این رو برنامه ما اصطلاحاً Crash کرده و در پنجره Console همانطور که در تصویر فوق مشخص است یک Exception از نوع کلاس ArithmeticException در برنامه رخ داده است. واژه Arithmetic به معنی "محاسباتی، ریاضیاتی و ..." است و همانطور که از نام این کلاس پیدا است نوع Exception بوجود آمده در ارتباط با اعمال ریاضیاتی است. حال از آنجا که برنامه ما در حین اجرای دومین دستور خود Crash کرد بنابراین از اجرای دستور سوم که همان به نمایش در آوردن عبارت This is my final output! است نیز ناتوان خواهد بود. در آموزش آتی خواهیم دید که به چه شکل با استفاده از دستورات try, catch, finally پروژه ای که در این آموزش نوشتیم و Crash کرد را باز نویسی کرده و از Crash کردن آن جلوگیری خواهیم کرد.

چهارشنبه 2 بهمن 1392  12:26 PM
تشکرات از این پست
amirreza781128
amirreza781128
کاربر برنزی
تاریخ عضویت : آذر 1394 
تعداد پست ها : 21
سه شنبه 29 دی 1394  5:13 PM
تشکرات از این پست
hosseinb68
دسترسی سریع به انجمن ها