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

[Nesta]

عملگر انتساب The Assignment Operator

عملگر انتساب علامت تكي تساوي = مي باشد . عملگر انتساب در جاوا مشابه ساير
زبانهاي برنامه نويسي كار مي كند . شكل كلي آن بصورت زير است :

Var = expression;


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

+ int x/ y/ z;
+
+ x = y = z = 100; // set x/ y/ and z to 100


اين قطعه از برنامه مقدار 100 را با استفاده از يك دستور در متغيرهاي x، y،
و z قرار مي دهد . زيرا = عملگري است كه مقدار عبارت سمت راست را جذب مي كند .
بنابراين مقدار Z=100 برابر 100 است كه اين مقدار به y منتسب شده و نيز به x
منتسب خواهد شد . استفاده از " زنجيره اي از انتسابها " يك راه آسان براي قرار ادن يك مقدار مشترك در گروهي از متغيرهاست .

[Nesta]

عملگر ?

جاوا شامل يك عملگر سه تايي ويژه است كه مي تواند جايگزين انواع مشخصي از
دستورات if-then-else باشد. اين عملگر علامت ? است و نحوه كار آن در جاوا مشابه
با Cو C++و است . ابتدا كمي گيج كننده است ، اما مي توان از ? براحتي و با
كارايي استفاده نمود شكل كلي اين عملگر بصورت زير است :

experssion 1? experssion2 :experssion3


در اينجا experssion1 مي تواند هر عبارتي باشد كه با يك مقدار بولي سنجيده
مي شود . اگر experssion1 صحيح true باشد ، آنگاه experssion2 سنجيده مي شود
در غير اينصورت experssion3 ارزيابي خواهد شد . نتيجه عمليات ? همان عبارت
ارزيابي شده است . هر دو عبارت experssion2و experssion3و بايد از يك نوع باشند
كه البته void نمي تواند باشد .
در اينجا مثالي براي استفاده از عملگر ? مشاهده مي كنيد :

+ ratio = denom == 0 ? 0 : num / denom;


هنگاميكه جاوا اين عبارت انتساب را ارزيابي مي كند ، ابتدا به عبارتي كه
سمت چپ علامت سئوال قرار دارد ، نگاه مي كند. اگر denom مساوي صفر باشد ، آنگاه
عبارت بين علامت سئوال و علامت (colon) ارزيابي شده و بعنوان مقدار كل عبارت ?
استفاده مي شود . اگر denom مساوي صفر نباشد ، آنگاه عبارت بعد از (colon)
ارزيابي شده و براي مقدار كل عبارت ? استفاده مي شود . نتيجه توليد شده توسط
عملگر ? سپس به ratio نسبت داده مي شود .
در زير برنامه اي مشاهده مي كنيد كه عملگر ? را نشان مي دهد . اين برنامه از
عملگر فوق براي نگهداري مقدار مطلق يك متغير استفاده مي كند .

+ // Demonstrate ?.
+ class Ternary {
+ public static void main(String args[] ){
+ int i/ k;
+
+ i = 10;
+ k = i < 0 ?- i : i; // get absolute value of i
+ System.out.print("Absolute value of ");
+ System.out.println(i + " is " + k);
+ }
+ }


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

Absolute value of 10 is 10
Absolute value of- 10 is 10



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

Highest
)( [].
++ -- ~ !
* / %
+-
>> >>> <<
> >= < <=
== !=
&
^
|
&&
||
?:
= op=
Lowest


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

[Nesta]

استفاده از پرانتزها

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

+ a >> b + 3


اين عبارت ابتدا 3 را به b اضافه نموده و سپس a را مطابق آن نتيجه بطرف
راست حركت مي دهد. اين عبارت را مي توان با استفاده از پرانتزهاي اضافي بصورت
زير دوباره نويسي نمود :

+ a >>( b + 3)


اما ، اگر بخواهيد ابتدا a را با مكانهاي b بطرف راست حركت داده و سپس 3 را
به نتيجه آن اضافه كنيد ، بايد عبارت را بصورت زير در پرانتز قرار دهيد : +( a >> b )+ 3

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

+ a | 4 + c >> b & 7 || b > a % 3
+( a |((( 4 + c )>> b )& 7 ))||( b >( a % 3))


يك نكته ديگر : پرانتزها ( بطور كلي خواه اضافي باشند يا نه ) سطح عملكرد
برنامه شما را كاهش نمي دهند. بنابراين ، اضافه كردن پرانتزها براي كاهش ابهام نفي روي برنامه شما نخواهد داشت .

[Nesta]

دستورات كنترلي

زبانهاي برنامه نويسي از دستورات كنترلي استفاده مي كنند تا جريان اجراي
برنامه را پيشرفت داده و براساس تغييرات حالت يك برنامه شاخه هايي از آن برنامه
منشعب نمايند . دستورات كنترلي برنامه در جاوا را مي توان در طبقه بندي بعدي
گنجاند : انتخاب (selection) ، تكرار (iteration) ، و پرش (jump) . دستورات
انتخاب به برنامه شما امكان ميدهند تا مسيرهاي متفاوت اجراي برنامه را براساس
حاصل يك عبارت يا حالت خاص يك متغير انتخاب نماييد . دستورات تكرار اجراي
برنامه را قادر مي سازد تا يك يا چند عبارت را تكرار نمايد ( يعني دستورات
تكرار حلقه ها را تشكيل مي دهند ). دستورات پرش به برنامه شما امكان مي دهند تا
يك روش اجراي غير خطي داشته باشيد . كليه دستورات كنترلي جاوا را در اينجا
بررسي نموده ايم .
نكته : اگر C++/C را ميدانيد، دستورات كنترلي جاوا براي شما بسيار آشنا هستند.
در حقيقت ، دستورات كنترلي جاوا براي برنامه نويسان C++/C بسيار يكسان
است . اما تفاوتهاي محدودي وجود دارد بخصوص در دستورات break و

[Nesta]

دستورات انتخاب در جاوا

جاوا از دو دستور انتخاب پشتيباني مي كنند : ifو switchو . با اين دستورات
شما اجراي برنامه را براساس شرايطي كه فقط حين اجراي برنامه اتفاق مي افتند
كنترل مي كنيد. اگر سابقه برنامه نويسي با C++/C را نداريد، از قدرت و انعطاف
پذيري موجود در اين دو دستور متعجب و شگفت زده خواهيد شد .


if


دستور if دستور انشعاب شرطي در جاوا است . از اين دستور مي توان استفاده
نمود و اجراي برنامه را طي دو مسير متفاوت به جريان انداخت . شكل كلي اين دستور
بصورت زير است :

if( condition )statement 1;
else statement 2;


دراينجا هر statement ممكن است يك دستور منفرد يا يك دستور مركب قرار گرفته
در ابروها ( يعني يك بلوك ) باشد . condition ( شرط ) هر عبارتي است كه يك
مقدار boolean را برمي گرداند . جمله else اختياري است . if
بصورت زير كار مي كند : اگر شرايط محقق باشد ، آنگاه statement 1 اجرا
مي شود . در غير اينصورت statement 2 ( در صورت وجود ) اجرا خواهد شد .
تحت هيچ شرايطي هر دو دستور با هم اجرا نخواهند شد . بعنوان مثال ، در نظر
بگيريد :

+ int a/ b;
+ //...
+ if(a < b )a = 0;
+ else b = 0;


در اينجا اگر a كوچكتر از b باشد ، آنگاه a برابر صفر مي شود . در غير
اينصورت b برابر صفر قرار مي گيرد . در هيچ شرايطي اين دو متغير در آن واحد
برابر صفر نمي شوند .
غالب اوقات ، عبارتي كه براي كنترل if استفاده ميشود شامل عملگرهاي رابطه اي
است . اما از نظر تكنيكي ضرورتي وجود ندارد . مي توان با استفاده از يك متغير boolean
تكي ، if را همانطوريكه در بخش زير مشاهده مي كنيد ، كنترل نمود .

+ boolean dataAvailable;
+ //...
+ if( dataAvailable)
+ ProcessData)(;
+ else
+ waitForMoreData)(;


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

+ int bytesAvailable;
+ //...
+ if( bytesAvailable > 0 ){
+ ProcessData)(;
+ bytesAvailable- = n;
+ } else
+ waitForMoreData)(;


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

+ int bytesAvailable;
+ //...
+ if( bytesAvailable > 0 ){
+ ProcessData)(;
+ bytesAvailable- = n;
+ } else
+ waitForMoreData)(;
+ bytesAvailable = n;


بنظر خيلي روشن است كه دستور bytes Available=n طوري طراحي شده تا داخل
جمله else اجرا گردد ، و اين بخاطر سطح طراحي آن است . اما حتما" بياد داريد
كه فضاي خالي براي جاوا اهميتي ندارد و راهي وجود ندارد كه كامپايلر بفهمد چه
مقصودي وجود دارد . اين كد بدون مشكل كامپايل خواهد شد ، اما هنگام اجرا بطور
ناصحيح اجرا خواهد شد . مثال بعدي داخل كدي كه مشاهده مي كنيد تثبيت شده است :

+ int bytesAvailable;
+ //...
+ if( bytesAvailable > 0 ){
+ ProcessData)(;
+ bytesAvailable- = n;
+ } else {
+ waitForMoreData)(;
+ bytesAvailable = n;
+ }
if

هاي تودرتو شده Nested ifs
يك nested if يك دستور if است كه هدف ifيا elseا ديگري باشد. if هاي تودرتو
در برنامه نويسي بسيار رايج هستند. هنگاميكه if ها را تودرتو مي كنيد، مهمترين
چيزي كه بايد بخاطر بسپاريد اين است كه يك دستورelse هميشه به نزديكترين دستور if
خود كه داخل همان بلوك else است و قبلا" با يك else همراه نشده ، مراجعه
خواهد نمود . مثالي را مشاهده نماييد :

+ if(i == 10 ){
+ if(j < 20 )a = b;
+ if(k > 100 )c = d; // this if is
+ else a = c; // associated with this else
+ }
+ else a = d; // this else refers to if(i == 10)


همانگونه كه توضيحات نشان مي دهند ، else نهايي با (20 چون داخل همان بلوك قرار ندارد ( اگر چه نزديكترين if بدون else است ) . بجاي
آن ، else نهايي با (i==10)if همراه مي شود . else داخلي به (100>k)if ارجاع
مي كند ، زيرا نزديكترين if در داخل همان بلوك است .

نردبان if-else-if
يك ساختار برنامه نويسي رايج براساس يك ترتيب از ifهاي تودرتو شده يا نردبان if-else-if
است . اين ساختار بصورت زير است :

if(condition)
statement;
else if(condition)

statement;
else if(condition)
statement;
.
.
.
else
statement;


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

+ // Demonstrate if-else-if statement.
+ class IfElse {
+ public static void main(String args[] ){
+ int month = 4; // April
+ String season;
+
+ if(month == 12 || month == 1 || month == 2)
+ season = "Winter";
+ else if(month == 3 || month == 4 || month == 5)
+ season = "Spring";
+ else if(month == 6 || month == 7 || month == 8)
+ season = "Summer";
+ else if(month == 9 || month == 10 || month == 11)
+ season = "Autumn";
+ else
+ season = "Bogus Month";
+
+ System.out.println("April is in the" + season + ".");
+ }
+ }


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

April is in the Spring.

ممكن است بخواهيد اين برنامه را تجربه نماييد . خواهيد ديد كه هيچ فرقي
ندارد كه چه مقداري به month بدهيد ، يك و فقط يك دستور انتساب داخل نردبان
اجرا خواهد شد .


switch


دستور switch ، دستور انشعاب چند راهه در جاوا است . اين دستور راه ساده اي
است براي تغيير مسير اجراي بخشهاي مختلف يك كد براساس مقدار يك عبارت . اين
روش يك جايگزين مناسب تر براي مجموعه هاي بزرگتر از دستورات if-else-if است .
شكل كلي دستور switch بقرار زير مي باشد :

switch(expression){
case value1:
// statement sequence
break;
case value2:
// statement sequence
break;
.
.
.
case valueN:
// statement sequence
break;
default:
// default statement sequence
}
expression

مي تواند هر نوع ساده اي را برگرداند ، هر يك از مقادير (values)
در دستورات case بايد از نوع سازگار با عبارت باشند . هر يك از مقادير case
بايد يك مقدار لفظي منحصر بفرد باشد ( يعني بايد يك ثابت ، نه متغير ، باشد ).
دو برابر سازي مقادير case مجاز نيست .
دستور switch بشرح فوق عمل مي كند : مقدار عبارت با هر يك از مقادير لفظي
در دستورات case مقايسه مي شوند. اگر تطابق پيدا شود ، كد سلسله اي تعقيب كننده
آن دستور case اجرا خواهد شد . اگر هيچيك از ثابت ها با مقدار عبارت تطابق
نيابند ، آنگاه دستور پيش فرض (default) اجرا خواهد شد ، اما دستور default
اختياري است . اگر هيچيك از case ها تطابق نيابد و default وجود نداشته باشد
آنگاه عمل اضافي ديگري انجام نخواهد شد .
از دستور break داخل دستور switch استفاده شده تا سلسله يك دستور را پايان
دهد . هنگاميكه با يك دستور break مواجه مي شويم ، اجرا به خط اول برنامه كه
بعد از كل دستور switch قرار گرفته ، منشعب خواهد شد . اين حالت تاثير پريدن switch
است .
در زير مثال ساده اي را مشاهده مي كنيد كه از دستور switch استفاده نموده
است :

+ // A simple example of the switch.
+ class SampleSwitch {
+ public static void main(String args[] ){
+ for(int i=0; i<6; i++)
+ switch(i ){
+ case 0:
+ System.out.println("i is zero.");
+ break;
+ case 1:
+ System.out.println("i is one.");
+ break;
+ case 2:
+ System.out.println("i is two.");
+ break;
+ case 3:
+ System.out.println("i is three.");
+ break;
+ default:
+ System.out.println("i is greater then 3.");
+ }
+ }
+ }


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

i is zero.
i is one.
i is two.
i is three.
i is greater than 3.
i is greater than 3.


همانطوريكه مشاهده مي كنيد ، داخل حلقه ، دستوراتي كه همراه ثابت case بوده
و با i مطابقت داشته باشند ، اجرا خواهند شد . ساير دستورات پشت سر گذاشته
مي شوند (bypassed) . بعد از اينكه i بزرگتر از 3 بشود ، هيچ دستور همراه case
مطابقت نداشته ، بنابراين دستور پيش فرض (default) اجرا خواهد شد .
دستور break اختياري است . اگر break را حذف كنيد ، اجراي برنامه با case
بعدي ادامه خواهد يافت . گاهي بهتر است چندين case بدون دستورات break در بين
آنها داشته باشيم . بعنوان مثال ، برنامه بعدي را در نظر بگيريد :

+ // In a switch/ break statements are optional.
+ class MissingBreak {
+ public static void main(String args[] ){
+ for(int i=0; i<12; i++)
+ switch(i ){
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ System.out.println("i is less than 5");
+ break;
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ System.out.println("i is less than 10");
+ break;
+ default:
+ System.out.println("i is 10 or more");
+ }
+ }
+ }


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

i is less than 5
i is less than 5
i is less than 5
i is less than 5
i is less than 5
i is less than 10
i is less than 10
i is less than 10
i is less than 10
i is less than 10
i is 10 or more
i is 10 or more


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

+ // An improved version of the season program.
+ class Switch {
+ public static void main(String args[] ){
+ int month = 4;
+ String season;
+ switch( month ){
+ case 12:
+ case 1:
+ case 2:
+ season = "Winter";
+ break;
+ case 3:
+ case 4:
+ case 5:
+ season = "Spring";
+ break;
+ case 6:
+ case 7:
+ case 8:
+ season = "Summer";
+ break;
+ case 9:
+ case 10:
+ case 11:
+ season = "Autumn";
+ break;
+ default:
+ season = "Bogus Month";
+ }
+ System.out.println("April is in the" + season + ".");
+
+ }
+ }



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

+ switch(count ){
+ case 1:
+ switch(target ){ // nested switch
+ case 0:
+ System.out.println("target is zero");
+ break;
+ case 1 :// no conflicts with outer switch
+ System.out.println("target is one");
+ break;
+ }
+ break;
+ case 2 ://...


در اينجا دستور :case 1در switchر داخلي با دستور :case 1در switchر خارجي
تلاقي نخواهد داشت . متغير count فقط با فهرست case ها در سطح خارجي مقايسه
مي شود. اگر count برابر 1 باشد، آنگاه target با فهرست case هاي داخلي مقايسه
خواهد شد .
بطور خلاصه ، سه جنبه مهم از دستور switch قابل توجه هستند :
ؤ switchبا ifا متفاوت است چون switch فقط آزمايش كيفيت انجام مي دهد ، در
حاليكه if هر نوع عبارت بولي را ارزيابي مي كند . يعني كه switch فقط بدنبال
يك تطابق بين مقدار عبارت و يكي از ثابت هاي case خودش مي گردد .
ؤ دو ثابت caseدر switchر مشابه نمي توانند مقادير يكسان داشته باشند .
البته ، يك دستور switch قرار گرفته داخل يك switch خارجي تر مي تواند ثابتهاي case
مشترك داشته باشد .
ؤ يك دستور switch معمولا" بسيار كاراتر از يك مجموعه از if هاي تودرتو شده
است . آخرين نكته بخصوص جالب توجه است زيرا روشنگر نحوه كار كامپايلر جاوا
مي باشد . كامپايلر جاوا هنگاميكه يك دستور switch را كامپايل مي كند ، به هر
يك از ثابتهاي case سركشي نموده و يك جدول jump table مي سازد كه براي انتخاب
مسير اجرا براساس مقدار موجود در عبارت استفاده مي شود . بنابراين ، اگر بايد
از ميان گروه بزرگي از مقادير انتخاب نماييد ، يك دستور switch نسبت به يك
ترتيب از if-else ها كه بطور معادل و منطقي كد بندي شده باشد ، بسيار سريعتر
اجرا خواهد شد. كامپايلر قادر است اينكار را انجام دهد چون مي داند كه ثابتهاي case
همه از يك نوع بوده و بايد خيلي ساده با عبارت switch براي كيفيت مقايسه
شوند . كامپايلر چنين شناسايي را نسبت به يك فهرست طولاني از عبارات if ندارد .

دستورات تكرار iteration statements
دستورات تكرار در جاوا عبارتند از for، while،و do-whileو . اين دستورات آن
چه را ما " حلقه " مي ناميم ، ايجاد مي كنند . احتمالا" مي دانيد كه حلقه يك
مجموعه از دستورالعملها را بطور تكراري اجرا مي كند . تا اينكه يك شرط پاياني
را ملاقات نمايد . همانطوريكه بعدا" خواهيد ديد، جاوا حلقه اي دارد كه براي كليه
نيازهاي برنامه نويسي مناسب است .


while


حلقه while اساسي ترين دستور حلقه سازي (looping) در جاوا است . اين دستور
ماداميكه عبارت كنترل كننده ، صحيح (true) باشد، يك دستور يا يك بلوك را تكرار
مي كند . شكل كلي اين دستور بقرار زير است :

while(condition ){
// body of loop
}


شرط يا condition ممكن است هر عبارت بولي باشد . ماداميكه عبارت شرطي صحت
داشته باشد ، بدنه حلقه اجرا خواهد شد . هنگاميكه شرط صحت نداشته باشد ، كنترل
بلافاصله به خط بعدي كدي كه بلافاصله پس از حلقه جاري قرار دارد ، منتقل خواهد
شد . اگر فقط يك دستور منفرد در حال تكرار باشد ، استفاده از ابروها غير ضروري
است .
در اينجا يك حلقه while وجود دارد كه تا 10 را محاسبه كرده و دقيقا" ده خط "tick"
را چاپ مي كند .

+ // Demonstrate the while loop.
+ class While {
+ public static void main(String args[] ){
+ int n = 10;
+
+ while(n > 0 ){
+ System.out.println("tick" + n);
+ n--;
+ }
+ }
+ }


هنگاميكه اين برنامه را اجرا مي كنيد، ده مرتبه "tick" را انجام خواهد داد:

tick 10
tick 9
tick 8
tick 7
tick 6
tick 5
tick 4
tick 3
tick 2
tick 1


از آنجاييكه حلقه while عبارت شرطي خود را در بالاي حلقه ارزيابي ميكند، اگر
شرط ابتدايي ناصحيح باشد ، بدنه حلقه اجرا نخواهد شد . بعنوان مثال ، در قطعه
زير ، فراخواني ()println هرگز اجرا نخواهد شد .

+ int a = 10/ b = 20;
+
+ while(a < b)
+ System.out.println("This will not be displayed");


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

+ // The target of a loop can be empty.
+ class NoBody {
+ public static void main(String args[] ){
+ int i/ j;
+
+ i = 100;
+ j = 200;
+
+ // find midpoint between i and j
+ while(++i <-- j); // no body in this loop
+
+ System.out.println("Midpoint is" + i);
+ }
+ }


اين برنامه نقطه مياني (midpoint) بين iو jو را پيدا مي كند و خروجي زير را
توليد خواهد كرد :

Midpoint is 150


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


do-while


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

do{
// body of loop
} while(condition);


هر تكرار از حلقه do-while ابتدا بدنه حلقه را اجرا نموده ، سپس به ارزيابي
عبارت شرطي خود مي پردازد . اگر اين عبارت صحيح (true) باشد ، حلقه اجرا خواهد
شد . در غير اينصورت حلقه پايان مي گيرد . نظير كليه حلقه هاي جاوا ، شرط بايد
يك عبارت بولي باشد .
اينجا يك روايت ديگر از برنامه (tick) وجود دارد كه حلقه do-while را نشان
مي دهد . خروجي اين برنامه مشابه برنامه قبلي خواهد بود :

+ // Demonstrate the do-while loop.
+ class DoWhile {
+ public static void main(String args[] ){
+ int n = 10;
+
+ do {
+ System.out.println("tick" + n);
+ n--;
+ } while(n > 0);
+ }
+ }


حلقه موجود در برنامه قبلي ، اگر چه از نظر تكنيكي صحيح است ، اما مي توان
آن را به شكل كاراتري بصورت زير دوباره نويسي نمود : + do {
+ System.out.println("tick " + n);
+ } while--(n > 0);

در اين مثال ، عبارت (0>n) عمل كاهش n و آزمايش براي صفر را در يك عبارت
گنجانده است . عملكرد آن بقرار بعدي است . ابتدا دستور n اجرا مي شود و n
را كاهش داده و مقدار جديد را به n برمي گرداند . اين مقدار سپس با صفر مقايسه
مي شود . اگر بزرگتر از صفر باشد ، حلقه ادامه مي يابد . در غير اينصورت حلقه
پايان مي گيرد .
حلقه do-while بويژه هنگام پردازش انتخاب منو بسيار سودمند است ، زيرا
معمولا" مايليد تا بدنه يك حلقه منو حداقل يكبار اجرا شود . برنامه بعدي را كه
يك سيستم Help ساده را براي دستورات تكرار و انتخاب در جاوا پياده سازي مي كند
در نظر بگيريد :

+ // Using a do-while to process a menu selection -- a simple help system.
+ class Menu {
+ public static void main(String args[])
+ throws java.io.IOException {
+ char choice;
+
+ do {
+ System.out.prinln("Help on:");
+ System.out.prinln(" 1 .if");
+ System.out.prinln(" 2 .switch");
+ System.out.prinln(" 3 .while");
+ System.out.prinln(" 4 .do-while");
+ System.out.prinln(" 5 .for\n");
+ System.out.prinln("Choose one:");
+ choice =( char )System.in.read)(;
+ } while(choice < '1' || choice > '5');
+
+ System.out.println("\n");
+ switch(choice ){
+ case '1':
+ System.out.println("The if:\n");
+ System.out.println("if(condition )statement;");
+ System.out.println("else statement;");
+ break;
+ case '2':
+
+ System.out.println("The switch:\n");
+ System.out.println("switch(expression ){");
+ System.out.println(" case constant:");
+ System.out.println(" statement sequence");
+ System.out.println(" break;");
+ System.out.println(" //... ");
+ System.out.println("}");
+ break;
+ case '3':
+ System.out.println("The switch:\n");
+ System.out.println(while(condition )statement;");
+ break;
+ case '4':
+ System.out.println("The do-while:\n");
+ System.out.println("do {");
+ System.out.println(" statement;");
+ System.out.println("} while( condition);");
+ break;
+ case '5':
+ System.out.println("The for:\n");
+ System.out.print("for(init; condition; iteration)");
+ System.out.println(" statement;");
+ break;
+ }
+ }
+ }


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

Help on:
1 .if
2 .switch
3 .while
4 .do-while
5 .for
Choos one:
4

The do-while:

do {
statement;
} while( condition);


در برنامه ، از حلقه do-while براي تصديق اينكه كاربر يك گزينه معتبر را
وارد كرده باشد ، استفاده مي شود . در غير اينصورت ، به كاربر مجددا" اعلان
خواهد شد . از آنجاييكه منو بايد حداقل يكبار بنمايش درآيد ، do-while حلقه
كاملي براي انجام اين مقصود است .
چند نكته ديگر درباره اين مثال : دقت كنيد كه كاراكترهااز صفحه كليد بوسيله
فراخواني ()system.in.read خوانده مي شوند . اين يكي از توابع ورودي كنسول در
جاوا است .
اگر چه بررسي تفصيلي روشهاي l/o جاوا به بحثهاي بعدي موكول شده ، اما از
()system.in.read در اينجا براي بدست آوردن گزينه كاربر استفاده شده است . اين
تابع كاراكترها را از ورودي استاندارد مي خواند ( كه بعنوان عدد صحيح برگردان
شد ، اين دليلي است كه چرا مقدار برگردان از طريق تبديل (cast) به char تبديل
شده است ). بصورت پيش فرض ، ورودي استاندارد، بافر شده خطي است (line buffered)
بنابراين قبل از اينكه كاراكترهايي را كه تايپ كرده ايد به برنامه اتان ارسال
كنيد ، بايد كليد ENTER را فشار دهيد . ( اين حالت مشابه C++/C است و احتمالا"
از قبل با آن آشنايي داريد ) .
ورودي كنسول در جاوا كاملا" محدود شده و كار با آن بسيار مشكل است . بعلاوه
اكثر برنامه و ريز برنامه هاي واقعي نوشته شده با جاوا گرافيكي و پنجره اي
هستند. از سوي ديگر : چون از ()system.in.read استفاده شده ، برنامه بايد جمله throwsjava.io.loException
را كاملا" توصيف نمايد . اين خط براي مديريت خطاهاي
ورودي ضروري است . اين بخشي از جنبه هاي مختلف اداره استثنائ در جاوا است كه
بعدا" بررسي خواهد شد .
for

خواهيد ديد كه حلقه for يك ساختار قدرتمند و بسيار روان است .شكل كلي دستور for
بصورت زير است :

for(initialization; condition; iteration; ){
// body
}


اگر فقط يك دستور بايد تكرار شود ، نيازي به ابروها نيست .
عملكرد حلقه for بشرح بعدي است . وقتي كه حلقه براي اولين بار شروع مي شود
بخض مقدار دهي اوليه در حلقه اجرا مي شود . معمولا" ، اين بخش يك عبارت است كه
مقدار متغير كنترل حلقه را تعيين مي كند ، كه بعنوان يك شمارشگر ، كنترل حلقه
را انجام خواهد داد . مهم است بدانيم كه عبارت مقدار دهي اوليه فقط يكبار اجرا
مي شود . سپس شرط مورد ارزيابي قرار مي گيرد . اين شرط بايد يك عبارت بولي
باشد . اين بخش معمولا" مقدار متغير كنترل حلقه را با مقدار هدف مقايسه مي كند.
اگر عبارت صحيح (true) باشد، آنگاه بدنه حلقه اجرا خواهد شد . اگر ناصحيح باشد
حلقه پايان مي گيرد . بعد، بخش تكرار (iteration) حلقه اجرا مي شود . اين بخش
معمولا" عبارتي است كه مقدار متغير كنترل را افزايش يا كاهش مي دهد. آنگاه حلقه
تكرار خواهد شد ، ابتدا عبارت شرطي را ارزيابي مي كند ، سپس بدنه حلقه را اجرا
مي كند و سرانجام عبارت تكرار را در هر گذر (pass) اجرا ميكند. اين روال آنقدر
دادمه مي يابد تا عبارت شرطي ناصحيح (false) گردد .
در زير روايت جديدي از برنامه "tick" را مي بينيد كه از يك حلقه for استفاده
كرده است :

+ // Demonstrate the for loop.
+ class ForTick {
+ public static void main(String args[] ){
+ int n;
+ for(n=10; n>0; n)--
+ System.out.println("tick" + n);
+ }
+ }



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

+ // Declare a loop control variable inside the for.
+ class ForTick {
+ public static void main(String args[] ){
+
+ // here/ n is declared inside of the for loop
+ for(int n=10; n>0; n)--
+ System.out.println("tick" + n);
+ }
+ }


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

+ // Test for primes.
+ class FindPrime {
+ public static void main(String args[] ){
+ int num;
+ boolean isPrime = true;
+
+ num = 14;
+ for(int i=2; i < num/2; i++ ){
+ if((num % i )== 0 ){
+ isPrime = false;
+ break;
+ }
+ }
+ if(isPrime )System.out.println("Prime");
+ else System.out.println("Not Prime");
+ }
+ }


استفاده از كاما Comma
شرايطي پيش مي آيد كه مايليد بيش از يك دستور در بخش مقدار دهي اوليه
(initalization) و تكرار (iteration) بگنجانيد . بعنوان مثال ، حلقه موجود در
برنامه بعدي را در نظر بگيريد :

+ class Sample {
+ public static void main(String args[] ){
+ int a/ b;
+
+ b = 4;
+ for(a=1; a + System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ b--;
+ }
+ }
+ }


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

+ // Using the comma.
+ class Comma {
+ public static void main(String args[] ){
+ int a/ b;
+
+ for(a=1/ b=4; a + System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ }
+ }
+ }


در اين مثال ، بخش مقدار دهي اوليه ، مقادير aو bو را تعيين مي كند . هربار
كه حلقه تكرار مي شود ، دو دستور جدا شده توسط كاما در بخش تكرار (itration)
اجرا خواهند شد . خروجي اين برنامه بقرار زير مي باشد :

a=1
b=4
a=2
b=3


نكته : اگر با C++/C آشنايي داريد ، حتما" مي دانيد كه در اين زبانها ، علامت
كاما يك عملگر است كه در هر عبارت معتبري قابل استفاده است . اما در
جاوا اينطور نيست . در جاوا ، علامت كاما يك جدا كننده است كه فقط در
حلقه for قابل اعمال مي باشد .

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

+ boolean done = false;
+
+ for(int i=1; !done; i++ ){
+ //...
+ if(intettupted ))(done = true;
+ }


در اين مثال ، حلقه for تا زمانيكه متغير بولي done معادل true بشود ، اجرا
را ادامه خواهد داد . اين مثال مقدار i را بررسي نمي كند .
اكنون يكي ديگر از گوناگونيهاي جالب حلقه for را مشاهده مي كنيد. ممكن است
يكي يا هر دو عبارت مقدار دهي اوليه و تكرار غايت باشند ، نظير برنامه بعدي :

+ // Parts of the for loop can be empty.
+ class ForVar {
+ public static void main(String args[] ){
+ int i;
+ boolean done = false;
+
+ i = 0;
+ for (; !done; ) {
+ System.out.println("i is" + i);
+ if(i == 10 )done = true;
+ i++;
+ }
+ }
+ }


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

+ for (; ; ) {
+ //...
+ }


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

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

+ // Loops may be nested.
+ class Nested {
+ public static void main(String args[] ){
+ int i/ j;
+
+ for(i=0; i<10; i++ ){
+ for(j=i; j<10; j++)
+ System.out.print(".");
+ System.out.println)(;
+ }
+ }
+ }


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

[Nesta]

دومين برنامه كوتاه

شايد در يك زبان برنامه نويسي هيچ مفهومي اساسي تر از يك متغير (Variable)
نباشد. به احتمال زياد مي دانيد كه يك متغير مكاني از حافظه نامگذاري شده است
كه توسط برنامه شما مقداري به آن نسبت داده مي شود . مقدار يك متغير ممكن است
حين اجراي يك برنامه تغيير يابد . برنامه بعدي نشان مي دهد كه چگونه يك متغير
را اعلان نموده و چگونه مقداري را به آن نسبت مي دهيم . علاوه بر اين ، برنامه
همچنين نشاندهنده برخي جنبه هاي خروجي كنسول نيز ميباشد. همانطوريكه " توضيحات "
در بالاي برنامه بيان مي كنند ، بايد اين فايل را Example2.java بناميد .

+ /*
+ Here is another short example.
+ Call this file "Example2.java".
+ */
+ class Example2 {
+ public static void main(String args [] ){
+ int num; // this declares a variable called num
+ num = 100; // this assigns num the value 100
+ System.out.println("This is num :" + num);
+ num = num * 2;
+ System.out.print("The value of num * 2 is *);
+ System.out.println(num);
+ }
+ }


هنگاميكه اين برنامه را اجرا كنيد ، خروجي زير را مشاهده مي كنيد : This is num :100
The value of num * 2 is 200

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

+ int num; // this declares a variable called num


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

type var-name;


در اينجا type مشخص كننده نوع متغيري است كه اعلان خواهد شد، و var-name نام
آن متغير است . اگر مي خواهيد بيش از يك متغير از آن نوع مشخص شده اعلان كنيد
مي توانيد با استفاده از فهرست كاما (comma) اسامي متغيرها را جدا كنيد . جاوا
چندين نوع داده را تعريف مي كند كه دربرگيرنده اعداد صحيح (integer) ، كاراكتر
(character) و اعشاري (floating-point) مي باشد . واژه كليدي int مشخص كننده
نوع عدد صحيح است .
در برنامه ، خط زير :

+ num = 100; // this assigns num the value 100


مقدار 100 را به متغير num نسبت مي دهد. در جاوا، عملگر (operator) انتساب
يك علامت تساوي تكي (=) است .
خط بعدي كد ، مقدار متغير num را بعنوان خروجي ارائه داده و البته قبل از
اين مقدار رشته "This is num" قرار خواهد گرفت .

+ System.out.println("This is num :" + num);


در اين دستور ، علامت تساوي سبب مي شود تا مقدار متغير num با رشته اي كه قبل
از آن قرار مي گيرد پيوسته باشد ، و رشته حاصل سرانجام خروجي خواهد شد . ( در
واقع ، num ابتدا از شكل يك عدد صحيح به معادل رشته اي خود تبديل شده و سپس به
رشته قبل از خود پيوسته خواهد شد . اين رويه بعدا" بررسي خواهد شد. ) اين شيوه
را مي توان عمومي نمود. با استفاده از عملگر + ، مي توانيد هر تعداد اقلام مورد
نظرتان را در داخل يك دستور تكي ()println به رشته درآوريد .
خط بعدي كد ، مقدار متغير num را در 2 ضرب نموده و حاصل را به متغير num
نسبت مي دهد . نظير اكثر زبانهاي برنامه نويسي ، جاوا از عملگر * براي نشان
دادن عمل ضرب استفاده مي كند . بعد از اينكه اين خط اجرا شود ، متغير num دربر
گيرنده مقدار 200 خواهد بود .
اكنون دو خط بعدي برنامه را بررسي مي كنيم :

+ System.out.print("This value of num * 2 is ");
+ System.out.println(num);


چند مورد جديد اينجا در حال وقوع است . اول اينكه از روش توكار ()print
استفاده شده تا رشته "The value of num *2 is" بنمايش درآيد . بعد از اين رشته
يك خط جديد نخواهد آمد. اين بدان معني است كه وقتي خروجي بعدي توليد شود، همان
خط شروع خواهد شد . روش ()print مشابه روش ()println مي باشد ، بجز اينكه آن
روش اول بعد از هر فراخواني يك كاراكتر خط جديد خارج نخواهد كرد . اكنون به
فراخواني ()println نگاه كنيد . دقت كنيد كه متغير num توسط خودش مورد استفاده
قرار مي گيرد . هم ()print و هم ()println را مي توان براي خروجي مقادير هر يك تفاده قرار داد .

[Nesta]

معرفي كلاسها

كلاس هسته اصلي جاوا است . كلاس يك ساختار منطقي است كه تماميت زبان جاوا بر
آن استوار شده ، زيرا شكل (shape) و طبيعت يك شي ئ را روشن مي كند . كلاس همچنين
شكل دهنده اساس برنامه نويسي شي ئ گرا در جاوا مي باشد. هر مفهومي كه مايليد در
يك برنامه جاوا پياده سازي نماييد بايد ابتدا داخل يك كلاس كپسول سازي شود .
از اين پس مي آموزيد چگونه يك كلاس را براي توليد اشيائاستفاده كنيد. همچنين
درباره روشها (methods) و سازنده ها (constructors) و واژه كليدي this مطالبي
مي آموزيد .

[Nesta]

بنيادهاي كلاس

كلاسهاي توليد شده در بحثهاي گذشته فقط براي كپسول سازي روش ()main استفاده
مي شد ، كه براي نشان دادن اصول دستور زبان جاوا مناسب بودند . شايد بهترين
چيزي كه بايد درباره يك كلاس بدانيد اين است كه كلاس يك نوع جديد داده را تعريف
مي كند . هربار كه اين نوع تعريف شود ، مي توان از آن براي ايجاد اشيائي از
همان نوع استفاده نمود . بنابراين ، يك كلاس قالبي (template) براي يك شي ئ است
و يك شي ئ نمونه اي (instance) از يك كلاس است . چون شي ئ يك نمونه از يك كلاس است
غالبا" كلمات شي ئ (object) و نمونه (instance) را بصورت مترادف بكار مي بريم .

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

type methodname2(parameter-list ){
// body of method
}
//...
type methodnameN(parameter-list ){
// body of method
}
}


داده يا متغيرهايي كه داخل يك كلاس تعريف شده اند را متغيرهاي نمونه instance)
(variables مي نامند . كدها ، داخل روشها (methods) قرار مي گيرند . روشها و
متغيرهاي تعريف شده داخل يك كلاس را اعضائ (members) يك كلاس مي نامند . در اكثر
كلاسها ، متغيرهاي نمونه يا روي روشهاي تعريف شده براي آن كلاس عمل كرده يا توسط
اين روشها مورد دسترسي قرار مي گيرند . بنابراين ، روشها تعيين كننده چگونگي
استفاده از داده هاي يك كلاس هستند .
متغيرهاي تعريف شده داخل يك كلاس ، متغيرهاي نمونه خوانده شده زيرا هر نمونه
از كلاس ( يعني هر شي ئ يك كلاس ) شامل كپي خاص خودش از اين متغيرهاست . بنابراين
داده مربوط به يك شي ئ ، جدا و منحصر بفرد از داده مربوط به شي ئ ديگري است . ما
بزودي اين نكته را بررسي خواهيم نمود ، اما فعلا" بايد اين نكته بسيار مهم را
بياد داشته باشيد .
كليه روشها نظير()main همان شكل عمومي را دارند كه تاكنون استفاده كرده ايم .
اما ، اكثر روشها را بعنوان staticيا publicا توصيف نمي كنند . توجه داشته
باشيد كه شكل عمومي يك كلاس ، يك روش ()main را توصيف نمي كند . كلاسهاي جاوا
لزومي ندارد كه يك روش ()main داشته باشند . فقط اگر كلاس ، نقطه شروع برنامه
شما باشد ، بايد يك روش ()main را توصيف نماييد . علاوه بر اين ، ريز برنامه ها
(applets) اصولا" نيازي به روش ()main ندارند .
نكته : برنامه نويسان C++ آگاه باشند كه اعلان كلاس و پياده سازي روشها در يك
مكان ذخيره شده و بصورت جداگانه تعريف نمي شوند. اين حالت گاهي فايلهاي
خيلي بزرگ java ايجاد مي كند ، زيرا هر كلاس بايد كاملا" در يك فايل منبع
تكي تعريف شود . اين طرح در جاوا رعايت شد زيرا احساس مي شد كه در بلند
مدت ، در اختيار داشتن مشخصات ، اعلانها و پياده سازي در يك مكان ، امكان
دسترسي آسانتر كد را بوجود مي آورد .

يك كلاس ساده
بررسي خود را با يك نمونه ساده از كلاسها شروع مي كنيم . در اينجا كلاسي تحت
غنوان Box وجود دارد كه سه متغير نمونه را تعريف مي كند : width، height، و depth
و فعلا" ، كلاس Box دربرگيرنده روشها نيست .

+ class Box {
+ double width;
+ double height;
+ double depth;
+ }


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

+ Box mybox = new Box)(; // create a Box object called mybox


پس از اجراي اين دستور ، mybox نمونه اي از Box خواهد بود. و بدين ترتيب اين
شي ئ وجود فيزيكي و واقعي پيدا مي كند .
مجددا" بياد داشته باشيد كه هر بار يك نمونه از كلاسي ايجاد مي كنيد ، شيئي
ايجاد كرده ايد كه دربرگيرنده كپي ( نسخه خاص ) خود از هر متغير نمونه تعريف
شده توسط كلاس خواهد بود . بدين ترتيب ، هر شي ئ Box دربرگيرنده كپي هاي خود از
متغيرهاي نمونه width، heidht،و depthو مي باشد . براي دسترسي به اين متغيرها
از عملگر نقطه (.) استفاده مي كنيد . عملگر نقطه اي ، نام يك شي ئ را با نام يك
متغير نمونه پيوند مي دهد . بعنوان مثال ، براي منتسب كردن مقدار 100 به متغير width
در myboxر ، از دستور زير استفاده نماييد :

+ mybox.width = 100;


اين دستور به كامپايلر مي گويد كه كپي width كه داخل شي ئ mybox قرار گرفته
را معادل عدد 100 قرار دهد . بطور كلي ، از عملگر نقطه اي براي دسترسي هم به
متغيرهاي نمونه و هم به روشهاي موجود در يك شي ئ استفاده مي شود .
دراينجا يك برنامه كامل را مشاهده ميكنيد كه از كلاس Box استفاده كرده است :

+ /* A program that uses the Box class.
+
+ Call this file BoxDemo.java
+ /*
+ class Box {
+ double width;
+ double height;
+ double depth;
+ }
+
+ // This class declares an object of type Box.
+ class BoxDemo {
+ public static void main(String args[] ){
+ Box mybox = new Box)(;
+ double vol;
+
+ // assign values to mybox's instance variables
+ mybox.width = 10;
+ mybox.height = 20;
+ mybox.depth = 15;
+
+ // compute volume of box
+ vol = mybox.width * mybox.height * mybox.depth;
+
+ System.out.println("Volume is " + vol);
+ }
+ }


فايلي را كه دربرگيرنده اين برنامه است بايد با نام BoxDemo.java بخوانيد
زيرا روش ()main در كلاس BoxDemo و نه در كلاس Box قرار گرفته است . هنگاميكه اين
برنامه را كامپايل مي كنيد ، مي بينيد كه دو فايل class. ايجاد شده اند ، يكي
براي Box و ديگري براي BoxDemo . كامپايلر جاوا بطور خودكار هر كلاس را در فايل class
. مربوط به خودش قرار مي دهد . ضرورتي ندارد كه كلاس Boxو BoxDemoو هر دو
در يك فايل منبع قرار گيرند . مي توانيد هر كلاس را در فايل خاص خودش گذاشته و
آنها را بترتيب Box.javaو BoxDemo.javaو بناميد .
براي اجراي اين برنامه بايد BoxDemo.class را اجرا كنيد . پس از اينكار
حاصل زير را بدست مي آوريد :

Volume is 3000


قبلا" هم گفتيم كه هر شي ئ داراي كپي هاي خاص خودش از متغيرهاي نمونه است .
يعني اگر دو شي ئ Box داشته باشيد، هركدام بتنهايي كپي ( يا نسخه اي ) از lenght width
و heightو خواهند داشت . مهم است بدانيد كه تغييرات در متغيرهاي نمونه يك
شي ئ تاثيري روي متغيرهاي نمونه كلاس ديگر نخواهد داشت . بعنوان مثال ، برنامه
بعدي دو شي ئ Box را اعلان مي كند :

+ // This program declares two Box objects.
+
+ class Box {
+ double width;
+ double height;
+ double depth;
+ }
+
+ class BoxDemo2 {
+ public static void main(String args[] ){
+
+ Box mybox1 = new Box)(;
+ Box mybox2 = new Box)(;
+ double vol;
+
+ // assign values to mybox1's instance variables
+ mybox1.width = 10;
+ mybox1.height = 20;
+ mybox1.depth = 15;
+
+ /* assign different values to mybox2's
+ instance variables */
+ mybox2.width = 3;
+ mybox2.height = 6;
+ mybox2.depth = 9;
+
+ // compute volume of first box
+ vol = mybox1.width * mybox1.height * mybox1.depth;
+ System.out.println("Volume is " + vol);
+
+ // compute volume of second box
+ vol = mybox2.width * mybox2.height * mybox2.depth;
+ System.out.println("Volume is " + vol);
+ }
+ }


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

Volume is 3000
Volume is 162


بخوبي مشاهده مي كنيد كه داده مربوط به mybox1 كاملا" از داده موجود در

[Nesta]

اعلان نمودن اشيائ

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

+ Box mybox = new Box)(;


اين دستور دو مرحله گفته شده را با يكديگر تركيب نموده است . براي اينكه هر
يك از مراحل را روشن تر درك كنيد، ميتوان آن دستور را بصورت زير بازنويسي نمود:


+ Box mybox; // declare reference to object
+ mybox = new Box)(; // allocate a Box object


خط اول ، myBox را بعنوان يك ارجاع به شيئي از نوع Box اعلان مي كند . پس از
اجراي اين خط ، mybox محتوي تهي (null) خواهد داشت كه نشانگر آن است كه هنوز
شي ئ بطور واقعي بوجود نيامده است . هر تلاشي براي استفاده ازmybox در اين مرحله
سبب بروز خطاي زمان كامپايل (compile-time error) خواهد شد . خط بعدي يك شي ئ
واقعي را تخصيص داده و يك ارجاع از آن به mybox انجام مي دهد . پس از اجراي خط
دوم ، مي توانيد از mybox بعنوان يك شي ئ Box استفاده نماييد . اما در واقعيت mybox
خيلي ساده آدرس حافظه شي ئ واقعي Box را نگهداري مي كند . تاثير اين دو
خط كد را در شكل زير نشان داده ايم .
نكته : كساني كه با C++/C آشنايي دارند احتمالا" توجه نموده اند كه ارجاعات شي ئ
مشابه اشاره گرها هستند . اين تشابه تا حدود زيادي صحيح است . يك ارجاع
شي ئ (object reference) مشابه يك اشاره گر حافظه است . مهمترين تفاوت
و كليد ايمني در جاوا اين است كه نمي توانيد از ارجاعات همچون
اشاره گرهاي واقعي استفاده نماييد . بدين ترتيب ، نمي توانيد ارجاع شي ئ
را بعنوان اشاره اي به موقعيت دلخواه حافظه يا بعنوان يك عدد صحيح بكار
بريد .

Statement Effect


Box mybox; | null |

mybox

|
| Width > | ;()mybox = new Box
mybox | Height |

| Depth |

Box object



نگاهي دقيقتر به new
شكل عمومي عملگر new بقرار زير مي باشد :

class-var = new classname)(;


در اينجا class-var يك متغير از نوع كلاسي است كه ايجاد كرده ايم . class name
نام كلاسي است كه مي خواهيم معرفي كنيم . نام كلاس كه بعد از آن پرانتزها قرار
گرفته اند مشخص كننده سازنده (constructor) كلاس است . سازنده تعريف مي كند كه
وقتي يك شي ئ از يك كلاس ايجاد شود ، چه اتفاقي خواهد افتاد . سازنده ها بخش مهمي
از همه كلاسها بوده و خصلتهاي بسيار قابل توجهي دارند .
بسياري از كلاسهاي دنياي واقعي (real-world) بطور صريحي سازندگان خود را
داخل تعريف كلاس ، معرفي مي كنند . اما اگر سازنده صريحي مشخص نشده باشد ، جاوا
بطور خودكار يك سازنده پيش فرض را عرضه مي كند . درست مثل حالت Box .
در اين مرحله ، ممكن است تعجب كنيد كه چرا از new براي مواردي نظير اعداد
صحيح و كاراكترها استفاده نمي شود. جواب اين است كه انواع ساده در جاوا بعنوان
اشيائ پياده سازي نمي شوند . در عوض ، آنها بعنوان متغيرهاي عادي پياده سازي
مي شوند. اينكار براي افزايش كارايي انجام مي گيرد. جاوا قادراست بدون استفاده
از رفتارهاي خاص نسبت به اشيائ، اين انواع ساده را بطور موثري پياده سازي كند.
نكته مهم اين است كه new حافظه را براي يك شي ئ طي زمان اجرا تخصيص مي دهد .
مزيت اين روش آن است كه برنامه شما ميتواند اشيائ مورد نيازش را طي زمان اجراي
برنامه ايجاد كند . اما از آنجاييكه محدوديت حافظه وجود دارد ، ممكن است new
بعلت عدم كفايت حافظه نتواند حافظه را به يك شي ئ تخصيص دهد . اگر چنين حالتي
پيش بيايد، يك استثنائ حين اجرا واقع خواهد شد. ولي در زبانهاي C++/C در صورت
عدم موفقيت ، مقدار تهي (null) برگردان مي شود .
اجازه دهيد يكبار ديگر تفاوت بين يك كلاس و يك شي ئ را مرور كنيم . يك كلاس
يك نوع جديد داده را ايجاد مي كند كه مي توان براي توليد اشيائ از آن نوع
استفاده نمود. يعني يك كلاس يك چهارچوب منطقي ايجاد مي كند كه ارتباط بين اعضائ
را توصيف مي نمايد . هنگاميكه يك شي ئ از يك كلاس را اعلان مي كنيد ، در حقيقت
نمونه اي از آن كلاس را بوجود آورده ايد. بدين ترتيب ، كلاس يك ساختار منطقي است .
يك شي داراي واقعيت فيزيكي است . ( يعني يك شي ئ فضايي از حافظه را اشغال در ذهن داشته باشيد .

[Nesta]

انتساب متغيرهاي ارجاع شي ئ

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

+ Box b1 = new Box)(;
+ Box b2 = b1;


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




| |
| Width |
> b1 | Height | Box object

> |
| Depth |
|


اگرچه b1و b2و هر دو به يك شي ئ ارجاع مي كنند ، اما بطريق ديگري با يكديگر
پيوند ندارند. بعنوان مثال ، يك شي ئ پس آيند ( متعاقب ) به b1 خيلي ساده b1 را
از شي ئ اوليه جدا كرده (un hook) بدون اينكه تاثيري روي شي ئ اوليه يا b2 داشته
باشد . بعنوان مثال :

+ Box b1 = new Box)(;
+ Box b2 = b1;
+ //...
+ b1 = null;


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