1. مهمان گرامی، جهت ارسال پست، دانلود و سایر امکانات ویژه کاربران عضو، ثبت نام کنید.
    بستن اطلاعیه

آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

شروع موضوع توسط minaaa ‏9/2/14 در انجمن Java Script

  1. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا[/h]

    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی Exception Object
    2. آشنایی با مفهوم Handle کردن
    3. نحوه حذف یک Exception

    در آموزش گذشته پروژه ای طراحی کردیم که در آن یک ArithmeticException وجود داشت بنابراین برنامه ما Crash کرد.

    اکنون ببینیم اگر همین برنامه را به استفاده از دستور ات try, catch, finally بنویسیم چه اتفاقی خواهد افتاد:




    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • System.out.println("This is my first output!");
    • try {
    • int numberOne = 10;
    • int numberTwo = 0;
    • int result = numberOne / numberTwo;
    • System.out.println(result);
    • } catch (ArithmeticException myProblem) {
    • System.out.println(myProblem);
    • } finally {
    • System.out.println("This is my final output!");
    • }
    • }
    • }

    همانطور که می بینیم ابتدا دستوری که قرار است عبارت This is my first output! را در پنجره Console به نمایش در آورد را نوشته ایم. سپس دستوری که در کد قبل مشکل زا بود را داخل try نوشته ایم. بلافاصله پس از دستور try دستور catch آمده است که این وظیفه را دارا است تا اگر در دستور try مشکلی وجود داشت آن مشکل را به کاربر نشان دهد و از Crash کردن برنامه جلوگیری به عمل آورد. همانطور که ملاحظه می شود پارامتری که برای دستور catch در نظر گرفته شده است کلاسی تحت عنوان ArithmeticException است و نامی هم که برای شیئ ساخته شده از روی این کلاس در نظر گرفته ایم myProblem به معنی "مشکل من" است (لازم به ذکر است اکثر برنامه نویسان دنیا برای نام کلاس های مرتبط با Exception نام e را در نظر می گیرند که حرف اول Exception می باشد اما به منظور جلوگیری از سردرگمی برنامه نویسان مبتدی در این آموزش نامی گویاتر همچون myProblem در نظر گرفته شده است).

    سپس با استفاده از دستور System.out.println و قرار دادن نام شیئ ساخته شده از روی کلاس ArithmeticException داخل این دستور از برنامه خود می خواهیم که چنانچه مشکلی در دستور try بود آن را با استفاده از این دستور نمایش دهد. در خاتمه در دستور finally دستوری که قصد داریم در پایان برنامه اجرا شود را می نویسیم که این دستور همان به نمایش در آوردن عبارت This is my final output! است.

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

    [​IMG]
    می بینیم که دستور اول که مسئول به نمایش در آوردن عبارت This is my first output! بود به نمایش در آمده است. حال نوبت به اجرای دستور داخل try می رسد و از آنجا که دستور داخل try یک دستور غیر منطقی است برنامه مستقیماً وارد دستور catch می شود و همانطور که می بینیم نوع Exception نوشته شده است و مقابل آن عبارت / by zero آمده است. چنانچه بخواهیم این عبارت را به زبان فارسی ترجمه کنیم بایستی گفت " یک مشکل محاسباتی بوجود آمده است که علت آن هم تقسیم شدن عددی بر صفر است". در نهایت برنامه علیرغم اینکه دارای یک مشکل است اما به هیچ وجه Crash نکرده و ادامه پیدا می کند تا جاییکه دستور به نمایش در آوردن عبارت This is my final output! هم اجرا خواهد شد.

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

    [​IMG]
    همانطور که در نمودار فوق مشخص است در صورت وجود یک دستور نادرست از لحاظ ریاضیاتی مثل تقسیم کردن عدد ده بر عدد صفر یک Exception Object ایجاد می شود که به ماشین مجازی جاوا یا JVM فرستاده می شود. حال دو اتفاق ممکن است روی دهد: اگر این Exception اصطلاحاً Handle شود یا رفع شود برنامه به کار خود ادامه خواهد داد و مابقی دستورات اجرا خواهند شد (مورد سمت راست) و اگر هم که این Exception اصطلاحاً Handle نشود برنامه متوقف خواهد شد، در پنجره Console نوع Exception به نمایش در خواهد آمد و مابقی دستورات داخل برنامه به هیچ وجه اجرا نخواهند شد.

    به نظر می رسد پس از اجرای برنامه خود در مرحله دوم کاملاً به اهمیت استفاده از دستورات try, catch, finally بیشتر پی ببریم. همانطور که دیدیم برنامه بدون آنکه Crash کند اجرا شده و در جایی از کد هم که مشکلی وجود داشت آن مشکل به اطلاع کاربر رسید.

    اکنون فرض کنیم که در صورت وجود یک Exception در برنامه خود نمی خواهیم که نوع Exception و دلیل آن در پنجره Console به نمایش در آید بلکه قصد داریم چنانچه برنامه مشکلی داشت جمله ای را به نمایش در آوریم. برای این منظور کد خود را به صورت زیر ویرایش می کنیم:



    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • System.out.println("This is my first output!");
    • try {
    • int numberOne = 10;
    • int numberTwo = 0;
    • int result = numberOne / numberTwo;
    • System.out.println(result);
    • } catch (ArithmeticException myProblem) {
    • System.out.println("Hey Boy! You cannot divide 10 by 0 ...");
    • } finally {
    • System.out.println("This is my final output!");
    • }
    • }
    • }

    می بینیم که داخل دستور System.out.println یی که داخل catch قرار گرفته است به جای نوشتن نام شیئ ساخته شده از روی کلاس ArithmeticException عبارت Hey Boy! You cannot divide 10 by 0… به معنی "هی پسر! تو نمی توانی عدد ده رو بر صفر تقسیم کنی ..." را نوشته ایم. یک بار دیگر برنامه خود را اجرا می کنیم:

    [​IMG]
    می بینیم که برنامه ما پس از اجرا با مشاهده کردن مشکلی در کد مرتبط با try عبارتی را نمایش خواهد داد که در دستور catch نوشته ایم. حال فرض کنیم که به هیچ وجه نمی خواهیم برنامه ما پس از مشاهده مشکلی در کد مرتبط با try چیزی در پنجره Console نمایش دهد. برای این منظور کد فوق را به صورت زیر بازنویسی می کنیم:



    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • System.out.println("This is my first output!");
    • try {
    • int numberOne = 10;
    • int numberTwo = 0;
    • int result = numberOne / numberTwo;
    • System.out.println(result);
    • } catch (ArithmeticException myProblem) {
    • } finally {
    • System.out.println("This is my final output!");
    • }
    • }
    • }

    در واقع کاری که در کد بالا انجام داده ایم این است که دستوری که داخل {} مرتبط با catch بود را از برنامه حذف کرده ایم. با اینکار به برنامه خود دستور می دهیم که چنانچه مشکلی در دستور try بود آن مشکل را در دستور catch بررسی کند اما به هیچ وجه چیزی مرتبط با دستور catch در پنجره Console به نمایش در نیاورد. حال مجدد برنامه خود را اجرا می کنیم:

    [​IMG]
    همانطور که ملاحظه می شود علیرغم اینکه برنامه ما داری یک Exception است اما برنامه Crash نکرده و چیزی هم حاکی از آنکه برنامه داری مشکلی است به اطلاع کاربر نخواهد رسید.
     
  2. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۵۵: آشنایی با انواع Exception ها[/h]

    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی انواع Exception ها در زبان جاوا
    2. آشنایی با مفاهیم Compile-time و Runtime
    3. آشنایی با NullPointerException
    4. آشنایی با NumberFormatException
    5. آشنایی با ArrayIndexOutOfBoundsException

    به طور کلی Exception ها را می توان به دو گروه اصلی Checked و Unchecked دسته بندی کرد. در واقع منظور از Checked Exception ها Exception هایی هستند که در حین Compile-time رخ می دهند که از آن جمله می توان به IOException و SQLException اشاره کرد. در واقع این دست از Error ها مشکلاتی هستند که به Syntax برنامه مرتبط هستند. مثلاً اگر به جای نوشتن int عبارت INT را بنویسیم، از آنجا که یک مشکل Syntax یی داریم بایستی انتظار مشکلی مرتبط با Compile time داشته باشیم. به طور کلی این دسته از Exception ها "حتماً" می بایست اصطلاحاً Handle شده یا مد نظر قرار داده شوند.

    منظور از Unchecked Exception ها نوعی از Exception ها است که در حین Runtime رخ می دهندکه از آن جمله می توان به ArithmeticException و NullPointerException اشاره نمود. در واقع در این دست از مشکلات برنامه بدون هیچ مشکلی Compile می شود اما این در حالی است که در حین اجرای برنامه کاربر نتایج غیر قابل انتظاری مشاهده خواهد کرد و حتی ممکن است برنامه Crash هم بکند.

    در حقیقت منظور از Compile-time این است که زمانیکه ما یک برنامه در زبان برنامه نویسی جاوا می نویسیم، کدهای ما می بایست به زبان ماشین تبدیل شوند و زمانیکه کدها به زبان ماشین تبدیل می شوند Compile-time نامیده می شود. حال پس از آنکه کدها به زمان ماشین تبدیل شدند و اصطلاحاً برنامه Compile شد، کاربر می تواند برنامه را اجرا کند و به زمانیکه کاربر یک برنامه را اجرا می کند Runtime گفته می شود.

    پس از آنکه با مفاهیم Compile-time و Run-time در زبان برنامه نویسی جاوا آشنا شدیم در این بخش از آموزش به منظور بررسی دیگر انواع Exception ها کلاس های دیگری به پروژه خود اضافه می کنیم:




    • public class NullPointerException {
    • public static void main(String[] args) {
    • String s = null;
    • System.out.println(s.length());
    • }
    • }

    همانطور که در کد فوق می بینیم کلاسی تحت عنوان NullPointerException ایجاد کرده ایم. سپس در متد main این کلاس یک شیئ از روی کلاس String تحت عنوان s ساخته ایم و مقدار اولیه آن را برابر با null قرار داده ایم. حال در دستور System.out.println با استفاده از متد length قصد داریم تعداد کاراکتر های شیئ ساخته شده از روی کلاس String را شمارش کنیم. برای همین منظور داخل پرانتز مرتبط با متد println نام شیئ ساخته شده از روی کلاس String را نوشته سپس یک نقطه قرار داده و متد length را به آن ضمیمه می کنیم. اکنون می توانیم برنامه خود را اجرا کنیم:

    [​IMG]
    همانطور که در تصویر فوق می بینیم پس از اجرای برنامه با یک NullPointerException مواجه می شویم. علت مواجهه با چنین Exception یی این است که برای Object های ایجاد شده از روی کلاس String می بایست مقداری همچون یک عبارت یا یک کلمه در نظر گرفت که در این صورت اگر از متد length هم استفاده کنیم این متد تعداد کاراکترهای مرتبط با شیئ ساخته شده از روی کلاس String را خواهد شمارد اما از آنجا که در مثال فوق مقدار اولیه این کلاس را برابر با null قرار داده ایم حال اگر بخواهیم متد length را به شیئی ضمیمه کنیم که مقدار اولیه آن null است، برنامه ما با Exception یی از جنس NullPointerException رو به رو خواهد شد. چنانچه بخواهیم عبارت NullPointerException را به صورت تحت الفظی ترجمه کنیم می توانیم معادل "مشکلی که به خاطر اشاره به چیزی که تهی است ایجاد شده است" را در نظر بگیریم.

    حال کلاس دیگری تحت عنوان NumberFormatException ایجاد می کنیم که از طریق آن Exception یی با نام NumberFormatException را مورد بررسی قرار خواهیم داد:



    • public class NumberFormatException {
    • public static void main(String[] args) {
    • String s = "Hello";
    • int i = Integer.parseInt(s);
    • }
    • }

    همانطور که در کد فوق مشخص است شیئی تحت عنوان s از روی کلاس String ایجاد کرده و مقدار اولیه آن را برابر با Hello قرار می دهیم. سپس یک متغیر از جنس int تحت عنوان i ایجاد می کنیم و مقدار آن را برابر با متدی تحت عنوان parseInt که به کلاسی تحت عنوان Integer ضمیمه شده است قرار داده و شیئ ساخته شده از روی کلاس String را به عنوان پارامتر متد parseInt در نظر می گیریم.

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

    [​IMG]
    در واقع علت بروز چنین Exception یی این است که به هیچ وجه نمی توانیم یک شیئ از جنس کلاس String را به متغیری از جنس int تبدیل کنیم.

    Exception دیگری که می خواهیم مورد بررسی قرار دهیم ArrayIndexOutOfBoundsException نام دارد. برای این منظور کلاسی با همین نام در پروژه خود ایجاد می کنیم و آن را به صورت زیر تکمیل می کنیم:



    • public class ArrayIndexOutOfBoundsException {
    • public static void main(String[] args) {
    • int[] numbers = new int[10];
    • numbers[11] = 100;
    • }
    • }

    همانطور که در کد فوق می بینیم یک Array از جنس int ایجاد کرده ایم که numbers نام دارد. همانطور که مشخص است این Array قرار است 10 گزینه را در خود جای دهد. پس از تعریف این Array در خط دوم می بینیم که Array یی با شماره 11 را مد نظر قرار داده ایم و مقدار آن را برابر با عدد 100 در نظر گرفته ایم. حال برنامه را اجرا می کنیم:

    [​IMG]
    همانطور که در تصویر فوق می بینیم برنامه ما با یک Exception از جنس ArrayIndexOutOfBoundsException رو به رو می شود و علت هم آن است که ما در Array خود فقط ده گزینه داریم اما در ادامه برنامه گزینه شماره یازده را هدف قرار داده ایم و از آنجا که این گزینه خارج از محدوده تعریف شده برای این Array است با چنین Exception یی رو به رو خواهیم شد.
     
  3. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۵۴: آشنایی با مفهوم Exception در زبان برنامه نویسی جاوا[/h]

    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی Exception در زبان برنامه نویسی جاوا
    2. آشنایی با دستورات try, catch, finally

    در این آموزش با مفهومی تحت عنوان 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 را تیک بزنیم):



    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • }
    • }

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



    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • try{
    • // کدی که می خواهیم اجرا شود
    • }catch(){
    • //کدی که در صورت بروز مشکل می خواهیم اجرا شود
    • }finally{
    • //کدی که در پایان اجرای مراحل فوق می خواهیم اجرا شود
    • }
    • }
    • }

    همانطور که در کد فوق می بینیم مابین دو {} مرتبط با دستور try بخشی از برنامه خود را می نویسیم که می خواهیم اجرا شود. حال این بخش از کد ما ممکن است که برنامه را با Error یی مواجه سازد. از این رو داخل دو {} مرتبط با دستور catch کدی را می نویسیم که در صورت بروز هر گونه مشکلی اجرا شود. در نهایت داخل دو {} مرتبط با دستور finally کدی را می نویسیم که در انتهای برنامه قصد داریم اجرا شود. حال اگر کدی که داخل دستور try است هیچ گونه مشکلی ایجاد نکرد، برنامه ما مستقیم به سراغ کدی خواهد دارد که داخل دستور finally قرار دارد و اگر هم کدی که داخل دستور try بود مشکلی ایجاد کرد، برنامه ابتدا دستور داخل catch را اجرا خواهد نمود سپس به سراغ اجرای دستور داخل finally خواهد رفت.

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

    اکنون برای آنکه به طور عملی با کارکرد Exception ها آشنا شویم کد فوق را به صورت زیر تکمیل می کنیم:



    • public class ExceptionsInJava {
    • public static void main(String[] args) {
    • System.out.println("This is my first output!");
    • int numberOne = 10;
    • int numberTwo = 0;
    • int result = numberOne / numberTwo;
    • System.out.println(result);
    • System.out.println("This is my final output!");
    • }
    • }

    همانطور که در کد بالا مشاهده می کنیم در ابتدا با استفاده از دستور 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 به نمایش در آوریم.

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

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

    حال از آنجا که برنامه ما در حین اجرای دومین دستور خود Crash کرد بنابراین از اجرای دستور سوم که همان به نمایش در آوردن عبارت This is my final output! است نیز ناتوان خواهد بود.

    در آموزش آتی خواهیم دید که به چه شکل با استفاده از دستورات try, catch, finally پروژه ای که در این آموزش نوشتیم و Crash کرد را باز نویسی کرده و از Crash کردن آن جلوگیری خواهیم کرد.
     
  4. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۵۳: نحوه ایجاد یک Thread[/h]

    اهداف آموزشی این قسمت عبارتند از:
    1. نحوه ایجاد یک Thread
    2. آشنایی با Interface یی تحت عنوان Runnable
    3. آشنایی با متدهای run و start

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

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

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

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

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



    • public class ThreadA extends Thread {
    • }

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



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

    همانطور که در کد فوق ملاحظه می شود ابتدا متدی تحت عنوان 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 ایجاد کرده و آن را به شکل زیر تکمیل می کنیم:



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

    همانطور که ملاحظه می شود این کلاس نیز از کلاس Thread ارث بری می کند و تنها تفاوتی که با کلاس ThreadA دارد این است که هر کجا که حرف A داشتیم به حرف B تغییر یافته است.

    حال مجدد اقدام به کلاس دیگری تحت عنوان ActionClass می نماییم و به خاطر داشته باشیم که در حین ساخت این کلاس حتماً گزینه public static void main را تیک بزنیم چرا که این کلاس به منزله نقطه شروع برنامه ما خواهد بود:



    • public class ActionClass {
    • public static void main(String args[]) {
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String args[]) {
    • ThreadA a = new ThreadA();
    • ThreadB b = new ThreadB();
    • }
    • }

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

    اکنون برای آنکه بتوانیم شیئ های ساخته شده از روی کلاس Thread را اجرا نماییم نیاز به متدی تحت عنوان start داریم. برای این منظور همانطور که در کد زیر مشخص است متد start را به شیئ های ساخته شده از روی کلاس های ThreadA و ThreadB ضمیمه می کنیم:



    • public class ActionClass {
    • public static void main(String args[]) {
    • ThreadA a = new ThreadA();
    • a.start();
    • ThreadB b = new ThreadB();
    • b.start();
    • }
    • }

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

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

    [​IMG]
    می بینیم که این بار ترتیب اجرای Thread ها عکس اجرای قبل است. در حقیقت علت این مسئله از آنجا ناشی می شود که در یک برنامه جاوا Thread نه تنها به صورت هم زمان اجرای می شوند بلکه این در حالی است که هر دو Thread مستقل از یکدیگر اجرا می شوند و به همین دلیل نیز می باشد که هر کدام ابتدا شانس اجرا شدن را پیدا کند اول اجرا خواهد شد.

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



    • public class MyThread {
    • }

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



    • public class MyThread implements Runnable {
    • @Override
    • public void run() {
    • for (int i = 1; i <= 5; i++) {
    • System.out.println("From My Thread loop no:" + i);
    • }
    • }
    • }

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

    حال نیاز است تا کلاس دیگری تحت عنوان ActionClass ایجاد کنیم که به منزله نقطه شروع برنامه ما خواهد بود (به خاطر داشته باشیم که گزینه public static void main را تیک دار نماییم):



    • public class ActionClass {
    • public static void main(String[] args) {
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • MyThread test = new MyThread();
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • MyThread test = new MyThread();
    • Thread thread = new Thread(test);
    • thread.start();
    • }
    • }

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

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

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

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

    اهداف آموزشی این قسمت عبارتند از:
    1. نحوه ایجاد یک Interface
    2. نحوه ایجاد یک متد در یک Interface
    3. نحوه اجرا کردن یک Interface در یک Class

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



    • public interface ProgrammerOne {
    • public void designTheUI();
    • }

    همانطور که در کد فوق ملاحظه می شود برای ساخت یک 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 را تیک دار نماییم):



    • public class ActionClass {
    • public static void main(String[] args) {
    • }
    • }

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



    • public class ActionClass implements ProgrammerOne{
    • public static void main(String[] args) {
    • }
    • }

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



    • public class ActionClass implements ProgrammerOne {
    • @Override
    • public void designTheUI() {
    • System.out.println("Programmer one has to design the UI");
    • }
    • public static void main(String[] args) {
    • }
    • }

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

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

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



    • public class ActionClass implements ProgrammerOne {
    • @Override
    • public void designTheUI() {
    • System.out.println("Programmer one has to design the UI");
    • }
    • public static void main(String[] args) {
    • ActionClass test = new ActionClass();
    • test.designTheUI();
    • }
    • }

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

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

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۵۱: معرفی کلاس Thread در جاوا‎[/h]
    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی کلاس Thread ها در زبان برنامه نویسی جاوا
    2. چند مثال از کاربر Thread ها
    3. آشنایی با Interface ها
    4. تفاوت های Interface ها با Class ها

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

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

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

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

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

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

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

    [​IMG]
    از سوی دیگر این نقشه حاوی اطلاعاتی است مبنی بر اینکه هر برنامه نویس طبق چه استانداردی بایست به کدنویسی بپردازد. به عبارت دیگر برنامه نویسان نمی توانند طبق نظر شخصی به هر سبکی که تمایل دارند کدنویسی کنند. در واقع 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 بیشتر آشنا خواهیم شد.
     
  7. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

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

    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی Constant ها در زبان برنامه نویسی جاوا
    2. نحوه ایجاد یک Constant

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


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



    • public class JavaConstants {
    • public static void main(String[] args) {
    • }
    • }

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



    • public class JavaConstants {
    • public static void main(String[] args) {
    • int numberOfHoursInADay = 24;
    • }
    • }

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



    • public class JavaConstants {
    • public static void main(String[] args) {
    • int numberOfHoursInADay = 24;
    • System.out.println(numberOfHoursInADay);
    • }
    • }

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

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



    • public class JavaConstants {
    • public static void main(String[] args) {
    • int numberOfHoursInADay = 24;
    • numberOfHoursInADay = 25;
    • System.out.println(numberOfHoursInADay);
    • }
    • }

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

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



    • public class JavaConstants {
    • public static void main(String[] args) {
    • final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • System.out.println(NUMBER_OF_HOURS_IN_A_DAY);
    • }
    • }

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

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

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

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

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

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

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

    [​IMG]
    این پیغام خطا به طور خلاصه حاکی از آن است که برنامه به درستی Compile نشده است.

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



    • public class JavaConstants {
    • final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • }

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



    • public class JavaConstants {
    • public void showConstant() {
    • final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • }
    • }

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



    • public class JavaConstants {
    • public final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • }

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



    • public class JavaConstants {
    • private final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • }

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



    • public class JavaConstants {
    • static final int NUMBER_OF_HOURS_IN_A_DAY = 24;
    • }

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

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۴۹: آشنایی با کلید واژه final[/h]اهداف آموزشی این قسمت عبارتند از:
    1. معرفی کلید واژه final در زبان برنامه نویسی جاوا
    2. کاربردی های مختلف کلید واژه final

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

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

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

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

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

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



    • public class WhatIsFinal {
    • }

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



    • public class WhatIsFinal {
    • public void showData() {
    • String name = "Behzad";
    • String lastName = "Moradi";
    • int dateOfBirth = 1362;
    • System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
    • }
    • }

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

    حال کلاس دیگری تحت عنوان ActionClass به معنی "کلاس عملیاتی" ایجاد کرده و در حین ساخت آن گزینه public static void main را تیک دار می کنیم چرا که این کلاس قرار است به عنوان نقطه شروع برنامه ما باشد:



    • public class ActionClass {
    • public static void main(String[] args) {
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • WhatIsFinal objectOne = new WhatIsFinal();
    • objectOne.showData();
    • }
    • }

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

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



    • public class Change extends WhatIsFinal {
    • }
    • }

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

    در ادامه کار خود نیاز داریم تا درکلاس Change متدی که قبلا ایجاد کرده بودیم را Override را رونویسی کنیم. برای این منظور کد فوق را به شکل زیر تکمیل می کنیم:



    • public class Change extends WhatIsFinal {
    • @Override
    • public void showData() {
    • String name = "Iman";
    • String lastName = "Ahmadi";
    • int dateOfBirth = 1364;
    • System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • WhatIsFinal objectOne = new WhatIsFinal();
    • objectOne.showData();
    • System.out.println();
    • Change objectTwo = new Change();
    • objectTwo.showData();
    • }
    • }

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

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



    • public class WhatIsFinal {
    • public final void showData() {
    • String name = "Behzad";
    • String lastName = "Moradi";
    • int dateOfBirth = 1362;
    • System.out.println(name + "\n" + lastName + "\n" + dateOfBirth);
    • }
    • }

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

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

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

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

    [​IMG]
    می بینیم که شیئ ساخته شده اول ما به خوبی نمایش داده شده است اما شیئ دوم ما که در آن یک متد final را Override کرده بودیم با مشکل مواجه شده است.
     
  9. کاربر ارزشمند

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

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

    اهداف آموزشی این قسمت عبارتند از:
    1. ساخت شیئ از روی یک کلاس
    2. آشنایی عملی با کلید واژه static
    3. نحوه به کار گیری کلید واژه static با متدها

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

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



    • public class ActionClass {
    • /**
    • * [MENTION=10078]para[/MENTION]m args
    • */
    • public static void main(String[] args) {
    • // TODO Auto-generated method stub
    • }
    • }


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

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

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • }
    • }

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • personOne.showAthleteInfo();
    • }
    • }

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

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

    حال دو شیئ دیگر از روی کلاس Athlete می سازیم:



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • personOne.showAthleteInfo();
    • Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
    • personTwo.showAthleteInfo();
    • Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
    • personThree.showAthleteInfo();
    • }
    • }

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

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • personOne.showAthleteInfo();
    • // Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
    • // personTwo.showAthleteInfo();
    • Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
    • personThree.showAthleteInfo();
    • }
    • }

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

    [​IMG]
    می بینیم که اطلاعات personThree به نمایش درآمده اما این در حالی است که شماره عضویت به صورت خودکار یکی کاهش می یابد.

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



    • static int registrationNumber = 100;

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

    [​IMG]
    می بینیم که از آنجا که Field مرتبط با شماره عضویت از جنس static است هر تغییری که در آن ایجاد کنیم در کلیه کلاس های ساخته شده از روی آن کلاس اعمال خواهد شد.

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • static int registrationNumber = 0;
    • public Athlete(String nameOfAthlete, String lastNameOfAthlete,
    • int dateOfBirthOfAthlete) {
    • name = nameOfAthlete;
    • lastName = lastNameOfAthlete;
    • dateOfBirth = dateOfBirthOfAthlete;
    • registrationNumber++;
    • }
    • public void showAthleteInfo() {
    • System.out.println("Your name is " + name);
    • System.out.println("Your last name is " + lastName);
    • System.out.println("Your date of birth is " + dateOfBirth);
    • System.out.println("Your registration No is " + registrationNumber);
    • }
    • public static int showAllAthletes() {
    • return registrationNumber;
    • }
    • }

    همانطور که در کد فوق ملاحظه می شود در انتهای کد اقدام به ساخت یک متد جدید تحت عنوان showAllAtheltes به معنی "همه ورزشکاران را نشان بده" نموده ایم. از آنجا که قرار است این متد یک عدد به ما نشان دهد، از این رو آن را از جنس int قرار می دهیم. زمانیکه ما در ساخت یک متد از کلید واژه void استفاده نمی کنیم به بدان معنا است که این متد همواره داده ای را return خواهد کرد پس می بایست کلید واژه return را نوشته و چیزی که قصد داریم این متد بازگرداند را مقابل آن قرار می دهیم. در این مثال می خواهیم این متد همواره تعداد کل ثبت نامی ها را به مدیر باشگاه نشان دهد پس می بایست نام متغیر registrationNumber را مقابل آن بنویسیم.

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • personOne.showAthleteInfo();
    • Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
    • personTwo.showAthleteInfo();
    • Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
    • personThree.showAthleteInfo();
    • System.out.println("The number of all registrations is "
    • + personOne.showAllAthletes());
    • }
    • }

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

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



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

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

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



    • public class ActionClass {
    • public static void main(String[] args) {
    • Athlete personOne = new Athlete("Behzad", "Moradi", 1362);
    • personOne.showAthleteInfo();
    • Athlete personTwo = new Athlete("Ahmad", "Sohrabi", 1346);
    • personTwo.showAthleteInfo();
    • // Athlete personThree = new Athlete("Ramin", "Jafari", 1371);
    • // personThree.showAthleteInfo();
    • System.out.println("The number of all registrations is "
    • + personOne.showAllAthletes());
    • }
    • }

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

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

    تاریخ عضویت:
    ‏9/12/10
    ارسال ها:
    19,869
    تشکر شده:
    6,409
    امتیاز دستاورد:
    113
    پاسخ : آموزش برنامه نویسی جاوا - : دستورات try, catch, finally در جاوا

    [​IMG] برنامه نویسی

    [h=1]آموزش برنامه نویسی جاوا - قسمت ۴۷: نحوه به کارگیری از کلید واژه static در متغیرها در پروژه باشگاه ورزشی[/h]
    اهداف آموزشی این قسمت عبارتند از:
    1. معرفی کلید واژه static در زبان جاوا
    2. به کارگیری از Constructor ها در برنامه های جاوا
    3. استفاده از دستور ++

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

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

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

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

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



    • public class Athlete {
    • }

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • int registrationNumber;
    • }

    همانطور که در کد فوق ملاحظه می شود، دو شیئ از روی کلاس String تحت عناوین name و lastName به معنی به ترتیب "نام" و "نام خانوادگی" ایجاد کرده سپس یک متغیر از جنس عدد صحیح تحت عنوان dateOfBirth به معنی "تاریخ تولد" و یک متغیر دیگر هم از همان نوع تحت عنوان registrationNumber به معنی "شماره عضویت" ایجاد کرده ایم.

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • static int registrationNumber;
    • }

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • static int registrationNumber = 0;
    • }

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

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • static int registrationNumber = 0;
    • public Athlete(String nameOfAthlete, String lastNameOfAthlete,
    • int dateOfBirthOfAthlete) {
    • name = nameOfAthlete;
    • lastName = lastNameOfAthlete;
    • dateOfBirth = dateOfBirthOfAthlete;
    • registrationNumber++;
    • }
    • }

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



    • public class Athlete {
    • String name;
    • String lastName;
    • int dateOfBirth;
    • static int registrationNumber = 0;
    • public Athlete(String nameOfAthlete, String lastNameOfAthlete,
    • int dateOfBirthOfAthlete) {
    • name = nameOfAthlete;
    • lastName = lastNameOfAthlete;
    • dateOfBirth = dateOfBirthOfAthlete;
    • registrationNumber++;
    • }
    • public void showAthleteInfo() {
    • System.out.println("Your name is " + name);
    • System.out.println("Your last name is " + lastName);
    • System.out.println("Your date of birth is " + dateOfBirth);
    • System.out.println("Your registration No is "
    • + registrationNumber);
    • }
    • }

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