Java

[B@RBOD]

عملگرهاي رابطه اي

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

نتيجه آن عملگر

مساوي با ==
نامساوي با !=
>بزرگتر از
<كوچكتر از
بزرگتر از يا مساوي با = >
كوچكتر از يا مساوي با = <

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

هر نوعي در جاوا شامل اعداد صحيح ، ارقام اعشاري ، كاراكترها و عبارات بولي را مي توان بوسيله آزمون تساوي == و آزمون عدم تساوي != مقايسه نمود . دقت نماييد كه در جاوا ( نظير Cو C++و ) تساوي توسط دو علامت تساوي و نه يك علامت نشان داده مي شود . ( بياد آوريد كه علامت تكي تساوي يك عملگر انتساب است . )
عملگرهاي ترتيب بندي فقط براي مقايسه انواع عددي بكار مي روند . يعني فقط عملوندهاي اعداد صحيح ، اعداد اعشاري و كاراكترها را مي توان مقايسه نمود و و تعيين كرد كه كداميك از ديگري بزرگتر يا كوچكتر است .
گفتيم كه نتيجه توليد شده توسط يك عملگر رابطه اي ، يك مقدار boolean است .

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

+ int a = 4;
+ int b = 1;
+ boolean c = a < b;

در اين حالت ، جواب b اگر سابق برنامه نويسي C++/C داريد ، به نكته زير توجه نماييد . در C++/C
اين نوع از دستورات بسيار رايج است .

+ int done;
+ //...
+ if(!done ... )// Valid in C/C++
+ if(done ... )// but not in Java.

در جاوا ، آن دستورات بايد بصورت زير دوباره نويسي شوند :
+ if(done == 0 ... )// This is Java-style.
+ if(done != 0... )

علت آن است كه در جاوا صحيح و ناصحيح (true and false) مشابه C++/C تعريف نشده است . در C++/C صحيح هر مقدار غير صفر و ناصحيح معادل صفر است . در جاوا trueو falseو مقادير غيرعادي هستند كه ربطي با صفر يا غيرصفر ندارند. بنابراين براي آزمون صفر و غير صفر، بايد بطور صريح يك يا چند عملگر رابطه اي را استخدام كنيد .

[B@RBOD]

عملگرهاي منطقي بولي كه در زير نشان داده ايم فقط روي عملوندهاي بولي عمل مي كنند . كليه عملگرهاي منطقي باينري دو مقدار boolean را تركيب مي كنند تا يك مقدار منتج boolean ايجاد نمايند .

نتيجه آن عملگر

AND
منطقي & OR
منطقي | XOR
منطقي ( خارج ) ^ OR
مدار كوتاه || AND
مدار كوتاه && NOT
يكاني منطقي !
انتساب AND &=
انتساب OR |=
انتساب XOR ^=
مساوي با ==
نامساوي با !=
سه تايي if-tethen-eselse :?
عملگرهاي بولي منطقي &، |،، ^، روي مقادير Boolean همانطوري كه روي بيت هاي
يك عدد صحيح رفتار مي كنند ، عمل خواهند كرد . عملگر منطقي ! حالت بولي را
معكوس مي كند :
!false=true t!true=false


جدول بعدي تاثيرات هر يك از عمليات منطقي را نشان مي دهد : A B A|B A&B A^B !A


False False False False False True
True False True False True False
False True True False True True
True True True True False False


در زير برنامه اي را مشاهده مي كنيد كه تقريبا" با مثال Bitlogic قبلي برابر است ، اما در اينجا بجاي بيت هاي باينري روي مقادير منطقي بولي عمل مي كند :

+ // Demonstrate the boolean logical operators.
+ class BoolLogic {
+ public static void main(String args[] ){
+ boolean a = true;
+ boolean b = false;
+ boolean c = a | b;
+ boolean d = a & b;
+ boolean e = a ^ b;
+ boolean f =( !a & b )|( a & !b);
+ boolean g = !a;
+ System.out.println(" a = " + a);
+ System.out.println(" b = " + b);
+ System.out.println(" a|b = " + c);
+ System.out.println(" a&b = " + d);
+ System.out.println(" a^b = " + e);
+ System.out.println("!a&b|a&!b = " + f);
+ System.out.println(" !a = " + g);
+ }
+ }



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

a = true
b = false
a|b = true
a&b = false
a^b = true
!a&b|a&!b = true
!a = false

عملگرهاي منطقي مدار كوتاه
جاوا دو عملگر بولي بسيار جالب دارد كه در اكثر زبانهاي ديگر برنامه نويسي وجود ندارند . اين ها روايت ثانويه عملگرهاي ANDو ORو بولي هستند و بعنوان عملگرهاي منطقي مدار كوتاه معرفي شده اند. در جدول قبلي مي بينيد كه عملگر OR هرگاه كه A معادل true باشد، منجر به true مي شود، صرفنظر از اينكه B چه باشد.

بطور مشابه ، عملگر AND هرگاه A معادل false باشد منجر به false مي شود. صرفنظر از اينكه B چه باشد . اگر از اشكال ||و &&و بجاي |و &و استفاده كنيد، هنگاميكه حاصل يك عبارت مي تواند توسط عملوند چپ بتنهايي تعيين شود ، جاوا ديگر به ارزيابي عملوند راست نخواهد پرداخت . اين حالت بسيار سودمند است بخصوص وقتي كه عملوند سمت راست بستگي به عملوند سمت چپ و trueيا falseا بودن آن براي درست عمل كردن داشته باشد . بعنوان مثال ، كد قطعه اي زير به شما نشان مي دهد چگونه مي توانيد مزاياي ارزيابي منطقي مدار كوتاه را استفاده نموده تا مطمئن شويد كه عمليات تقسيم قبل از ارزيابي آن معتبر است .

+ if(denom != 0 && num / denom > 10)

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

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

+ if(c==1 & e++ < 100 )d = 100;

[B@RBOD]

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

[B@RBOD]

عملگر ?

جاوا شامل يك عملگر سه تايي ويژه است كه مي تواند جايگزين انواع مشخصي از دستورات 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

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

[B@RBOD]

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

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

+ 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))



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

[B@RBOD]

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

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

دستور 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

[B@RBOD]

يك 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 در داخل همان بلوك است .

[B@RBOD]

نردبان 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 ، دستور انشعاب چند راهه در جاوا است . اين دستور راه ساده اي است براي تغيير مسير اجراي بخشهاي مختلف يك كد براساس مقدار يك عبارت . اين روش يك جايگزين مناسب تر براي مجموعه هاي بزرگتر از دستورات 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 + ".");
+
+ }
+ }

[B@RBOD]

تودرتو كردن دستورات 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 ندارد .

[B@RBOD]

دستورات تكرار iteration statements
دستورات تكرار در جاوا عبارتند از for، while،و do-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 باشد . ) همانطوريكه مي بينيد ، نيازي به بدنه حلقه نيست ، كليه عمليات داخل خود عبارت شرطي اتفاق
مي افتد . در كدهاي حرفه اي نوشته شده ديگر جاوا ، وقتي كه عبارت كنترل كننده توانايي مديريت كليه جزئيات خود را داشته باشد ، حلقه هاي كوتاه غالبا" بدون بدنه كد بندي مي شوند .