Java

[B@RBOD]

آموزش جاوا - integers ( اعداد صحيح )

جاوا چهار نوع عدد صحيح تعريف مي كند : byte، short،، int،، long، . كليه اين اعداد داراي علامات مثبت و منفي هستند . جاوا از اعداد صحيح غير علامت دار و فقط مثبت پشتيباني نمي كند . بسياري از زبانهاي برنامه نويسي شامل Cو C++و هم از اعداد صحيح علامت دار و هم از اعداد صحيح فاقد علامت پشتيباني مي كنند . اما طراحان جاوا احساس مي كردند كه اعداد صحيح فاقد علامت غير ضروري است . بويژه آنها احساس كردند كه مفهوم فاقد علامت (unsigned) بيشتر براي مشخص كردن رفتار بيت بالاتر از حد مجاز (high-order bit) استفاده مي شود كه علامت يك int را هنگاميكه بعنوان يك رقم عنوان مي شود ، مشخص مي كند . بعدا" خواهيد ديد كه
جاوا مفهوم بيت بالاتر از حد مجاز (high-order bit) را بگونه اي متفاوت مديريت مي كند ، يعني با اضافه كردن يك عملگر ويژه حركت به راست فاقد علامت unsigned) (right shift . بدين ترتيب نياز به يك نوع عدد صحيح فاقد علامت منتفي شده است .

پهناي (widit) يك نوع عدد صحيح را نبايد با ميزان حافظه اي كه مصرف مي كند اشتباه گرفت ، بلكه نشانه رفتاري است كه براي متغيرها و عبارات آن نوع تعريف مي شود . محيط حين اجراي جاوا از هر اندازه اي كه نياز داشته باشد ، استفاده مي كند ، البته تا آن اندازه اي كه انواع براساس اعلام قبلي شما رفتار كنند . در حقيقت ، حداقل يك پياده سازي byte وجود دارد كه ، short را بعنوان مقادير 32 بيتي ذخيره مي كند تا عملكرد را توسعه دهد. زيرا آنچه درحال حاضر مورد استفاده قرار مي گيرد ، اندازه كلمه (word size) اكثر كامپيوترهاست .


پهنا و دامنه اين انواع اعداد صحيح همانطوريكه در جدول زير مشاهده مي كنيد
طيف وسيعي دارند :


دامنه پهنا نام
long 64- 9/ 223/ 372/ 036/ 845/ 775/ 808 to 9/ 223/ 372
/036/ 854/ 775/ 807
int 32- 2/ 147/ 483/ 648 to 2/ 147/ 483/ 647
short 16- 32/ 768 to 32/ 767
byte 8- 128 to 127

اكنون نگاه دقيقتري به هر يك از انواع عدد صحيح خواهيم داشت .
byte

كوچكترين نوع عدد صحيح byte است . اين يك نوع علامت دار 8 بيتي است كه دامنه آن از 128- تا 127 مي باشد . متغيرهاي نوع byte بويژه هنگاميكه با يك جريان داده از يك شبكه يا يك فايل كار ميكنيد ، سودمند خواهند بود . همچنين هنگاميكه با داده دودويي ( باينري ) خام مشغول كار هستيد كه ممكن است بطور مستقيم با ساير انواع توكار جاوا سازگاري نداشته باشند ، بسيار سودمند هستند .

متغيرهاي byte را با استفاده از واژه كليدي byte اعلام مي كنيم . بعنوان
مثال ، در زير دو متغير byte با اسامي bو cو را اعلام كرده ايم : + byte b/ c;

short

يك نوع 16 بيتي علامت داراست . دامنه آن از 768 32/- تا 767 32/ است . short در اصل كم استفاده ترين نوع در جاوا مي باشد ، چون طوري تعريف شده كه بايت بالاي آن اول مي آيد ( آن را big-endian format ميگويند ). اين نوع براي كامپيوترهاي 16بيتي كه بسرعت از رده خارج شده اند ، كاربري دارد .

در زير مثالهايي از چگونگي اعلان متغيرهاي short را مشاهده مي كنيد : + short s;
+ short t;

نكته : Endiannes توصيف كننده چگونگي ذخيره شدن انواع داده چند بايتي short intو longو در حافظه است . اگر 2 بايت براي معرفي يك نوع short استفاده شود ، آن بايتي كه ابتدا قرار مي گيرد ( مهمترين يا كم اهميت ترين ? ) مي گويد كه يك ماشين big-endian است ، بدان معني كه مهمترين بايت اول آمده و بعد از آن بايت كم اهميت تر قرار دارد . ماشينهايي نظير SPARC و power pcاز نوع big-endian و ماشينهاي سري lntelx86نوع little-endianع هستند .

intرايجترين نوع عدد صحيح int است . اين يك نوع 32 بيتي علامت دار است كه دامنه آن از 2/147/483/648- تا 2/147/483/647 گسترده است . علاوه بر كاربردهاي ديگر متغيرهاي از نوع int براي كنترل حلقه ها و نمايه سازي آرايه ها مورد استفاده قرار مي گيرند . هر بار كه يك عبارت عدد صحيح شامل byte، short،و intو و ارقام لفظي
(literal) داشته باشيد، كل عبارت قبل از انجام محاسبات به int ارتقائ مي يابد.

نوع int روان ترين و كاراترين نوع است و اكثر اوقات هنگاميكه ميخواهيد رقمي را براي شمارش يا نمايه سازي آرايه ها يا انجام محاسبات عدد صحيح بوجود آوريد بايد از آن استفاده نماييد . شايد بنظر آيد كه استفاده از انواع shortو byteو سبب صرفه جويي در فضا شود ، اما هيچ تضميني وجود ندارد كه جاوا اين انواع را بطرق داخلي به int ارتقائ ندهد . همواره بياد داشته باشيد كه نوع ، مشخص كننده رفتار است نه اندازه . ( تنها استثنائ در اين مورد، آرايه است كه در آنجا byte بصورت تضميني براي هر عضو آرايه فقط يك بايت ، short دو بايت و int از چهار
بايت استفاده مي كند . )


long يك نوع 64 بيتي علامت دار است و براي مواردي مفيد است كه يك نوع int طول كافي براي دربرگرفتن مقدار مورد نظر نداشته باشد. دامنه long كاملا" وسيع است .

اين نوع ، براي كار با اعداد خيلي بزرگ مناسب است . بعنوان مثال ، در زير برنامه اي را مشاهده مي كنيد كه مسافت طي شده توسط نور در تعداد مشخص روز را بر حسب مايل محاسبه مي كند .


+ // Compute distance light travels using long variables.
+ class Light {
+ public static void main(String args[] ){
+ int lightspeed;
+ long days;
+ long seconds;
+ long distance;
+
+ // approximate speed of light in miles per second
+ lightspeed = 86000;
+
+ days = 1000; // specify number of days here
+
+ seconds = days * 24 * 60 * 60; // convert to seconds
+
+ distance = lightspeed * seconds; // compute distance
+
+ System.out.print("In " + days);
+ System.out.print(" days light will travel about ");
+ System.out.println(distance + " miles .");
+ }
+ }



خروجي اين برنامه بقرار زير خواهد بود : ln 1000 days light will travel about 4730400000000 miles

[B@RBOD]

انواع اعداد اعشاري جاوا

اعداد اعشاري يا همان اعداد حقيقي براي ارزش گذاري عبارتهايي كه نيازمند دقت بيشتري هستند ، استفاده مي شوند . بعنوان نمونه ، محاسباتي نظير ريشه دوم و محاسبات مثلثاتي نظير سينوس و كسينوس منجربه جوابهايي مي شوند كه براي تعيين دقت آن نياز به نوع عدد اعشاري مي باشد . جاوا يك مجموعه استاندارد (IEEE-754) از انواع عدد اعشاري و عملگرها را پياده سازي مي كند. دو نوع عدد اعشاري تعريف شده يعني floatو doubleو هستند كه بترتيب معرف دقت معمولي و مضاعف مي باشند .

پهنا و دامنه آنها را در زير نشان داده ايم :
دامنه پهنا بر حسب تعداد بيت نام
double 64 1.7e-308 to 1.7e+308
float 32 3.4e-038 to 3.4e+038

هر يك از انواع اعشاري را متعاقبا" مورد بررسي قرار مي دهيم .

floatاين نوع مشخص كننده يك مقدار با دقت معمولي بوده كه از 32 بايت حافظه استفاده مي كند . دقت معمول روي بعضي پردازنده ها سريعتر بوده و نسبت به دقت مضاعف نيمي از فضا را اشغال مي كند ، اما هنگاميكه مقادير خيلي بزرگ يا خيلي كوچك باشند ، دقت خود را از دست ميدهد . متغيرهاي نوع float براي زماني مناسب
هستند كه از يك عضو كسري استفاده مي كنيد اما نيازي به دقت خيلي زياد نداريد .

بعنوان مثال ، نوع float براي معرفي دلار و سنت بسيار مناسب است . + float hightemp/ lowtemp;

double دقت مضاعف كه با واژه كليدي double معين مي شود براي ذخيره كردن يك مقدار 64بيت فضا را اشغال مي كند . دقت مضاعف روي برخي پردازنده هاي جديد كه براي محاسبات رياضي با سرعت زياد بهينه شده اند ، واقعا" سريعتر از دقت معمولي عمل مي كند . كليه توابع مثلثاتي نظير ()sin ، ()cos و ()sqrt مقادير مضاعف را
برمي گردانند . هنگام اجراي محاسبات مكرر كه نياز به حفظ دقت داريد و يا هنگام كار با ارقام خيلي بزرگ double بهترين انتخاب است .

در زير برنامه اي را مشاهده مي كنيد كه از double استفاده نمود تا محيط يك دايره را محاسبه كند :

+ // Compute the area of a circle.
+ class Area {
+ public static void main(String args[] ){
+ double pi/ r/ a;
+
+ r = 10.8; // radius of circle
+ pi = 3.1416; // pi/ approximately
+ a = pi * r * r; // compute area
+
+ System.out.println("Area of circle is " + a);
+ }
+ }



كاراكترها
در جاوا از نوع داده char براي ذخيره كردن كاراكترها استفاده مي شود . اما برنامه نويسان Cو C++و آگاه باشند كه char در جاوا مشابه char در زبانهاي C و C++ نيست . در زبانهاي Cو C++و ، نوع char يك نوع عدد صحيح با پهناي 8 بيت است . اما جاوا متفاوت عمل مي كند . جاوا از كدهاي جهاني (unicode) براي معرفي كاراكترها استفاده مي كند . كدهاي جهاني يك مجموعه كاملا" جهاني از كاراكترها هستند كه مي توانند همه كاراكترها را معرفي نمايند . اين مجموعه شامل دهها مجموعه كوچك تر كاراكتري نظير Latin، Greek،، Arabic،، Cyrillic،، Hebrew، Katakana، Hangul، و امثال آن است .

براي اين منظور ، 16 بيت مورد نياز است . بنابراين char در جاوا يك نوع 16 بيتي است . دامنه charاز 0ز تا 65/536 مي باشد . در نوع char مقدار منفي وجود ندارد . مجموعه استاندارد كاراكترها موسوم به ASCII همچون گذشته داراي دامنه از 0 تا 127 و مجموعه كاراكترهاي 8 بيتي توسعه يافته موسوم به lso-Latin-1 داراي دامنه از 0 تا 255 مي باشند .

چون در جاوا امكان نوشتن ريز برنامه ها براي كاربري جهاني وجود دارد ، بنظر مي رسد كه بهتر است جاوا از كدهاي جهاني براي معرفي كاراكترها استفاده نمايد .

البته بكار بردن كدهاي جهاني درمورد زبانهايي نظير انگليسي ،آلماني ،اسپانيايي يا فرانسوي كه كاراكترهاي آنها را مي توان براحتي داخل 8 بيت جاي داد ، تا حدي سبب نزول كارآيي خواهد شد . اما اين بهايي است كه براي رسيدن به قابليت حمل جهاني در برنامه ها بايد پرداخت .

در زير برنامه اي را مشاهده مي كنيد كه متغيرهاي char را نشان مي دهد :

+ // Demonstrate char data type.
+ class CharDemo {
+ public static void main(String args[] ){
+ char ch1/ ch2;
+
+ ch1 = 88; // code for X
+ ch2 = 'Y';
+
+ System.out.print("ch1 and ch2 :");
+ System.out.println(ch1 + " " + ch2);
+ }
+ }

اين برنامه خروجي زير را نشان خواهد داد : ch1 and ch2 :xy

دقت كنيد كه مقدار 88به ch1 نسبت داده شده ، كه مقدار متناظر با حرف x در كد ASCII ( و كد جهاني ) است . قبلا" هم گفتيم كه مجموعه كاراكتري ASCII َ127 مقدار اوليه در مجموعه كاراكتري كدهاي جهاني را اشغال كرده است . بهمين دليل كليه فوت و فنهاي قديمي كه قبلا" با كاراكترها پياده كرده ايد ، در جاوا نيز به خوبي جواب مي دهند .

اگر چه انواع char عدد صحيح محسوب نمي شوند ، اما در بسياري از شرايط مي توانيد مشابه عدد صحيح با آنها رفتار كنيد . بدين ترتيب قادريد دو كاراكتر را با هم جمع نموده و يا اينكه مقدار يك متغير كاركتري را كاهش دهيد . بعنوان مثال ، برنامه زير را در نظر بگيريد :

+ // char variables behave like integers.
+ class CharDemo2 {
+ public static void main(String args[] ){
+ char ch1;
+
+ ch1 = 'X';
+ System.out.println("ch1 contains " + ch1);
+
+ ch1++; // increment ch1
+ System.out.println("ch1 is now " + ch1);
+ }
+ }

خروجي اين برنامه بشرح زير خواهد بود : ch1 contains x
ch1 is now y

در برنامه ابتدا مقدار xبه ch1 داده ميشود . سپس ch1 افزايش مي يابد . اين روال باعث مي شود تا ch1 حرف y را اختيار كند، كه كاراكتر بعدي در ترتيب ASCII ( و كدهاي جهاني ) مي باشد .
Boolean

جاوا يك نوع ساده موسوم به boolean براي مقادير منطقي دارد . اين نوع فقط يكي از مقادير ممكن trueيا falseا را اختيار مي كند . اين نوعي است كه توسط كليه عملگرهاي رابطه اي نظير bشرطي كه دستورهاي كنترلي نظير ifو forو را مديريت مي كنند ، استفاده مي شود .

در زير برنامه اي مشاهده مي كنيد كه نوع boolean را نشان مي دهد :

+ // Demonstrate boolean values.
+ class BoolTest {
+ public static void main(String args[] ){
+ boolean b;
+
+ b = false;
+ System.out.println("b is " + b);
+ b = true;
+ System.out.println("b is " + b);
+
+ // a boolean value can control the if statement
+ if(b )System.out.println("This is executed.");
+
+ b = false;
+ if(b )System.out.println("This is not executed.");
+
+ // outcome of a relational operator is a boolean value
+ System.out.println("10 > 9 is " +( 10 > 9));
+ }
+ }

خروجي برنامه فوق بقرار زير خواهد بود :

b is false
b is true
This is executed.
10>9 is true

درباره اين برنامه سه نكته جالب توجه وجود دارد . اول اينكه وقتي كه مقدار booleanتوسط ()println خارج مي شود ، مي بينيد كه "true"يا "false"ا بنمايش درمي آيد . دوم اينكه يك متغير boolean بتنهايي براي كنترل دستور if كفايت مي كند . ديگر نيازي به نوشتن يك دستور if بقرار زير نخواهد بود : + if(b == true... )

سوم اينكه ، پي آمد يك عملگر رابطه اي نظيربولين يک مقدار است .

[B@RBOD]

انواع اعداد اعشاري جاوا

اعداد اعشاري يا همان اعداد حقيقي براي ارزش گذاري عبارتهايي كه نيازمند دقت بيشتري هستند ، استفاده مي شوند . بعنوان نمونه ، محاسباتي نظير ريشه دوم و محاسبات مثلثاتي نظير سينوس و كسينوس منجربه جوابهايي مي شوند كه براي تعيين دقت آن نياز به نوع عدد اعشاري مي باشد . جاوا يك مجموعه استاندارد (IEEE-754) از انواع عدد اعشاري و عملگرها را پياده سازي مي كند. دو نوع عدد اعشاري تعريف شده يعني floatو doubleو هستند كه بترتيب معرف دقت معمولي و مضاعف مي باشند .

پهنا و دامنه آنها را در زير نشان داده ايم :
دامنه پهنا بر حسب تعداد بيت نام
double 64 1.7e-308 to 1.7e+308
float 32 3.4e-038 to 3.4e+038

هر يك از انواع اعشاري را متعاقبا" مورد بررسي قرار مي دهيم .

floatاين نوع مشخص كننده يك مقدار با دقت معمولي بوده كه از 32 بايت حافظه استفاده مي كند . دقت معمول روي بعضي پردازنده ها سريعتر بوده و نسبت به دقت مضاعف نيمي از فضا را اشغال مي كند ، اما هنگاميكه مقادير خيلي بزرگ يا خيلي كوچك باشند ، دقت خود را از دست ميدهد . متغيرهاي نوع float براي زماني مناسب
هستند كه از يك عضو كسري استفاده مي كنيد اما نيازي به دقت خيلي زياد نداريد .

بعنوان مثال ، نوع float براي معرفي دلار و سنت بسيار مناسب است . + float hightemp/ lowtemp;

double دقت مضاعف كه با واژه كليدي double معين مي شود براي ذخيره كردن يك مقدار 64بيت فضا را اشغال مي كند . دقت مضاعف روي برخي پردازنده هاي جديد كه براي محاسبات رياضي با سرعت زياد بهينه شده اند ، واقعا" سريعتر از دقت معمولي عمل مي كند . كليه توابع مثلثاتي نظير ()sin ، ()cos و ()sqrt مقادير مضاعف را
برمي گردانند . هنگام اجراي محاسبات مكرر كه نياز به حفظ دقت داريد و يا هنگام كار با ارقام خيلي بزرگ double بهترين انتخاب است .

در زير برنامه اي را مشاهده مي كنيد كه از double استفاده نمود تا محيط يك دايره را محاسبه كند :

+ // Compute the area of a circle.
+ class Area {
+ public static void main(String args[] ){
+ double pi/ r/ a;
+
+ r = 10.8; // radius of circle
+ pi = 3.1416; // pi/ approximately
+ a = pi * r * r; // compute area
+
+ System.out.println("Area of circle is " + a);
+ }
+ }



كاراكترها
در جاوا از نوع داده char براي ذخيره كردن كاراكترها استفاده مي شود . اما برنامه نويسان Cو C++و آگاه باشند كه char در جاوا مشابه char در زبانهاي C و C++ نيست . در زبانهاي Cو C++و ، نوع char يك نوع عدد صحيح با پهناي 8 بيت است . اما جاوا متفاوت عمل مي كند . جاوا از كدهاي جهاني (unicode) براي معرفي كاراكترها استفاده مي كند . كدهاي جهاني يك مجموعه كاملا" جهاني از كاراكترها هستند كه مي توانند همه كاراكترها را معرفي نمايند . اين مجموعه شامل دهها مجموعه كوچك تر كاراكتري نظير Latin، Greek،، Arabic،، Cyrillic،، Hebrew، Katakana، Hangul، و امثال آن است .

براي اين منظور ، 16 بيت مورد نياز است . بنابراين char در جاوا يك نوع 16 بيتي است . دامنه charاز 0ز تا 65/536 مي باشد . در نوع char مقدار منفي وجود ندارد . مجموعه استاندارد كاراكترها موسوم به ASCII همچون گذشته داراي دامنه از 0 تا 127 و مجموعه كاراكترهاي 8 بيتي توسعه يافته موسوم به lso-Latin-1 داراي دامنه از 0 تا 255 مي باشند .

چون در جاوا امكان نوشتن ريز برنامه ها براي كاربري جهاني وجود دارد ، بنظر مي رسد كه بهتر است جاوا از كدهاي جهاني براي معرفي كاراكترها استفاده نمايد .

البته بكار بردن كدهاي جهاني درمورد زبانهايي نظير انگليسي ،آلماني ،اسپانيايي يا فرانسوي كه كاراكترهاي آنها را مي توان براحتي داخل 8 بيت جاي داد ، تا حدي سبب نزول كارآيي خواهد شد . اما اين بهايي است كه براي رسيدن به قابليت حمل جهاني در برنامه ها بايد پرداخت .

در زير برنامه اي را مشاهده مي كنيد كه متغيرهاي char را نشان مي دهد :

+ // Demonstrate char data type.
+ class CharDemo {
+ public static void main(String args[] ){
+ char ch1/ ch2;
+
+ ch1 = 88; // code for X
+ ch2 = 'Y';
+
+ System.out.print("ch1 and ch2 :");
+ System.out.println(ch1 + " " + ch2);
+ }
+ }

اين برنامه خروجي زير را نشان خواهد داد : ch1 and ch2 :xy

دقت كنيد كه مقدار 88به ch1 نسبت داده شده ، كه مقدار متناظر با حرف x در كد ASCII ( و كد جهاني ) است . قبلا" هم گفتيم كه مجموعه كاراكتري ASCII َ127 مقدار اوليه در مجموعه كاراكتري كدهاي جهاني را اشغال كرده است . بهمين دليل كليه فوت و فنهاي قديمي كه قبلا" با كاراكترها پياده كرده ايد ، در جاوا نيز به خوبي جواب مي دهند .

اگر چه انواع char عدد صحيح محسوب نمي شوند ، اما در بسياري از شرايط مي توانيد مشابه عدد صحيح با آنها رفتار كنيد . بدين ترتيب قادريد دو كاراكتر را با هم جمع نموده و يا اينكه مقدار يك متغير كاركتري را كاهش دهيد . بعنوان مثال ، برنامه زير را در نظر بگيريد :

+ // char variables behave like integers.
+ class CharDemo2 {
+ public static void main(String args[] ){
+ char ch1;
+
+ ch1 = 'X';
+ System.out.println("ch1 contains " + ch1);
+
+ ch1++; // increment ch1
+ System.out.println("ch1 is now " + ch1);
+ }
+ }

خروجي اين برنامه بشرح زير خواهد بود : ch1 contains x
ch1 is now y

در برنامه ابتدا مقدار xبه ch1 داده ميشود . سپس ch1 افزايش مي يابد . اين روال باعث مي شود تا ch1 حرف y را اختيار كند، كه كاراكتر بعدي در ترتيب ASCII ( و كدهاي جهاني ) مي باشد .
Boolean

جاوا يك نوع ساده موسوم به boolean براي مقادير منطقي دارد . اين نوع فقط يكي از مقادير ممكن trueيا falseا را اختيار مي كند . اين نوعي است كه توسط كليه عملگرهاي رابطه اي نظير bشرطي كه دستورهاي كنترلي نظير ifو forو را مديريت مي كنند ، استفاده مي شود .

در زير برنامه اي مشاهده مي كنيد كه نوع boolean را نشان مي دهد :

+ // Demonstrate boolean values.
+ class BoolTest {
+ public static void main(String args[] ){
+ boolean b;
+
+ b = false;
+ System.out.println("b is " + b);
+ b = true;
+ System.out.println("b is " + b);
+
+ // a boolean value can control the if statement
+ if(b )System.out.println("This is executed.");
+
+ b = false;
+ if(b )System.out.println("This is not executed.");
+
+ // outcome of a relational operator is a boolean value
+ System.out.println("10 > 9 is " +( 10 > 9));
+ }
+ }

خروجي برنامه فوق بقرار زير خواهد بود :

b is false
b is true
This is executed.
10>9 is true

درباره اين برنامه سه نكته جالب توجه وجود دارد . اول اينكه وقتي كه مقدار booleanتوسط ()println خارج مي شود ، مي بينيد كه "true"يا "false"ا بنمايش درمي آيد . دوم اينكه يك متغير boolean بتنهايي براي كنترل دستور if كفايت مي كند . ديگر نيازي به نوشتن يك دستور if بقرار زير نخواهد بود : + if(b == true... )

سوم اينكه ، پي آمد يك عملگر رابطه اي نظيربولين يک مقدار است .

[B@RBOD]

متغيرها و اعمال روی آنها

در يك برنامه جاوا ، متغير ، اساسي ترين واحد ذخيره سازي است . يك متغير به وسيله تركيبي از يك شناسه ، يك نوع و يك مقدار ده اوليه اختياري تعريف خواهد شد . علاوه بر اين ، كليه متغيرها داراي يك قلمرو هستند كه رويت پذيري آنها را تعريف مي كند و يك زمان حيات نيز دارند. متعاقبا" اين اجزائ را مورد بررسي
قرار مي دهيم .

اعلان يك متغير Declaring a variable
در جاوا كليه متغيرها قبل از استفاده بايد اعلان شوند . شكل اصلي اعلان متغير بقرار زير مي باشد : type identifier [=value] [/identifier[=value]...];

مقدار شناسه مقدار شناسه نوع نوع (type) يكي از انواع اتمي جاوا يا نام يك كلاس يا رابط است . ( انواع
كلاس و رابط بعدا" بررسي خواهد شد . ) شناسه نام متغير است . مي توانيد با گذاشتن يك علامت تساوي و يك مقدار ، متغير را مقدار دهي اوليه نماييد . در ذهن بسپاريد كه عبارت مقدار دهي اوليه بايد منتج به يك مقدار از همان نوعي ( يا سازگار با آن نوع ) كه براي متغير مشخص شده ، گردد . براي اعلان بيش از يك نوع مشخص شده ، از فهرست كاماهاي (') جدا كننده استفاده نماييد .

در زير مثالهايي از اعلان متغير از انواع گوناگون را مشاهده مي كنيد . دقت كنيد كه برخي از آنها شامل يك مقدار دهي اوليه هستند .


+ int a/ b/ c; // declares three ints/ a/ b/ and c.
+ int d = 3/ e/ f = 5; // declares three more ints/ initializing
+ // d and f.
+ byte z = 22; // initializes z.
+ double pi = 3.14159; // declares an approximation of pi.
+ char x = 'x'; // the variable x has the value 'x'.



شناسه هايي كه انتخاب مي كنيد هيچ عامل ذاتي در نام خود ندارند كه نوع آنها را مشخص نمايد . بسياري از خوانندگان بياد مي آورند زماني را كه FORTRAN كليه شناسه هاي از Iتا Nا را پيش تعريف نمود تا از نوع NTEGER باشند ، در حاليكه ساير شناسه ها از نوع REAL بودند . جاوا به هر يك از شناسه هاي متناسب شكل گرفته
امكان اختيار هر نوع اعلان شده را داده است .

مقدار دهي اوليه پويا Dynamic intialization اگر چه مثالهاي قبلي از ثابت ها بعنوان مقدار ده اوليه استفاده كرده اند اما جاوا امكان مقداردهي اوليه بصورت پويا را نيز فراهم آورده است . اين موضوع با استفاده از هر عبارتي كه در زمان اعلان متغير باشد ، انجام مي گيرد .

بعنوان مثال ، در زير برنامه كوتاهي را مشاهده مي كنيد كه طول ضلع يك مثلث قائم الزاويه را با داشتن طول دو ضلع مقابل محاسبه مي كند :


+ // Demonstrate dynamic initialization.
+ class DynInit {
+ public static void main(String args[] ){
+ double a = 3.0/ b = 4.0;
+ // c is dynamically initialized
+ double c = Math.sqrt(a * a + b * b);
+
+ System.out.println("Hypotenuse is " + c);
+ }
+ }



در اينجا سه متغير محلي a، b،، c، اعلان شده اند . دو تاي اولي توسط ثابت ها مقدار دهي اوليه شده اند . اما متغير C بصورت پويا و بر حسب طول اضلاع مثلث قائم الزاويه ( بنابر قانون فيثاغورث ) مقدار دهي اوليه مي شود . اين برنامه از يكي از روشهاي توكار جاوا يعني ()sqrt كه عضوي از كلاس Math بوده و ريشه دوم آرگومانهاي خود را محاسبه ميكند استفاده كرده است . نكته كليدي اينجا است كه عبارت مقدار دهي اوليه ممكن است از هر يك از اجزائ معتبر در زمان مقدار دهي اوليه ، شامل فراخواني روشها ، ساير متغيرها يا الفاظ استفاده نمايد .

قلمرو زمان حيات متغيرها

تابحال كليه متغيرهاي استفاده شده ، در زمان شروع روش ()main اعلان مي شدند.
اما جاوا همچنين به متغيرها امكان مي دهد تا درون يك بلوك نيز اعلام شوند .

همانطوريكه قبلا" توضيح داديم ، يك بلوك با يك ابرو باز و يك ابرو بسته محصور مي شود : يك بلوك تعريف كننده يك قلمرو است . بدين ترتيب هر بار كه يك بلوك جديد را شروع ميكنيد ، يك قلمرو جديد نيز بوجود مي آوريد . همانطوريكه احتمالا" از تجربيات برنامه نويسي قبلي بياد داريد ، يك قلمرو (scope) تعيين كننده آن است كه چه اشيائي براي ساير بخشهاي برنامه قابل رويت هستند . اين قلمرو همچنين زمان حيات (lifetime) آن اشيائ را تعيين مي كند .

اكثر زبانهاي كامپيوتري دو طبقه بندي از قلمروها را تعريف مي كنند : سراسري (global) و محلي (local) . اما اين قلمروهاي سنتي بخوبي با مدل موكد شي ئ گرايي جاوا مطابقت ندارند . اگر چه در جاوا هم مي توان مقاديري را بعنوان قلمرو سراسري ايجاد نمود ، اما اين فقط يك نوع استثنائ است و عموميت ندارد . در جاوا قلمرو اصلي همانهايي هستند كه توسط يك كلاس يا يك روش تعريف مي شوند . حتي همين تمايز نيز تا حدي ساختگي و مصنوعي است . اما از آنجاييكه قلمرو كلاس داراي مشخصات و خصلتهاي منحصر بفردي است كه قابل استفاده در قلمرو تعريف شده توسط روش نيست ، اين تمايز تا حدي محسوس خواهد بود . بخاطر تفاوتهاي موجود ، بحث
قلمرو كلاس ( و متغيرهاي اعلان شده داخل آن ) اين مبحث بتعوق افتاده است . در حال حاضر فقط قلمروهاي تعريف شده توسط يك روش يا داخل يك روش را بررسي مي كنيم .

قلمرو تعريف شده توسط يك روش با يك ابروي باز شروع مي شود. اما اگر آن روش داراي پارامترهايي باشد ، آنها نيز داخل قلمرو روش گنجانده خواهند شد . بعدا" نگاه دقيقتري به پارامترها خواهيم داشت و فعلا" كافي است بدانيم كه پارامترها مشابه هر متغير ديگري در يك روش كار مي كنند .

بعنوان يك قانون عمومي ، متغيرهاي اعلان شده داخل يك قلمرو براي كدهايي كه خارج از قلمرو تعريف مي شوند ، قابل رويت نخواهند بود ( قابل دسترسي نيستند ).

بدين ترتيب ، هنگاميكه يك متغير را درون يك قلمرو اعلان مي كنيد ، در حقيقت آن متغير را محلي دانسته و آن را در مقابل دستيابيها و تغييرات غير مجاز محافظت مي كنيد . در حقيقت ، قوانين قلمرو اساس كپسول سازي را فراهم مي كنند .

قلمروها را مي توان بصورت تودرتو (nesting) محفوظ داشت . بعنوان مثال ، هر زمان يك بلوك كد ايجاد كنيد ، يك قلمرو جديد تودرتو ايجاد نموده ايد . هنگاميكه اين واقعه روي مي دهد ، قلمرو بيروني ، قلمرو دروني را دربرمي گيرد . اين بدان معني است كه اشيائ اعلان شده در قلمرو بيروني براي كدهاي داخل قلمرو دروني قابل
رويت هستند اما عكس اين قضيه صادق نيست . اشيائاعلان شده داخل قلمرو دروني براي بيرون قلمرو قابل رويت نخواهند بود .

براي درك تاثير قلمروهاي تودرتو ، برناه ريز را در نظر بگيريد :

+ // Demonstrate block scope.
+ class Scope {
+ public static void main(String args[] ){
+ int x; // known to all code within main
+
+ x = 10;
+ if(x == 10 ){ // start new scope
+ int y = 20; // known only to this bock
+
+ // x and y both known here.
+ System.out.println("x and y :" + x + " " + y);
+ x = y * 2;
+ }
+ // y = 100 :// Error! y not known here
+
+ // x is still known here.
+ System.out.println("x is " + x);
+ }
+ }



همانطوريكه توضيحات نشان مي دهند ، متغير x در ابتداي قلمروي ()main اعلان شده و براي كليه كدهاي متعاقب داخل ()main قابل دسترسي مي باشد . داخل بلوك if متغير y اعلان شده است . از آنجاييكه يك بلوك معرف يك قلمرو است ، y فقط براي ساير كدهاي داخل بلوك خود قابل رويت است . اين دليل آن است كه خارج بلوك مربوطه ، خط y=100 در خارج توضيح داده شده است . اگر نشانه توضيح راهنمايي را تغيير مكان دهيد ، يك خطاي زمان كامپايل (compile-time error) اتفاق مي افتد چون y براي بيرون از بلوك خود قابل رويت نيست . داخل بلوك if متغير x قابل استفاده است زيرا كدهاي داخل يك بلوك ( منظور يك قلمرو تودرتو شده است ) به متغيرهاي اعلان شده در يك قلمرو دربرگيرنده دسترسي دارند .

داخل يك بلوك ، در هر لحظه اي مي توان متغيرها را اعلان نمود ، اما فقط زماني معتبر مي شوند كه اعلان شده باشند . بدين ترتيب اگر يك متغير را در ابتداي يك روش اعلان مي كنيد، براي كليه كدهاي داخل آن روش قابل دسترس خواهد بود. بالعكس اگر يك متغير را در انتهاي يك بلوك اعلان كنيد ، هيچ فايده اي ندارد چون هيچيك
از كدها به آن دسترسي ندارند . بعنوان مثال اين قطعه از برنامه غير معتبر است چون نمي توان از count قبل از اعلان آن استفاده نمود :



+ // This fragment is wrong!
+ count = 100; // oops! cannot use count before it is declared!
+ int count;



يك نكته مهم ديگر در اينجا وجود دارد كه بايد بخاطر بسپاريد: متغيرها زماني ايجاد مي شوند كه قلمرو آن ها وارد شده باشد ، و زماني خراب مي شوند كه قلمرو آنها ترك شده باشد . يعني يك متغير هربار كه خارج از قلمروش برود ، ديگر مقدار خود را نگهداري نخواهد كرد . بنابراين ، متغيرهاي اعلان شده داخل يك روش مقادير خود را بين فراخواني هاي آن روش نگهداري نمي كنند . همچنين يك متغير اعلان شده داخل يك بلوك ، وقتي كه بلوك ترك شده باشد ، مقدار خود را از دست خواهد داد .

بنابراين ، زمان حيات (lifetime) يك متغير محدود به قلمرو آن مي باشد .
اگر اعلان يك متغير شامل مقدار دهي اوليه آن باشد ، آنگاه هر زمان كه به بلوك مربوطه وارد شويم ، آن متغير مجددا" مقدار دهي اوليه خواهد شد . بعنوان مثال برنامه زير را در نظر بگيريد :


+ // Demonstrate lifetime of a variable.
+ class LifeTime {
+ public static void main(String args[] ){
+ int x;
+
+ for(x = 0; x < 3; x++ ){
+ int y =- 1; // y is initialized each time block is entered
+ System.out.println("y is :" + y); // this always prints- 1
+ y = 100;
+ System.out.println("y is now :" + y);
+ }
+ }
+ }

خروجي توليد شده توسط اين برنامه بقرار زير است :


y is- :1
y is now:100
y is- :1
y is now:100
y is- :1
y is now:100



همانطوريكه مشاهده مي كنيد ، هر بار كه به حلقه for داخلي وارد مي شويم ، y همواره بطور مكرر مقدار اوليه 1- را اختيار مي كند . اگر چه بلافاصله به اين متغير مقدار 100 نسبت داده مي شود، اما هر بار نيز مقدار خود را از دست ميدهد.

و بالاخره آخرين نكته : اگر چه ميتوان بلوكها را تودرتو نمود، اما نميتوانيد متغيري را اعلان كنيد كه اسم آن مشابه اسم متغيري در قلمرو بيروني باشد. از اين نظر جاوا با زبانهاي Cو C++و متفاوت است . در زير مثالي را مشاهده مي كنيد كه در آن تلاش شده تا دو متغير جدا از هم با اسم اعلان شوند . در جاوا اينكار مجاز نيست . در Cو C++و اين امر مجاز بوده و دو bar كاملا" جدا خواهند ماند .

+ // This program will not compile
+ class ScopeErr {
+ public static void main(String args[] ){
+ int bar = 1;
+ { // creates a new scope
+ int bar = 2; // Compile-time error -- bar already defined!
+ }
+ }
+ }

[B@RBOD]

تبديل خودكار و تبديل غير خودكار انواع

اگر تجربه قبلي برنامه نويسي داشته ايد ، پس مي دانيد كه كاملا" طبيعي است كه مقداري از يك نوع را به متغيري از نوع ديگر نسبت دهيم . اگر اين دو نوع سازگار باشند ، آنگاه جاوا بطور خودكار اين تبديل (conversion) را انجام مي دهد .

بعنوان مثال ، همواره امكان دارد كه مقدار int را به يك متغير long نسبت داد .
اما همه انواع با يكديگر سازگاري ندارند ، بنابراين هر گونه تبديل انواع مجاز نخواهد بود . بعنوان نمونه ، هيچ تبديلي از doubleبه byte تعريف نشده است .

خوشبختانه ، امكان انجام تبديلات بين انواع غير سازگار هم وجود دارد . براي انجام اينكار ، بايد از تبديل cast استفاده كنيد كه امكان يك تبديل صريح بين انواع غير سازگار را بوجود مي آورد . اجازه دهيد تا نگاه دقيقتري به تبديل خودكار انواع و تبديل cast داشته باشيم .

[B@RBOD]

تبديل خودكار در جاوا Java's Automatic conyersions

هنگاميكه يك نوع داده به يك متغير از نوع ديگر نسبت داده مي شود ، اگر دو شرط زير فراهم باشد ، يك تبديل خودكار نوع انجام خواهد شد :
ؤ دو نوع با يكديگر سازگار باشند .
ؤ نوع مقصد بزرگتر از نوع منبع باشد .
هنگاميكه اين دو شرط برقرار باشد ، يك تبديل پهن كننده (widening) اتفاق مي افتد . براي مثال نوع int همواره باندازه كافي بزرگ است تا كليه مقادير معتبر byte را دربرگيرد، بنابراين نيازي به دستور صريح تبديل cast وجود ندارد.

در تبديلات پهن كننده ، انواع رقمي شامل انواع عدد صحيح و عدد اعشاري با هر يك از انواع سازگاري دارند . اما انواع رقمي با انواع charو booleanو سازگار نيستند . همچنين انواع charو booleanو با يكديگر سازگار نيستند .
همانطوريكه قبلا" ذكر شد ، جاوا هنگام ذخيره سازي يك ثابت عدد صحيح لفظي (Literal integer constant) به متغيرهاي از انواع byte، short،و longو ، يك تبديل خودكار نوع را انجام مي دهد .

[B@RBOD]

تبديل غير خودكار انواع ناسازگار
اگر چه تبديلات خودكار انواع بسيار سودمند هستند ، اما جوابگوي همه نيازها نيستند . بعنوان مثال ، ممكن است بخواهيد يك مقدار int را به يك متغير byte نسبت دهيد. اين تبديل بطور خودكار انجام نمي گيرد، زيرا يك byteاز intز كوچكتر است .اين نوع خاص از تبديلات را گاهي تبديل باريك كننده (narrowing conversions) مي نامند ، زيرا بطور صريح مقدار را آنقدر باريك تر و كم عرض تر مي كنيد تا با نوع هدف سازگاري يابد .

براي ايجاد يك تبديل بين دو نوع ناسازگار ، بايد از cast استفاده نماييد . castيك تبديل نوع كاملا" صريح است . شكل عمومي آن بقرار زير مي باشد : ( target - type )value

نوع نوع مقصد يا هدف
در اينجا نوع هدف ، همان نوعي است كه مايليم مقدار مشخص شده را به آن تبديل كنيم . بعنوان مثال ، قطعه زير از يك برنامه تبديل غير خودكار از intبه byte را اجرا مي كند . اگر مقدار integer بزرگتر از دامنه يك byte باشد ، اين مقدار به مدول ( باقيمانده تقسيم يك integer بر دامنه ) byte كاهش خواهد يافت .

+ int a;
+ byte b;
+ //...
+ b =( byte )a;

هر گاه كه يك مقدار اعشاري به يك عدد صحيح نسبت داده شود ، شكل ديگري از تبديل اتفاق مي افتد : بريدن ، truncation . همانطوريكه مي دانيد ، اعداد صحيح داراي قسمت اعشاري نيستند . بنابراين هنگاميكه يك مقدار اعشاري به يك نوع عدد صحيح نسبت داده مي شود ، جزئ اعشاري از بين خواهد رفت ( بريده خواهد شد ) .
بعنوان مثال ، اگر مقدار 1.23 را به يك عدد صحيح نسبت دهيم ، مقدار حاصله فقط عدد 1 مي باشد . مقدار 0.23 بريده (truncated) خواهد شد . البته اگر اندازه اجزائ عدد كلي آنچنان بزرگ باشد كه در نوع عدد صحيح مقصد نگنجد ، آنگاه مقدار فوق به مدول دامنه نوع هدف كاهش خواهد يافت .

برنامه زير نشان دهنده برخي از تبديلات انواع است كه مستلزم تبديل cast
مي باشند :

+ // Demonstrate casts.
+ class Conversion {
+ public static void main(String args[] ){
+ bytt b;
+ int i = 257;
+ double d = 323.142;
+
+ System.out.println("\nConversion of int to byte.");
+ b =( byte )i;
+ System.out.println("i and b " + i + " " + b);
+
+ System.out.println("\nConversion of double to int.");
+ i =( int )d;
+ System.out.println("d and i " + d + " " + i);
+
+ System.out.println("\nConversion of double to byte.");
+ b =( byte )d;
+ System.out/println("d and b " + d + " " + b);
+ }
+ }

خروجي اين برنامه بقرار زير مي باشد :


Conversion of int to byte.
i and b 257 1

Conversion of double to int.
d and i 323.142 323

Conversion of double to byte.
d and b 323.142 67

[B@RBOD]

آرايه ها در جاوا

يك آرايه گروهي از متغيرهاي يك نوع است كه با يك نام مشترك به آنها ارجاع مي شود . مي توان آرايه ها را براي هر يك از انواع ايجاد نمود و ممكن است اين آرايه ها داراي يك يا چندين بعد باشند . براي دسترسي به يك عضو آرايه از نمايه (index) آن آرايه استفاده مي شود . آرايه ها يك وسيله مناسب براي گروه بندي اطلاعات مرتبط با هم هستند .

نكته : اگر با Cو C++و آشنايي داريد ، آگاه باشيد . آرايه ها در جاوا بطور متفاوتي نسبت به زبانهاي ديگر كار مي كنند .

آرايه هاي يك بعدي

آرايه يك بعدي بطور ضروري فهرستي از متغيرهاي يكنوع است . براي ايجاد يك آرايه ، بايد يك متغير آرايه از نوع مورد نظرتان ايجاد كنيد . فرم عمومي اعلان يك آرايه يك بعدي بقرار زير است : type var-name [];

نام متغير نوع

در اينجا type اعلان كننده نوع اصلي آرايه است . نوع اصلي تعيين كننده نوع داده براي هر يك از اعضائ داخل در آرايه است . بنابراين ، نوع اصلي آرايه تعيين مي كند كه آرايه چه نوعي از داده را نگهداري مي كند . بعنوان مثال ، در زير يك آرايه با نام month-days با نوع آرايه اي از عدد صحيح اعلان شده است .

+ int month_days[];

اگر چه اين اعلان تثبيت مي كند كه month-days يك متغير آرايه است ، اما بطور واقعي آرايه اي وجود ندارد . در حقيقت ، مقدار month-days برابر تهي (null) مي باشد كه يك آرايه بدون مقدار را معرفي مي كند . براي پيوند دادن month-days با يك آرايه واقعي و فيزيكي از اعداد صحيح ، بايد از يك عملگر new استفاده نموده و به month-days منتسب كنيد. new يك عملگراست كه حافظه را اختصاص ميدهد.

بعداnew " را با دقت بيشتري بررسي مي كنيم ، اما لازم است كه هم اكنون از آن استفاده نموده و حافظه را براي آرايه ها تخصيص دهيد . فرم عمومي new آنگونه كه براي آرايه هاي يك بعدي بكار مي رود بقرار زير ظاهر خواهد شد :

array-var=new type [size];

اندازه نوع متغير آرايه
در اينجا type مشخص كننده نوع داده اي است كه تخصيص داده مي شود، size مشخص كننده تعداد اعضائ آرايه است و array-var متغير آرايه است كه به آرايه پيوند مي يابد . يعني براي استفاده از new در تخصيص يك آرايه ، بايد نوع و تعداد اعضايي كه تخصيص مي يابند را مشخص نماييد . اعضائ آرايه كه توسط new تخصيص مي يابند بطور خودكار با مقدار صفر مقدار دهي اوليه مي شوند . اين مثال يك آرايه 12 عضوي از اعداد صحيح را تخصيص داده و آنها را به month-days پيوند مي دهد .

+ month_days = new int[12];

بعد از اجراي اين دستور ، month-days به يك آرايه 12 تايي از اعداد صحيح ارجاع خواهد نمود . بعلاوه كليه اجزائ در آرايه با عدد صفر مقدار دهي اوليه خواهند شد .

اجازه دهيد مرور كنيم : بدست آوردن يك آرايه مستلزم پردازش دو مرحله اي است .

اول بايد يك متغير با نوع آرايه مورد نظرتان اعلان كنيد . دوم بايد حافظه اي كه آرايه را نگهداري مي كند ، با استفاده از new تخصيص دهيد و آن را به متغير آرايه نسبت دهيد . بنابراين در جاوا كليه آرايه ها بطور پويا تخصيص مي يابند .

اگر مفهوم تخصيص پويا براي شما ناآشناست نگران نباشيد . اين مفهوم را بعدا" تشريح خواهيم كرد .

هر بار كه يك آرايه را تخصيص مي دهيد ، مي توانيد بوسيله مشخص نمودن نمايه آن داخل كروشه [] به يك عضو مشخص در آرايه دسترسي پيدا كنيد . كليه نمايه هاي آرايه ها با عدد صفر شروع مي شوند. بعنوان مثال اين دستور مقدار 28 را به دومين عضو month-days نسبت مي دهد .

+ month_days[1] = 28;

خط بعدي مقدار ذخيره شده در نمايه 3 را نمايش مي دهد .
+ System.out.println(month_days[3]);

با كنار هم قرار دادن كليه قطعات ، در اينجا برنامه اي خواهيم داشت كه يك آرايه براي تعداد روزهاي هر ماه ايجاد مي كند .

+ // Demonstrate a one-dimensional array.
+ class Array {
+ public static void main(String args[] ){
+ int month_days[];
+ month_days = new int[12];
+ month_days [0] = 31;
+ month_days [1] = 28;
+ month_days [2] = 31;
+ month_days [3] = 30;
+ month_days [4] = 31;
+ month_days [5] = 30;
+ month_days [6] = 31;
+ month_days [7] = 31;
+ month_days [8] = 30;
+ month_days [9] = 31;
+ month_days [10] = 30;
+ month_days [11] = 31;
+ System.out.println("April has " + month_days[3] + " days .");
+ }
+ }

وقتي اين برنامه را اجرا ميكنيد ، برنامه ، تعداد روزهاي ماه آوريل را چاپ ميكند. همانطوريكه ذكر شد، نمايه هاي آرايه جاوا با صفر شروع مي شوند، بنابراين تعداد روزهاي ماه آوريل در month-days[3] برابر 30 مي باشد .
اين امكان وجود دارد كه اعلان متغير آرايه را با تخصيص خود آرايه بصورت زير تركيب نمود : + int month_days[] = new int[12]; اين همان روشي است كه معمولا" در برنامه هاي حرفه اي نوشته شده با جاوا مشاهده مي كنيد .
مي توان آرايه ها را زمان اعلانشان ، مقدار دهي اوليه نمود . پردازش آن بسيار مشابه پردازشي است كه براي مقدار دهي اوليه انواع ساده استفاده مي شود . يك مقدار ده اوليه آرايه فهرستي از عبارات جدا شده بوسيله كاما و محصور شده بين ابروهاي باز و بسته مي باشد . كاماها مقادير اجزائ آرايه را از يكديگر جدا مي كنند . آرايه بطور خودكار آنقدر بزرگ ايجاد مي شود تا بتواند ارقام اجزايي را كه در مقدار ده اوليه آرايه مشخص كرده ايد ، دربرگيرد . نيازي به استفاده از newوجود ندارد . بعنوان مثال ، براي ذخيره نمودن تعداد روزهاي هر ماه ، كد بعدي يك آرايه مقدار دهي اوليه شده از اعداد صحيح را بوجود مي آورد :


+ // An improved version of the previous program.
+ class AutoArray {
+ public static void main(String args[] ){
+ int month_days[] = { 31/ 28/ 31/ 30/ 31/ 30/ 31/ 31/ 30/ 31/ 30/ 31 };
+ System.out.println("April has " + month_days[3] + " days .");
+ }
+ }

وقتي اين برنامه را اجرا كنيد ، همان خروجي برنامه قبلي را خواهيد ديد .
جاوا بشدت كنترل مي كند تا مطمئن شود كه بطور تصادفي تلاشي براي ذخيره نمودن يا ارجاع مقاديري خارج از دامنه آرايه انجام ندهيد . سيستم حين اجراي جاوا كنترل مي كند كه كليه نمايه هاي آرايه ها در دامنه صحيح قرار داشته باشند . ( از اين نظر جاوا كاملا"با Cاو C++و متفاوت است كه هيچ كنترل محدوده اي در حين اجرا انجام نمي دهند . ) بعنوان مثال ، سيستم حين اجرا ، مقدار هر يك از نمايه ها به month-daysرا كنترل مي كند تا مطمئن شود كه بين ارقام 0 و 11 داخل قرار داشته باشند . اگر تلاش كنيد تا به اجزائ خارج از دامنه آرايه ( اعداد منفي يا اعدادي بزرگتر از طول آرايه ) دسترسي يابيد، يك خطاي حين اجرا (run-time error) توليد
خواهد شد .

در زير يك مثال پيچيده تر مشاهده مي كنيد كه از يك آرايه يك بعدي استفاده مي كند . اين برنامه ميانگين يك مجموعه از ارقام را بدست مي آورد .

+ // Average an array of values.
+ class Average {
+ public static void main(String args[] ){
+ double nums[] = {10.1/ 11.2/ 12.3/ 13.4/ 14.5};
+ double result = 0;
+ int i;
+
+ for(i=0; i<5; i++)
+ result = result + nums[i];
+
+ System.out.println("Average is " + result / 5);
+ }
+ }


آرايه هاي چند بعدي
در جاوا آرايه هاي چند بعدي در واقع آرايه اي از آرايه ها هستند . اين قضيه همانطوريكه انتظار داريد ظاهر و عملكردي مشابه آرايه هاي چندبعدي منظم (regular) دارد . اما خواهيد ديد كه تاوتهاي ظريفي هم وجود دارند . براي اعلان يك متغير آرايه چند بعدي ، با استفاده از مجموعه ديگري از كروشه ها هر يك از نمايه هاي اضافي را مشخص مي كنيد. بعنوان مثال ، عبارت زيرر يك متغير آرايه دو بعدي بنام twoDرا اعلان مي كند .

+ int twoD[][] = new int[4][5];

اين عبارت يك آرايه 4در 5ر را تخصيص داده و آن را به twoD نسبت مي دهد . از
نظر داخلي اين ماتريس بعنوان يك آرايه از آرايه نوع int پياده سازي خواهد شد .
بطور فرضي ، اين آرايه را مي توان بصورت شكل زير نمايش داد .

Right index determines column.

|| || || || ||
\/ \/ \/ \/ \/

|
| [0][4] | [0][3] | [0][2] | [0][1] | [0][0] >
|
| |
| [1][4] | [1][3] | [1][2] | [1][1] | [1][0] >
Left index
determines |
| [2][4] | [2][3] | [2][2] | [2][1] | [2][0] .> row
|
| |
| [3][4] | [3][3] | [3][2] | [3][1] | [3][0] >
Given :int twoD[][] = new int [4][5];



برنامه بعدي هر عضو آرايه را از چپ به راست ، و از بالا به پايين شماره داده و سپس مقادير آنها را نمايش مي دهد :

+ // Demonstrate a two-dimensional array.
+ class TwoDArray {
+ public static void main(String args[] ){
+ int twoD[][] = new int[4][5];
+ int i/ j/ k = 0;
+
+ for(i=0; i<4; i++)
+ for(j=0; j<5; j++ ){
+ twoD[i][j] = k;
+ k++;
+
+ }
+
+ for(i=0; i<4; i++ ){
+ for(j=0; j<5; j++)
+ System.out.print(twoD[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }

خروجي اين برنامه بقرار زير خواهد بود : 0 1 2 3 4

5 6 7 8 9
10 11 12 13 14
15 16 17 18 19

هنگام تخصيص حافظه به يك آرايه چند بعدي ، كافي است فقط حافظه براي اولين بعد را مشخص نماييد . مي توانيد ابعاد ديگر را جداگانه تخصيص دهيد . بعنوان مثال ، كد زير حافظه اولين بعد twoD را هنگام اعلان آن تخصيص مي دهد . اين كد حافظه دومين بعد را بصورت دستي اختصاص مي دهد .

+ int twoD[][] = new int[4][];
+ twoD[0] = new int[5];
+ twoD[1] = new int[5];
+ twoD[2] = new int[5];
+ twoD[3] = new int[5];



اگرچه در اين حالت اختصاص انفرادي حافظه به دومين بعد هيچ مزيتي ندارد، اما احتمال چنين مزيتهايي وجود دارد . بعنوان مثال ، هنگاميكه ابعاد را بصورت دستي اختصاص مي دهيد ، نيازي نيست كه همان ارقام براي اجزائ هر بعد را تخصيص دهيد .

همانطوريكه قبلا" گفتيم ، از آنجاييكه آرايه هاي چند بعدي واقعا" آرايه اي از آرايه ها هستند ، طول هر يك از آرايه ها تحت كنترل شما قرار مي گيرند . بعنوان مثال ، برنامه بعدي يك آرايه دو بعدي ايجاد مي كند كه در آن اندازه هاي دومين بعد نامساوي هستند .

+ // Manually allocate differing size second dimension.
+ class TwoDAgain {
+ public static void main(String args[] ){
+
+
+ int twoD[][] = new int[4][];
+ twoD[0] = new int[1];
+ twoD[1] = new int[2];
+ twoD[2] = new int[3];
+ twoD[3] = new int[4];
+
+ int i/ j/ k = 0;
+
+ for(i=0; i<4; i++)
+ for(j=0; j + towD[i][j] = k;
+ k++;
+ }
+
+ for(i=0; i<4; i++ ){
+ for(j=0; j + System.out.print(twoD[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }



خروجي اين برنامه بقرار زير مي باشد : 0

1 2
3 4 5
6 7 8 9



آرايه اي كه توسط اين برنامه ايجاد مي شود ، بصورت زير خواهد بود :

| [0][0] |

| [1][0] | [1][1] |

| [2][0] | [2][1] | [2][2] |

| [3][0] | [3][1] | [3][2] | [3][3] |




از آرايه هاي چند بعدي ناجور ( يا نامنظم ) در اكثر برنامه ها استفاده نميشود زيرا برخلاف آنچه مردم هنگام مواجه شدن با يك آرايه چند بعدي انتظار دارند رفتار مي كنند . اما اين آرايه ها در برخي شرايط بسيار كارا هستند . بعنوان مثال ، اگر نياز به يك آرايه دو بعدي خيلي بزرگ داريد كه داراي تجمع پراكنده باشد ( يعني كه يكي و نه همه اجزائ آن مورد استفاده قرار مي گيرند ) ، آنگاه آرايه بي قاعده احتمالا" يك راه حل كامل خواهد بود .
اين امكان وجود دارد كه آرايه هاي چند بعدي را مقدار دهي اوليه نمود . براي اينكار ، فقط كافي است هر يك از مقدار ده اوليه ابعاد را داخل مجموعه ابروهاي ختص خودش قرار دهيد . برنامه بعدي يك ماتريس ايجاد مي كند كه هر يك از اجزائ آن شامل حاصلضرب نمايه هاي سطرها و ستونها هستند. همچنين دقت نماييد كه مي توان
از عبارات همچون مقادير لفظي داخل مقدار ده اوليه آرايه استفاده نمود .

+ // Initialize a two-dimensional array.
+ class Matrix {
+ public static void main(String args[] ){
+ double m[][] = {
+ { 0*0/ 1*0/ 2*0/ 3*0 };
+ { 0*1/ 1*1/ 2*1/ 3*1 };
+ { 0*2/ 1*2/ 2*2/ 3*2 };
+ { 0*3/ 1*3/ 2*3/ 3*3 };
+ };
+ int i/ j;
+
+ for(i=0; i<4; i++ ){
+ for(j=0 j<4; j++)
+ System.out.print(m[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }



پس از اجراي اين برنامه ، خروجي آن بقرار زير خواهد بود : 0 0 0 0

0 1 2 3
0 2 4 6
0 3 6 9



همانطوريكه مشاهده مي كنيد، هر سطر در آرايه همانگونه كه در فهرستهاي مقدار دهي اوليه مشخص شده ، مقدار دهي اوليه شده است .

مثالهاي بيشتري درباره استفاده از آرايه چند بعدي بررسي مي كنيم . برنامه بعدي يك آرايه سه بعدي 3x4x5 ايجاد مي كند . سپس حاصل نمايه هاي مربوطه را براي هر عضو بارگذاري مي كند . در نهايت اين حاصل ها را نمايش خواهد داد :

+ // Demonstrate a three-dimensional array.
+ class threeDDatrix {
+ public static void main(String args[] ){
+ int threeD[][][] = new int[3][4][5];
+ int i/ j/ k;
+ for(i=0; i<3; i++)
+ for(j=0; j<4; j++)
+ for(k=0; k<5; k++)
+ threeD[i][j][k] = i * j * k;
+
+ for(i=0; i<3; i++ ){
+ for(j=0; j<4; j++ ){
+ for(k=0; k<5; k++)
+ System.out.print(threeD[i][j][k] + " ");
+ System.out.println)(;
+ }
+ System.out.println)(;
+ }
+ }
+ }



خروجي اين برنامه بقرار زير خواهد بود : 0 0 0 0 0

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12

0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24




دستور زبان جايگزين اعلان آرايه يك شكل دوم براي اعلان يك آرايه بصورت زير وجود دارد :
type [] var-name;



نام متغير نوع

در اينجا كروشه ها بعداز مشخص كننده نوع مي آيند نه بعداز نام متغير آرايه .
بعنوان مثال دو شكل اعلان زير يكسان عمل مي كنند :
+ int a1[] = new int[3];
+ int[] a2 = new int[3];



دو شكل اعلان زير هم يكسان عمل مي كنند :
+ char twod1[][] = n

[B@RBOD]

اولين برنامه ساده java

اكنون كه اصول اساسي شي ئ گرايي جاوا مورد بررسي قرار گرفته ، به برخي از برنامه هاي واقعي جاوا نگاه خواهيم كرد. كار را با كامپايل كردن و اجراي برنامه كوتاه زير شروع مي كنيم . خواهيم ديد كه اين برنامه بيشتر از حد تصور شما كار لازم دارد .


+ /*
+ This is a simple Java program.
+ Call this file "Example.java".
+ /*
+ class Exaample {
+ // Your program begins with a call to main.)(
+ public static void main( String args [] ){
+ System.out.println( "This is a simple Java program.");
+ }
+ }



نكته : در توصيف زيرين از JDK(JAVA Developer's Kit() استاندارد استفاده شده است كه توسط خود شركت Sun Microsystems عرضه شده است . اگر از يك محيط توسعه يافته ديگر براي جاوا استفاده مي كنيد ، آنگاه بايد از رويه متفاوتي براي كامپايل كردن و اجراي برنامه استفاده كنيد . در اين مورد به راهنماي كاربران كامپايلر خود مراجعه نماييد .

وارد نمودن برنامه Entering the program

در بسياري از زبانهاي كامپيوتري ، نام فايلي كه كد منبع (Source code) يك برنامه را نگهداري مي كند بصورت اختياري انتخاب مي شود . اما در جاوا اينگونه نيست . اولين چيزي كه بايد درباره جاوا بدانيد اين است كه نامي را كه براي فايل منبع انتخاب مي كنيد ، بسيار اهميت دارد . در اين مثال ، نام فايل منبع بايد Example JJAVA باشد . چرا ? در جاوا يك فايل منبع را بطور رسمي واحد كامپايل سازي (Compilation unit) مي گويند . اين فايل يك فايل متني است كه دربرگيرنده يك يا چندين تعريف كلاس (class definition) است . در كامپايلر جاوا بايد از فايل منبعي استفاده نمود كه داراي پسوند فايل JAVA باشد . دقت كنيد كه اين پسوند داراي چهار كاراكتر
است . حتما" مي دانيد كه سيستم عامل شما بايد توانايي حمايت از پسوندهاي طولاني تر را داشته باشد . بدين ترتيب Dos و ويندوز 3.1 توانايي حمايت از جاوا ( لااقل تاكنون ) را ندارند. اما ويندوز NT و95 بخوبي ازعهده اينكار برمي آيند.

يكبار ديگر به برنامه فوق نگاه كنيد، نام كلاس تعريف شده توسط برنامه ،Example مي باشد ، اين يك تصادف يا اتفاق نيست . در جاوا كليه كدها بايد داخل يك كلاس جاي بگيرند . براساس آيين نامه ، نام آن كلاس بايد با نام فايلي كه برنامه را نگهداري مي كند ، مطابقت داشته باشد . همچنين بايد مطمئن شويد كه حروف بزرگ در
نام فايل با نام كلاس مطابقت و هماهنگي داشته باشند . دليل اين است كه جاوا بسيار حساس نسبت به مورد است . از اين نظر آيين نامه اي كه نامهاي فايل را به نامهاي كلاس مرتبط مي كند ، ممكن است اختياري بنظر رسد . اما ، اين آيين نامه سبب شده تا نگهداري و سازماندهي برنامه ها آسان تر انجام شود .

كامپايل نمودن برنامه Compiling the program
براي كامپايل نمودن برنامه Example ، كامپايلر javac را اجرا نموده و نام فايل منبع را روي خط فرمان (command line) بصورت زير مشخص نماييد :

+ c:\>javac Example.java

كامپايلر javac فايلي تحت نام Example.class ايجاد مي كند كه شامل روايت كد بايتي از برنامه است . همانگونه كه قبلا" بحث شد ، كد بايتي جاوا نوعي معرفي مياني از برنامه شماست كه دربرگيرنده دستورالعملهايي است كه مفسر جاوا آنها را اجرا مي كند . بنابراين خروجي javac كدي كه مستقيما" قابل اجرا باشد ، نخواهد
بود .

براي اجراي واقعي برنامه ، بايد از مفسر (interpreter) جاوا تحت نام java استفاده نماييد . بدين منظور نام كلاس Example را بعنوان يك آرگومان (argument) خط فرمان بصورت زير وارد نماييد .

+ c:\>java Example

پس از اجراي اين برنامه ، خروجي بصورت زير بنمايش درمي آيد : This is a simple Java program.

هنگاميكه كد منبع جاوا كامپايل شود ، هر كلاس بتنهايي در فايل خروجي مخصوص خود كه فايل آن بعد از كلاس و پسوند class ذكر مي شود، قرار خواهد گرفت . بهمين دليل است كه بايد نام فايلهاي منبع جاوا را مطابق همان كلاسي كه آن را در بر مي گيرد انتخاب نمود تا نام فايل منبع با نام فايل class. مطابقت داشته باشد .

وقتي كه مفسر جاوا را همانگونه كه نشان داديم اجرا مي كنيد ، شما در حقيقت نام كلاسي كه مايليد مفسر آن را اجرا كند ، مشخص مي نماييد . مفسر بطور خودكار به دنبال يك فايل مي گردد كه داراي پسوند class. باشد . اگر آن را پيدا كند ، كدي را كه در آن كلاس مشخص شده وجود دارد ، اجرا خواهد نمود .

نگاهي دقيقتر به برنامه نمونه اول
اگر چه عبارت Example jjava بسيار كوتاه است ، اما دربرگيرنده چندين جنبه كليدي است كه در همه برنامه هاي جاوا وجود خواهند داشت . اجازه دهيد تا هر يك از بخشهاي برنامه را با دقت بيشتري بررسي كنيم .
برنامه با خط زير شروع مي شود :

+ /*
+ This is a simple Java program.
+ Call this file "Example .java".
+ /*

اين يك " توضيح "(Comment() است . مثل بسياري از زبانهاي برنامه نويسي ،جاوا به شما امكان وارد نمودن يك ملاحظه (Remark) در فايل منبع برنامه را مي دهد .

محتوي يك " توضيح " توسط كامپايلر ناديده گرفته خواهد شد . در عوض ، يك "توضيح " ، توصيف كننده يا شرح دهنده عملكرد برنامه است به هر كسي كه كد منبع را مطالعه نمايد . در اين مثال ، " توضيح " ، توصيف كننده برنامه بوده و بياد شما مي اندازد كه فايل منبع را بايدExample.java بناميد . البته ، در برنامه هاي واقعي ،" توضيحات " بطور كلي توصيف مي كنند كه چگونه برخي از بخشهاي يك برنامه كار كرده و يا اينكه يك جنبه خاص از برنامه چكاري انجام خواهد داد .

جاوا از سه روش براي " توضيحات " پشتيباني مي كند. اول آن چيزي است كه بالاي برنامه مشاهده مي كنيد كه آن را توضيح چند خطي (multiline comment) مي گويند .

اين نوع از " توضيح " بايد با علامت /* و با علامت */ پايان يابد . هر چيزي كه بين اين دو علامت قرار گيرد توسط كامپايلر ناديده گرفته خواهد شد . همانطوريكه از نام اين روش پيداست ، يك توضيح ، چند خطي ممكن است چندين خط دراز داشته باشد .
خط بعدي كد برنامه بصورت زير مي باشد :

+ class Exaple {

اين خط از واژه كليدي class استفاده مي كند تا اعلان نمايد كه يك كلاس جديد در حال تعريف شدن است . Example شناسه اي (identifier) است كه نام كلاس مي باشد.

كل تعريف كلاس ، شامل : كليه اعضائ خود ، بين علامات ابروباز ({) و ابروبسته (}) قرار مي گيرد . استفاده از علامات فوق در جاوا مشابه روش استفاده از آنها در C و C++ است . فعلا" درباره جزئيات مربوط به يك كلاس نگران نباشيد مگر دقت به اينكه در جاوا ، كليه فعاليت برنامه اي داخل يك علامت اتفاق مي افتد . اين امر يكي از
دلايلي است كه كليه برنامه هاي جاوا شي ئ گرا هستند .

خط بعدي برنامه يك " توضيح يك خطي "(single-line comment() بصورت زير است :
+ // Your program begins with a call to main.)(

اين نوع دوم " توضيحي " است كه توسط جاوا پشتيباني مي شود. يك توضيح يك خطي با علامت // شروع شده و در انتهاي خط پايان مي يابد . بعنوان يك قانون عمومي برنامه نويسان از توضيحات چند خطي براي ملاحظات طولاني تر و از توضيحات يك خطي براي توضيحات كوتاه و خط به خط استفاده مي كنند .

خط بعدي كد بقرار زير مي باشد :
+ public static void main( String args [] ){

اين خط شروع كننده روش ()main است . همانطوريكه توضيح متعاقب آن پيشنهاد مي كند ، اين خطي است كه برنامه در آن شروع به اجرا مي نمايد . كليه برنامه هاي كاربردي جاوا با فراخواني ()main شروع به اجرا مي كنند. ( درست شبيه C++/C. ).

معناي دقيق بخشهاي مختلف اين خط را فعلا" نمي توان توضيح داد ، زيرا درك آن مستلزم آگاهي از روش Java براي كپسول سازي است . اما از آنجاييكه اكثر مثالهاي موجود در بيشتر قسمتهاي اين بحث از اين خط از كط استفاده مي كنند ، بهتر است مرور كوتاهي بر بخشهاي مختلف آن داشته باشيم .

واژه كليدي public يك توصيفگر دسترسي (access specifier) است كه به برنامه نويس امكان داده تا قابليت و سطح مشاهده اعضائ كلاس را كنترل نمايد . وقتي كه عبارت public قبل از يك عضو كلاس قرار مي گيرد ، آنگاه آن عضو را مي توان با كدهاي خارج از كلاس كه اعلان شده ، مورد دسترسي قرار داد . ( مخالف اين عبارت
عبارت .private است كه از دسترسي به يك عضو توسط كدهاي تعريف شده در خارج كلاس جلوگيري مي نمايد . ) در اين حالت ()main بايد بعنوان public اعلام شود ، زيرا بايد توسط كدهاي خارج از كلاس هنگاميكه برنامه آغاز مي شود ، فراخواني شود .

واژه كليدي Static به ()main امكان داده تا بدون معرفي شدن توسط يك كلاس نمونه فراخواني شود . اين امر ضروري است چون ()main قبل از اينكه هر يك از اشيائ ساخته شوند توسط مفسر جاوا فراخواني خواهد شد . واژه كليدي Void بسادگي به كامپايلر مي گويد كه ()main مقداري را بازگردان نمي كند . همانطوريكه خواهيد
ديد ، ممكن است روشها (methods) نيز مقادير را بازگردان كنند . اگر اين مطالب تا حدي گيج كننده است ، نگران نباشيد . كليه اين مطالب با جزئيات بيشتري در قسمتهاي بعد بررسي خواهد شد .

همانطوريكه بيان شده ()main روشي است كه هنگام شروع يك برنامه كاربردي جاوا فراخواني مي شود . بياد آوريد كه جاوا بسيار حساس نسبت به مورد است . بنابراين براي جاوا Mainو mainو دو مفهوم متفاوت دارند . نكته مهم اين است كه كامپايلر جاوا فقط كلاسهايي را كه شامل روش ()main نباشند ، كامپايل خواهد نمود . اما
مفسر جاوا راهي براي اجراي اين كلاسها ندارد . بنابراين اگر بجاي main عبارت Mainرا تايپ كرده باشيد ، كامپايلر همچنان برنامه شما را كامپايل خواهد كرد .

اما مفسر جاوا يك گزارش خطا مي دهد زيرا توانايي يافتن روش ()main را ندارد .

اطلاعاتي كه لازم است به يك روش ارسال كنيد ، توسط متغيرهاي مشخص شده بين مجموعه پرانتزهايي كه بعد از نام روش قرار مي گيرند ، دريافت خواهد شد . اين متغيرها را پارامترها (parameters) مي نامند . اگر براي يك روش داده شده نياز به پارامتري نباشد ، از پرانتزهاي خالي استفاده مي كنيد . در حال حاضر ()main فقط يك پارامتر دارد ، كه البته بسيار پيچيده هم هست . String args [] يك پارامتر با نام args را اعلان ميكند كه يك آرايه از نمونه هاي string كلاس ميباشد.

( آرايه مجموعه اي از اشيائ مشابه هم هستند . ) اشيائ از نوع string ، رشته هاي كاراكترها را ذخيره مي كنند . در اين حالت ، args هر نوع آرگومان خط فرمان حاضر در هنگام اجراي برنامه را دريافت مي كند . اين برنامه از اين اطلاعات استفاده نمي كند ، اما برنامه هاي ديگر چنين استفاده اي را انجام مي دهند .

آخرين كاراكتر روي خط ، علامت { است . اين علامت نشان دهنده شروع بدنه ()main است . تمامي كدهايي كه يك روش را تشكيل مي دهند بين ابرو باز و ابرو بسته همان روش قرار مي گيرند .

يك نكته ديگر : ()main نقطه شروع بكار مفسر است . يك برنامه پيچيده شامل دهها كلاس است كه فقط يكي از آنها لازم است يك روش ()main داشته باشد تا كارها را شروع نمايد . هنگاميكه ريز برنامه ها (applets) برنامه هاي جاوا كه در مرورگرهاي وب تعبيه مي شوند را ايجاد مي كنيد ، بهيچوجه از ()main استفاده نخواهيد كرد، زيرا مرورگرهاي وب از وسائل متفاوتي براي شروع اجراي ريزبرنامه ها استفاده مي كنند .
خط بعدي كد بقرار زير ميباشد. دقت كنيد كه اين خط داخل ()main قرار ميگيرد.

+ System.out.println("This is a simple Java program.");

اين خط رشته "This is a simple Java program" را بعنوان خروجي ارائه مي دهد كه بعد از آن يك خط جديد روي صفحه ظاهر خواهد شد . خروجي بطور واقعي با روش توكار ()println همراه است . در اين حالت ، ()println نمايش دهنده رشته اي است كه در آن ثبت شده . خواهيد ديد كه از ()println براي نمايش ساير انواع اطلاعات
نيز استفاده مي شود . خط بالا با system.out شروع مي شود . اگر چه در اين مرحله توضيح اين مطلب بسيار دشواراست ، اما بطور اختصار system يك كلاس از پيش تعريف شده است كه دسترسي به سيستم را فراهم آورده و out نيز جريان خروجي است كه به كنسول (console) مرتبط شده است .

همانطوريكه احتمالا" حدس زده ايد ، خروجي ( و نيز ورودي ) كنسول بندرت در برنامه ها و ريز برنامه هاي جاوا مورد استفاده قرار مي گيرند . از آنجاييكه اكثر محيط هاي جديد كامپيوتري داراي طبيعت پنجره اي و گرافيكي هستند ، كنسول l/o اكثرا" براي برنامه هاي كمكي ساده و برنامه هاي نمايشي استفاده مي شود . بعدا"
شيوه هاي ديگري براي ايجاد خروجي با استفاده از جاوا ر خواهيد آموخت . اما فعلا" ما استفاده از روشهاي l/o كنسول را ادامه مي دهيم .

دقت كنيد كه ()println با يك علامت ويرگول نقطه (;)(semicolon) پايان ميگيرد.
كليه دستورات (statements) در جاوا با همين علامت پايان مي گيرند . دليل اينكه ساير خطوط برنامه با اين علامت پايان نمي گيرند اين است كه آنها را از نظر ند .

[B@RBOD]

عملگرهاي حسابي Arithmetic operators

عملگرهاي حسابي در عبارات رياضي استفاده مي شوند و طريقه استفاده از آنها بهمان روش جبري است . جدول بعدي فهرست عملگرهاي حسابي را نشان مي دهد :
|
نتيجه آن | عملگر |
|
اضافه نمودن | + | |
تفريق نمودن ( همچنين منهاي يكاني ) | - | |
ضرب | * | |
تقسيم | / | |
تعيين باقيمانده | % | |
افزايش | ++ | |
انتساب اضافه نمودن | += | |
انتساب تفرق نمودن | =- | |
انتساب ضرب نمودن | *= | |
انتساب تقسيم نمودن | /= | |
انتساب تعيين باقيمانده | %= | |
كاهش | - - |

عملوندهاي مربوط به عملگرهاي حسابي بايد از نوع عددي باشند . نمي توانيد از اين عملگرها روي نوع boolean استفاده كنيد ، اما روي انواع char قابل استفاده هستند ، زيرا نوع char در جاوا بطور ضروري زير مجموعه اي از int است .