همه چیز در مورد جاوا

زمينه هاي پيدايش جاوا

تاريخچه زبانهاي برنامه نويسي بشرح زير است : زبان B منجر به ظهور زبان C و C
زمينه پيدايش C++ شد و در نهايت زبان جاوا متولد شد . درك زبان جاوا مستلزم :
درك زمينه هاي لازم براي ايجاد جاوا ، نيروهايي كه اين زبان را شكل داده اند و
مشخصاتي است كه اين زبان از اسلاف خود به ارث برده است . نظير ساير زبانهاي
برنامه نويسي موفق ، جاوا نيز عناصر بارث برده از اسلاف خود را با ايده هاي
ابتكاري كه ناشي از محيط منحصر بفرد اين زبان بوده درهم آميخته است . فصول بعدي
جنبه هاي عملي زبان جاوا شامل دستور زبان (syntax) و كتابخانه ها (libraries)
و كاربردهاي جاوا را توصيف مي كند . فعلا" چگونگي و علت ظهور جاوا و اهميت آن
را بررسي مي كنيم .
اگر چه جاوا تفكيك ناپذيري با محيط هاي همزمان اينترنت پيوستگي دارد ، اما
بخاطر بسپاريد كه جاوا قبل از هر چيز يك زبان برنامه نويسي است . ابداعات و
پيشرفت ها در زبانهاي برنامه نويسي كامپيوتر بدو دليل بروز مي كنند :
- تطابق با تغييرات محيط ها و كاربردها .
- ايجاد پالايش و پيشرفت در هنر برنامه نويسي .
همانطوريكه بعدا" مشاهده مي كنيد ، تولد جاوا از اين دو دليل بطور يكسان .

انواع ساده The simple Types

جاوا هشت نوع ساده ( يا ابتدايي ) از داده را تعريف مي كند : short bbyte int
، long،، char،، float،، double،، boolean، اين انواع را مي توان در چهار
گروه بشرح زير دسته بندي نمود :
ؤ integers ( اعداد صحيح ) : اين گروه دربرگيرنده byte، short،، int،و longو
ميباشد كه مختص ارقام علامتدار مقدار كل (whole-valued signed numbers) ميباشد.
ؤ floating-point numbers ( اعداد اعشاري ) : اين گروه دربرگيرنده float و double
است كه معرف اعدادي است با دقت زياد .
ؤ characters ( كاراكترها ) : اين گروه فقط شامل char بوده كه نشانه هايي
نظير حروف و ارقام را در يك مجموعه خاص از كاراكترها معرفي مي كند .
ؤ Boolean ( بولي ) : اين گروه فقط شامل boolean است . كه نوع خاصي ازمعرفي
و بيان مقادير صحيح / ناصحيح مي باشد .
شما مي توانيد از اين انواع همانطوريكه هستند استفاده كرده ، يا آرايه ها و
انواع كلاسهاي خود را بسازيد .
انواع اتمي معرف مقادير تكي و نه اشيائ پيچيده هستند . اگر چه جاوا
همواره شي ئ گرا است ، اما انواع ساده اينطور نيستند . اين انواع ، مشابه انواع
ساده اي هستند كه در اكثر زبانهاي غير شي ئ گرا مشاهده مي شود . دليل اين امر
كارايي است . ساختن انواع ساده در اشيائ سبب افت بيش از حد كارايي و عملكرد
مي شود .
انواع ساده بگونه اي تعريف شده اند تا يك دامنه روشن و رفتاري رياضي داشته
باشند . و زبانهايي نظير Cو C++و امكان مي دهند تا اندازه يك عدد صحيح براساس
ملاحظات مربوط به محيط اجرايي تغيير يابد . اما جاوا متفاوت عمل مي كند . بدليل
نيازهاي موجود براي قابليت حمل جاوا ، كليه انواع داده در اين زبان داراي يك
دامنه كاملا" تعريف شده هستند . بعنوان مثال يك int هميشه 32 بيتي است ، صرفنظر
از اينكه زير بناي خاص محيطي آن چگونه باشد . اين حالت به برنامه هاي نوشته شده
اجازه مي دهد تا با اطمينان و بدون در نظر گرفتن معماري خاص يك ماشين اجرا
شوند. در حاليكه مشخص كردن دقيق اندازه يك عدد صحيح ممكن است در برخي محيط ها
سبب افت عملكرد شود ، اما براي رسيدن به خاصيت قابليت حمل پرداخت چنين تاواني

( اعداد صحيح )

جاوا چهار نوع عدد صحيح تعريف مي كند : 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.

اصل و نسب جاوا

جاوا به زبان C++ ( نتيجه مستقيم زبان C ) وابسته است . بسياري از خصلتهاي
جاوا بطور مستقيم از اين دو زبان گرفته شده است . دستور زبان جاوا منتج از
دستور زبان C است . بسياري از جنبه هاي oop زبان جاوا از C++ بعاريت گرفته شده
است . در حقيقت بسياري از خصلتهاي زبان جاوا از اين دو زبان مشتق شده يا با
آنها مرتبط است . علاوه بر اين ، توليد جاوا بطور عميقي متاثر از روال پالايش و
تطبيقي است كه طي سه دهه گذشته براي زبانهاي برنامه نويسي موجود پيش آمده است .
بهمين دلايل بهتر است سير مراحل و نيروهايي كه منجر به تولد جاوا شده را بررسي
نماييم . هرنوع ابتكار و فكر جديد در طراحي زبانها براساس نياز به پشت سر نهادن
يك مشكل اصلي است كه زبانهاي قبلي از حل آن عاجز مانده اند . جاوا نيز بهمين
ترتيب متولد شد .

تولد زبان برنامه نويسي جديد : C
زبان C پس از تولد ، شوك بزرگي به دنياي كامپيوتر وارد كرد . اين زبان بطور
اساسي شيوه هاي تفكر و دستيابي به برنامه نويسي كامپيوتر را دگرگون ساخت . تولد C
ناشي از نياز به يك زبان ساخت يافته ، موثر و سطح بالا بعنوان جايگزيني براي
كدهاي اسمبلي و پياده سازي برنامه نويسي سيستم بود . هنگاميكه يك زبان برنامه
نويسي جديد متولد ميشود ، مقايسه ها شروع خواهد شد . مقايسه ها براساس معيارهاي
زير انجام مي گيرند :
ؤ راحتي كاربري در مقايسه با قدرتمندي زبان برنامه نويسي
ؤ ايمني در مقايسه با سطح كارآيي
ؤ استحكام در مقايسه با توسعه پذيري
قبل از ظهور زبان C برنامه نويسان با زبانهايي كار مي كردند كه قدرت
بهينه سازي يك مجموعه خاص از خصايص را داشتند . بعنوان مثال هنگاميكه از فرترن
براي نوشتن برنامه هاي موثر در كاربردهاي علمي استفاده مي كنيم ، برنامه هاي
حاصله براي كدهاي سيستم چندان مناسب نيست . زبان بيسيك با اينكه براحتي آموخته
مي شود ، اما قدرت زيادي نداشته و عدم ساخت يافتگي آن در برنامه هاي بزرگ مشكل
آفرين خواهد شد . از زبان اسمبلي براي توليد برنامه هاي كاملا" موثر استفاده
مي شود ، اما آموزش و كار با اين زبان بسيار مشكل است . بعلاوه اشكال زدايي
كدهاي اسمبلي بسيار طاقت فرساست .
مشكل اصلي ديگر اين بود كه زبانهاي اوليه برنامه نويسي نظير بيسيك ، كوبول
و فرترن براساس اصول ساخت يافته طراحي نشده بودند . اين زبانها از Goto بعنوان
ابزارهاي اوليه كنترل برنامه استفاده مي كردند . در نتيجه ، برنامه هاي نوشته
شده با اين زبانها توليد باصطلاح " كدهاي اسپاگتي "(spaghetti code() مي كردند
منظور مجموعه اي در هم تنيده از پرشها و شاخه هاي شرطي است كه درك يك برنامه
طولاني را ناممكن مي سازد . اگر چه زبانهايي نظير پاسكال ، ساخت يافته هستند
اما فاقد كارايي لازم بوده و جنبه هاي ضروري براي كاربرد آنها در طيف وسيعي از
برنامه ها وجود ندارد . ( بخصوص ويرايش پاسكال استاندارد فاقد ابزارهاي كافي
براي استفاده در سطح كدهاي سيستم بود . )
تا قبل از ابداع زبان C ، زبان ديگري قدرت نداشت تا خصلتهاي متضادي كه در
زبانهاي قبلي مشاهده ميشد ، را يكجا گردآوري كند . نياز به وجود يك چنين زباني
شديدا" احساس ميشد. در اوايل دهه 1970 ميلادي ، انقلاب رايانه اي در حال شكل گيري
بود و تقاضا براي انواع نرم افزارها فشار زيادي روي برنامه نويسان و تواناييهاي
ايشان اعمال ميكرد. درمراكز آموزشي تلاش مضاعفي براي ايجاد يك زبان برنامه نويسي
برتر انجام مي گرفت . اما شايد از همه مهمتر توليد و عرضه انبوه سخت افزار
كامپيوتري بود كه بعنوان يك نيروي ثانويه روي زبانهاي برنامه نويسي عمل ميكرد.
ديگر رايانه ها و اسرار دروني آنها پشت درهاي بسته نگهداري نمي شد . براي اولين
بار بود كه برنامه نويسان واقعا" دسترسي نامحدودي به اسرار ماشينهاي خود پيدا
نمودند . اين امر زمينه تجربيات آزادانه را بوجود آورد . همچنين برنامه نويسان
توانستند ابزارهاي مورد نيازشان را ايجاد نمايند . با ظهور زبان C ، زمينه
جهشهاي بزرگ در زبانهاي برنامه نويسي مهيا شد .
زبان C نتيجه توسعه تحقيقاتي درباره يك زبان قديمي تر بنام Bcpl بود . زبان C
اولين بار توسط Dennis Ritchie ابداع و روي ماشينهاي DEC PDP-11 داراي سيستم
عامل يونيكس اجرا شد . زبان Bcpl توسط Martin Richards توسعه يافته بود . Bcpl
منجر به تولد زبان B شد كه توسط Ken thompson ابداع شد و سرانجام به زبان C
منتهي شد . براي ساليان متمادي ، نسخه روايت استاندارد زبان C هماني بود كه
روي سيستم عامل unix عرضه و توسط Briian Kernighanو Dennis Ritchieو در كتاب "The C programming Language"
توصيف شده بود . بعدا" در سال 1989 ميلادي زبان C
مجددا" استاندارد شد وو استاندارد ANSI براي زبان C انتخاب شد .
بسياري معتقدند كه ايجاد زبان C راهگشاي دوران جديدي در زبانهاي برنامه نويسي
بوده است . اين زبان بطور موفقيت آميزي تناقضهاي موجود در زبان هاي برنامه نويسي
قبلي را مرتفع نمود . نتيجه فرآيند ايجاد زبان C ، يك زبان قدرتمند ، كارا و
ساخت يافته بود كه براحتي قابل آموزش و فراگيري بود . اين زبان يك ويژگي غير
محسوس اما مهم داشت : زبان C ، زبان برنامه نويسان بود . قبل از ابداع زبان C
زبانهاي برنامه نويسي يا جنبه هاي آموزشي داشته يا براي كارهاي اداري طراحي
ميشد . اما زبان C چيز ديگري بود . اين زبان توسط برنامه نويسان واقعي و درگير
با كارهاي جدي ، طراحي و پياده سازي شده و توسعه يافت . جنبه هاي مختلف اين
زبان توسط افرادي كه با خود زبان سر و كار داشته و برنامه نويسي مي كردند مورد
بررسي ، آزمايش و تفكر و تفكر مجدد قرار گرفته بود . حاصل اين فرآيند هم زباني
بود كه برنامه نويسان آن را دوست داشتند . در حقيقت زبان C بسرعت مورد توجه
برنامه نويسان قرار گرفت تا جايي كه برنامه نويسان نسبت به C تعصب خاصي پيدا
نمودند . اين زبان مقبوليت و محبوبيت زيادي در بين برنامه نويسان يافت . بطور
خلاصه زبان C توسط برنامه نويسان و براي برنامه نويسان طراحي شده است . بعدا"
مي بينيد كه جاوا نيز اين ويژگي را از اجداد خود بارث برده است .

نياز به C++
طي دهه 1970 و اوايل دهه 80 ميلادي زبان C نگين انگشتري برنامه نويسان بود و
هنوز هم در سطح وسيعي مورد استفده قرار مي گيرد . از آنجاييكه C يك زبان موفق
و سودمند بوده ، ممكن است بپرسيد چه نيازي به زبانهاي جديدتر وجود داشته است .
پاسخ شما يك كلمه يعني پيچيدگي (Complexity) است . طي تاريخ كوتاه برنامه نويسي
پيچيدگي فزاينده برنامه ها نياز براي شيوه هاي بهتر مديريت پيچيدگي را بوجود
آورده است . C++ پاسخي است به اين نياز مديريت پيچيدگي برنامه ها كه زمينه اصلي
پيدايش C++ بوده است .
شيوه هاي برنامه نويسي از زمان اختراع رايانه تاكنون بطور قابل توجهي تغيير
نموده اند . بعنوان مثال ، هنگاميكه رايانه ها اختراع شدند ، برنامه نويسي با
استفاده از دستور العملهاي باينري (Binary) ماشين انجام مي گرفت .
ماداميكه برنامه ها شامل حدود چند دستور العمل بود ، اين روش كارآيي داشت .
بموازات رشد برنامه ها زبان اسمبلي ابداع شد تا برنامه نويسان بتوانند برنامه هاي
بزرگتر و پيچيده تر را با استفاده از نشانه هايي كه معرف دستورالعملهاي ماشين
بودند ، بنويسند . اما پيشرفت و رشد برنامه ها همچنان ادامه يافت و زبانهاي سطح
بالايي معرفي شدند كه ابزارهاي مناسب براي مديريت پيچيدگي روزافزون برنامه ها را
در اختيار برنامه نويسان قرار مي دادند .
اولين زبان مطرح در اين زمينه فرترن بود . اگر چه فرترن اولين گام در اين
مسير بود، اما زباني است كه توسط آن برنامه هاي تميز و سهل الادراك نوشته ميشود.
در دهه 1960 ميلادي برنامه نويسي ساخت يافته مطرح شد . با استفاده از زبانهاي
ساخت يافته ، براي اولين بار امكان راحت نوشتن برنامه هاي بسيار پيچيده بوجود
آمد . اما حتي با وجود روشهاي برنامه نويسي ساخت يافته ، هنگاميكه يك پروژه به
اندازه معيني مي رسيد ، پيچيدگي آن از توان مديريت برنامه نويس خارج مي شد . در
اوائل دهه 1980 ميلادي بسياري از پروژه هاي مديريت برنامه نويسي از مرزهاي
برنامه نويسي ساخت يافته گذشتند . براي حل اين قبيل مشكلات ، يك روش نوين
برنامه نويسي ابداع شد . اين روش را برنامه نويسي شي ئ گرا يا باختصار oop
مي نامند . oop با جزئيات بيشتري بعدا" در همين كتاب بررسي خواهد شد ، اما
توصيف مختصر اين روش عبارت است از : oop يك نوع روش شناسي برنامه نويسي است كه
امكان سازماندهي برنامه هاي پيچيده از طريق بهره گيري از سه روش : وراثت ، كپسول
سازي و چند شكلي ، را ايجاد مي كند .
در تحليل نهايي ، اگر چه C بزرگترين و مهمترين زبان برنامه نويسي جهان است
اما محدوديتهايي در مديريت پيچيدگي برنامه ها دارد . هنگاميكه يك برنامه از
محدوده 25000 تا 100000 خط از كدها تجاوز نمايد، آنچنان پيچيده مي شود كه درك
آن بعنوان يك برنامه كلي ناممكن خواهد شد . C++ اين محدوديت را از بين برده و
به برنامه نويس كمك مي كند تا برنامه هايي از اين بزرگتر را نيز درك و مديريت
نمايد . C++
در سال 1979 ميلادي توسط Bjarne stoustrup هنگاميكه در آزمايشگاه بل در Marry Hill
ايالت New jersy مشغول كار بود ، ابداع شد . او در ابتدا اين زبان
جديد را (C with classes) ناميد . اما در سال 1983 ميلادي نام اين زبان جديد به C++
تغيير يافت . C++ تداوم زبان C بود كه جنبه هاي oop نيز به آن اضافه مي شد.
از آنجايي كه زبان C++ براساس زبان C شكل گرفته ، در بر گيرنده كليه جنبه ها
خسلتها (attributes) و مزاياي زبان C مي باشد . اين عوامل دلايل قاطعي براي
موفقيت حتمي C++ بعنوان يك زبان برنامه نويسي هستند . ابداع C++ در حقيقت تلاشي
براي ايجاد يك زبان كاملا" جديد برنامه نويسي نبود. در حقيقت پروژه C++ منجر به
افزايش تواناييهاي زبان موفق C شد .
چون C++ از ابتداي تولد تاكنون داراي روايتهاي گوناگوني شده است ، در حال
حاضر در تلاش استاندارد نمودن اين زبان هستند . ( اولين روايت پيشنهادي ANSI
براي استاندارد C++ در سال 1994 ميلادي مطرح شد . ) روال استاندارد سازي اين مچنان

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

اعداد اعشاري يا همان اعداد حقيقي براي ارزش گذاري عبارتهايي كه نيازمند
دقت بيشتري هستند ، استفاده مي شوند . بعنوان نمونه ، محاسباتي نظير ريشه دوم
و محاسبات مثلثاتي نظير سينوس و كسينوس منجربه جوابهايي مي شوند كه براي تعيين
دقت آن نياز به نوع عدد اعشاري مي باشد . جاوا يك مجموعه استاندارد (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 بيت جاي داد ، تا حدي
سبب نزول كارآيي خواهد شد . اما اين بهايي است كه براي رسيدن به قابليت حمل
جهاني در برنامه ها بايد پرداخت .
نكته : اطلاعات بيشتر درباره كدهاي جهاني را در آدرسهاي وب زير پيدا خواهيد
نمود : [ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ] .unicode .org
[ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ] .stonehand .com/unicode .html


در زير برنامه اي را مشاهده مي كنيد كه متغيرهاي 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... )

يك مقدار <سوم اينكه ، پي آمد يك عملگر رابطه اي نظير boolean است . بهمين
دليل است كه عبارت 9>َ10 مقدار true را نمايش مي دهد . علاوه بر اين ، مجموعه ي از پرانتزهايي كه عبارت 9>َ10 را محصور كرده اند ، ضروري است زيرا عملگر +

نگاهي دقيقتر به الفاظ

اكنون كه انواع توكار را بطور رسمي توضيح داده ايم ، نگاه دقيقتري به اين
الفاظ خواهيم داشت .

الفاظ عدد صحيح integer literals
احتمالا" اعداد صحيح رايجترين نوع استفاده شده در برنامه هاي نوع بندي شده
هستند. هر مقدار رقمي كلي يك لفظ عدد صحيح است . اعداد 1، 2،، 3، و 42 مثالهاي
روشني هستند . اين اعداد همگي مقادير دهدهي مي باشند ، بدين معني كه اين اعداد
در يك مبناي ده رقمي تعريف شده اند . دو مبناي ديگر نيز در الفاظ عدد صحيح قابل
استفاده هستند : مبناي هشت (octal) و مبناي 16(hexadecimal(). مقادير در مبناي
هشت در جاوا با يك رقم 0 پيش آيند مشخص ميشوند. ارقام دهدهي معمولي نمي توانند
رقم 0 پيش آيند داشته باشند . بنابراين مقدار بظاهر معتبر 09 خطايي را در
كامپايلر توليد مي كند، زيرا رقم 9 خارج از دامنه 0تا 7ا مبناي هشت قرار دارد.
يكي ديگر از مبناهاي رايج براي ارقام مورد استفاده برنامه نويسان ، مبناي 16
مي باشد كه با مدول اندازه هاي كلمه 8 تايي نظير 8 ، 16 ، 32 و 64 بيتي كاملا"
سازگاري دارد . يك ثابت درمبناي 16 را توسط OXيا oxا مشخص مي كنيد . دامنه يك
رقم در مبناي 16 از رقم 0 تا 15 و حروف Aتا Fا ( يا aتا fا ) بعنوان جايگزين
ارقام 10 تا 15 مي باشد .
الفاظ عدد صحيح يك مقدار int توليد مي كنند كه در جاوا يك مقدار عدد صحيح 32
بيتي است . از آنجاييكه جاوا شديدا" نوع بندي شده است ، ممكن است تعجب كنيد
كه چگونه مي توان يك لفظ عدد صحيح را به يكي ديگر از انواع عدد صحيح جاوا نظير byte
يا longا نسبت داد ، بدون اينكه خطاي عدم سازگاري انواع بوجود آيد .
خوشبختانه چنين حالتهايي بسادگي اداره مي شوند . هنگاميكه يك لفظ عدد صحيح به
يك متغير byteيا shortا منتسب مي شود، اگر مقدار لفظ داخل محدوده نوع هدف قرار
داشته باشد ، خطايي توليد نخواهد شد . همچنين همواره مي توان يك لفظ عدد صحيح
را به يك متغير long منتسب نمود . اما براي مشخص نمودن يك لفظ long بايد بطور
صريح به كامپايلر بگوييد كه مقدار لفظ از نوع long است . اينكار را با الحاق
يك حرف L بزرگ يا كوچك به لفظ انجام مي دهيم . بعنوان مثال ، ox7ffffffffffffffL 9223372036854775807L
بزرگترين Long مي باشد .

الفاظ عدد اعشاري Floating-point literals
ارقام اعشاري معرف مقادير دهدهي با اجزائ كسري مي باشند . آنها را مي توان
به شكل استاندارد يا به شكل علامتگذاري علمي بيان نمود . نشانه گذاري استاندارد
شامل يك جزئ عدد صحيح است كه بعد از آن يك نقطه و بعد از آن جزئ كسري عدد قرار
مي گيرد . بعنوان مثال 2.0 يا 3.14159 يا 0.6667 معرف نشانه گذاري استاندارد
معتبر در ارقام اعشاري هستند . نشانه گذاري علمي از يك نشانه گذاري استاندارد
نقطه مخصوص اعشاري بعلاوه يك پيوند كه مشخص كننده تواني از عدد 10 است كه
بايد در عدد ضرب شود استفاده مي كند . توان ( نما ) را توسط علامت Eيا eا كه
يك رقم دهدهي بدنبال آن مي آيد و ممكن است مثبت يا منفي باشد ، نشان مي دهيم .
مثل 6.022E23 يا 05-314159E و 2e+100 .
الفاظ عدد اعشاري در جاوا بصورت پيش فرض داراي دقت مضاعف (double) هستند .
براي مشخص نمودن يك لفظ float بايد يك حرف Fيا fا را به ثابت الحاق نماييد .
همچنين ميتوانيد بطور صريح يك لفظ double را با الحاق يك حرف Dيا dا نيز انجام
دهيد . انجام اينكار البته اضافي است . نوع double پيش فرض 64 بيت حافظه را
مصرف مي كند در حاليكه نوع كم دقت تر float مستلزم 32 بيت حافظه است .

الفاظ Boolean
الفاظ boolean بسيار ساده هستند. يك مقدار boolean فقط دو مقدار منطقي شامل true
و falseو مي تواند داشته باشد . مقادير trueو falseو هرگز به رقم تبديل
نمي شوند . در جاوا لفظ true مساوي يك نبوده ، همچنانكه لفظ false معادل صفر
نيست . در جاوا ، آنها را فقط مي توان به متغيرهاي اعلان شده بعنوان boolean
منتسب نمود و يا در عباراتي با عملگرهاي boolean استفاده نمود .

الفاظ كاراكترها Character literals
كاراكترهاي جاوا در مجموعه كاراكتر كدهاي جهاني نمايه سازي شده اند . آنها
مقادير 16 بيتي هستند كه قابل تبديل به اعداد صحيح بوده و با عملگرهاي عدد
صحيح نظير عملگرهاي اضافه و كسر نمودن اداره مي شوند . يك كاراكتر لفظي همواره
داخل يك علامت ' ' معرفي مي شود . كليه كاراكترهاي ASCII قابل رويت مي توانند
بطور مستقيم به داخل اين علامت وارد شوند ، مثل 'a'يا 'z'ايا '@'ا . براي
كاراكترهايي كه امكان ورود مستقيم را ندارند ، چندين پيش آيند وجود دارند كه
امكان ورود كاراكتر دلخواه را فراهم مينمايند، نظير '\' براي ورود خود كاراكتر
و '\n' براي كاراكتر خط جديد . همچنين مكانيسمي براي ورودي مستقيم مقدار يك
كاراكتر در مبناي هشت يا شانزده وجود دارد . براي نشانه گذاري مبناي هشت از
علامت \ كه توسط يك عدد سه رقمي دنبال ميشود، استفاده كنيد. بعنوان مثال '\141'
همان حرف 'a' است . براي مبناي شانزده از علامت (\u) استفاده كنيد و بعد از آن
دقيقا" چهار رقم مبناي شانزده . بعنوان مثال '\uoo61' كه معادل حرف 'a' در
استاندارد lso-latin-1 است چون بايت بالايي آن صفر است . '\ua432' يك كاراكتر Katakana
ژاپني است . جدول زير پيش آيندهاي كاراكترها را نشان مي دهد .

|
توصيف آن پيش آيند | |
كاراكتر مبناي هشت (ddd) \ddd | |
كاراكتر كد جهاني مبناي شانزده (xxxx) \uxxxx | |
علامت تكي نقل قول \' | |
علامت جفتي نقل قول \" | | \\ Backslash |
|
كاراكتر برگشت به سر خط \r | |
خط جديد \n | |
تغذيه فرم \f | | \t Tab |
| \b Backspace |



الفاظ String
الفاظ رشته اي در جاوا نظير ساير زبانهاي برنامه نويسي مشخص مي شوند قرار
دادن يك دنباله از كاراكترها بين يك جفت از علامات نقل قول ، در زير نمونه هايي
از الفاظ رشته اي را مشاهده مي كنيد .

"Hello world"
"tow\nlines"
"\"This is in quotes\"


پيش آيندها و نشانه گذاريهاي مبناي هشت / شانزده كه براي الفاظ كاراكترها
توصيف شد ، بهمان روش در داخل الفاظ رشته اي كار مي كنند . يك نكته مهم درباره
رشته هاي جاوا اين است كه آنها بايد روي يك خط شروع شده و پايان يابد . برخلاف
زبانهاي ديگر در جاوا ادامه خط در خطهاي ديگر مجاز نيست .
نكته : حتما" مي دانيد كه در اكثر زبانهاي ديگر شامل Cو C++و ، رشته ها بعنوان
آرايه هاي كاراكتري پياده سازي مي شوند . اما در جاوا اين حالت وجود
ندارد . رشته ها از نوع اشيائ هستند . بعدا" مي بينيد از آنجاييكه جاوا ياده سازي مي كند ، دربرگيرنده تواناييهاي

متغيرها

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

اعلان يك متغير 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ا را پيش تعريف نمود تا از نوع INTEGER باشند ، در حاليكه
ساير شناسه ها از نوع 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!
+ }
+ }
+ }



تبديل خودكار و تبديل غير خودكار انواع
اگر تجربه قبلي برنامه نويسي داشته ايد ، پس مي دانيد كه كاملا" طبيعي است كه
مقداري از يك نوع را به متغيري از نوع ديگر نسبت دهيم . اگر اين دو نوع سازگار
باشند ، آنگاه جاوا بطور خودكار اين تبديل (conversion) را انجام مي دهد .
بعنوان مثال ، همواره امكان دارد كه مقدار int را به يك متغير long نسبت داد .
اما همه انواع با يكديگر سازگاري ندارند ، بنابراين هر گونه تبديل انواع مجاز
نخواهد بود . بعنوان نمونه ، هيچ تبديلي از doubleبه byte تعريف نشده است .
خوشبختانه ، امكان انجام تبديلات بين انواع غير سازگار هم وجود دارد . براي
انجام اينكار ، بايد از تبديل cast استفاده كنيد كه امكان يك تبديل صريح بين
انواع غير سازگار را بوجود مي آورد . اجازه دهيد تا نگاه دقيقتري به تبديل
خودكار انواع و تبديل cast داشته باشيم .

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

تبديل غير خودكار انواع ناسازگار
اگر چه تبديلات خودكار انواع بسيار سودمند هستند ، اما جوابگوي همه نيازها
نيستند . بعنوان مثال ، ممكن است بخواهيد يك مقدار 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


اكنون به هر يك از اين تبديلات نگاه مي كنيم . هنگاميكه مقدار 257 از طريق
تبديل cast به يك byte منتسب مي شود ، نتيجه برابر باقيمانده تقسيم 257 بر 256
( دامنه byte ) يعني عدد 1 است . هنگاميكه d به يك int تبديل مي شود ، بخش خواهند رفت . هنگاميكه d به يك byte تبديل مي شود ، بخش

ارتقائ خودكار انواع در عبارات Automatic Type promotion in Expressions


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

+ byte a = 40;
+ byte b = 50;
+ byte c = 100;
+ int d = a * b / c;


نتيجه قلم واسطه a*b از دامنه هر يك از عملوندهاي byte خود تجاوز مي نمايد.
براي اداره اين نوع مشكلات ، جاوا بطور خودكار هر يك از عملوندهاي byteو shortو
را هنگام ارزشيابي يك عبارت به int ارتقائ مي دهد . اين بدان معني است كه زير
عبارت a*b با استفاده از اعداد صحيح و نه byte اجرا مي شود. بنابراين عدد 2000
نتيجه عبارت واسطه 50*40 مجاز است ، اگر چه aو bو هر دو بعنوان نوع byte مشخص
شده اند .
همانقدر كه ارتقائ خودكار مفيداست ، مي تواند سبب بروز خطاهاي زمان كامپايل
(compile-time) گردد . بعنوان مثال ، اين كد بظاهر صحيح يك مشكل را بوجود
مي آورد .

+ byte b = 50;
+ b = b * 2; // Error! Cannot assign an int to a byte!


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

+ byte b = 50;
+ b =( byte( )b * 2);


كه مقدار صحيح عدد 100 را بدست مي آورد .

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

+ class Promote {
+ public static void main(String args[] ){
+ byte b = 42;
+ char c = 'a';
+ short s = 1024;
+ int i = 50000;
+ float f = 5.67f;
+ double d =. 1234;
+ double result =( f * b )+( i / c( - )d * s);
+ System.out.println((f * b )+ " + " +( i / c )+ " - " +( d * s));
+ System.out.println("result = " + result);
+ }
+ }


اجازه دهيد به ارتقائ انواع كه در اين خط از برنامه اتفاق افتاده ، دقيقتر
نگاه كنيم :

+ double result =( f * b )+( i / c( - )d * s);


در اولين زير عبارت يعني f*b، b، به يك نوع float ارتقائ يافته و جواب زير
عبارت نيز از نوع float خواهد بود . در زير عبارت بعدي يعني i/c، c، به يك نوع int
ارتقائ يافته و جواب آن زير عبارت نيز از نوع int خواهد بود . سپس در زير
عبارت d*s ، مقدار S به نوع double ارتقائ يافته و نوع زير عبارت نيز double
خواهد بود . در نهايت اين سه مقدار واسطه ، float، int،، double، در نظر گرفته
مي شوند . خروجي float بعلاوه int از نوع float خواهد شد . آنگاه اين نتيجه
منهاي آخرين double به نوع double ارتقائ يافته ، كه نوع مربوط به جواب نهايي

آرايه ها

يك آرايه گروهي از متغيرهاي يك نوع است كه با يك نام مشترك به آنها ارجاع
مي شود . مي توان آرايه ها را براي هر يك از انواع ايجاد نمود و ممكن است اين
آرايه ها داراي يك يا چندين بعد باشند . براي دسترسي به يك عضو آرايه از نمايه
(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

چند كلمه اي درباره رشته ها (strings)

حتما" دقت كرده ايد كه طي بحث گذشته درباره انواع داده و آرايه ها هيچ حرفي
از رشته ها يا نوع داده رشته (string data type) مطرح نشد . علت عدم پشتيباني
جاوا از اين نوع نيست . بلكه علت آن است كه نوع رشته در جاوا تحت نام string
يك نوع ساده نيست . اين مفهوم در جاوا با آرايه اي از كاراكترها ( آنگونه در C
و C++ مي باشد ) متفاوت است . در جاوا string تعريف كننده يك شي ئ است و توصيف
كامل رشته ، مستلزم درك كاملي از جنبه هاي گوناگون شي ئ گرايي است . بهمين دليل
مبحث رشته ها را بعد از بحث اشيائ خواهيم گفت . اما چون ممكن است تا آن زمان از
رشته هاي ساده درمثالها استفاده شود، لذا معرفي مختصري از رشته ها ارائه ميدهيم .
نوع string براي معرفي و اعلان متغيرهاي رشته اي استفاده مي شود . همچنين
مي توانيد آرايه هايي از رشته ها را اعلان كنيد . يك ثابت رشته اي داخل علامت " "
را مي توان به يك متغير string نسبت داد . يك متغير نوع string را مي توان به
متغير ديگري از همان نوع نسبت داد . مي توانيد يك شي ئ از نوع string را بعنوان
يك آرگومان به ()println استفاده نماييد . بعنوان مثال ، برنامه بعدي را در
نظر بگيريد :

+ String str = "this is a test";
+ String.out.println(str);


در اينجا str يك شي ئ از نوع string است كه رشته "this is a test" به آن
منتسب شده است . اين رشته توسط دستور ()println بنمايش درمي آيد .
بعدا" خواهيد ديد اشيائ string داراي جنبه ها و خصلتهايي هستند كه آنها را
بسيار قدرتمند و سهل الاستفاده ساخته است . اما در بحثهاي بعدي شما فقط از اده خواهيد نمود .