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

[Nesta]

سلام دوستان به دلیل این که این مبحث بسیار زیاد هست بقیه آموزش رو 2-3 روز دیگه می‌گذارم

[Spy]

ای ولللللللللللللللللل ...اگه متهم به هرزه نویسی هم بشم لازم میدونم از اینکه این اطلاعات کامل رو گذاشتی تشکر بکنم

[مهمان]

سلام کارلوس جان
ممنون از بابت مقاله
مشکل بسياري از برنامه نويسها آموزش زبان و syntax نمي باشد.
اگر بتوني از پايه بحث زبانها را بگذاري خيلي بهتره.
مثلا اين که چطوري فايل جاوا ايجاد کنيد و آن را کامپايل کنيد و اجرا نماييد.
لطفا درباره J2ME اگر اطلاعاتي داريد ارائه دهيد.
اين که چطور ميشه برنامه تحت جاوا را براي موبايل کامپايل کرد.
باز هم تشکر

[Nesta]

سلام دوستان به دلیل این که این مبحث بسیار زیاد هست بقیه آموزش رو 2-3 روز دیگه می‌گذارم

سلام امیر جان اگه اینجا رو خونده باشی‌ گفتم این بحث ادامه داره باشه قدم به قدم همه هم مشگل این چیز هرو ندران من فعلا از پای شروع کردم تا برم به بالا

[مهمان]

سلام نستا جان
پس بقيه مطلب چي شد!!!

[Nesta]

يك نكته درباره اشاره گرها (pointers) به برنامه نويسان Cو C++و

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

[Nesta]

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

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

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


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

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

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

+ c:\>javac Example.java


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

+ c:\>java Example


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

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

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


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


اين يك " توضيح "(Comment() است . مثل بسياري از زبانهاي برنامه نويسي ،جاوا
به شما امكان وارد نمودن يك ملاحظه (Remark) در فايل منبع برنامه را مي دهد .
محتوي يك " توضيح " توسط كامپايلر ناديده گرفته خواهد شد . در عوض ، يك "
توضيح " ، توصيف كننده يا شرح دهنده عملكرد برنامه است به هر كسي كه كد منبع
را مطالعه نمايد . در اين مثال ، " توضيح " ، توصيف كننده برنامه بوده و بياد
شما مي اندازد كه فايل منبع را بايدExample.java بناميد . البته ، در برنامه هاي
واقعي ،" توضيحات " بطور كلي توصيف مي كنند كه چگونه برخي از بخشهاي يك برنامه
كار كرده و يا اينكه يك جنبه خاص از برنامه چكاري انجام خواهد داد .
جاوا از سه روش براي " توضيحات " پشتيباني مي كند. اول آن چيزي است كه بالاي
برنامه مشاهده مي كنيد كه آن را توضيح چند خطي (multiline comment) مي گويند .
اين نوع از " توضيح " بايد با علامت /* و با علامت */ پايان يابد . هر چيزي كه
بين اين دو علامت قرار گيرد توسط كامپايلر ناديده گرفته خواهد شد . همانطوريكه
از نام اين روش پيداست ، يك توضيح ، چند خطي ممكن است چندين خط دراز داشته
باشد .
خط بعدي كد برنامه بصورت زير مي باشد :

+ class Exaple {


اين خط از واژه كليدي class استفاده مي كند تا اعلان نمايد كه يك كلاس جديد
در حال تعريف شدن است . Example شناسه اي (identifier) است كه نام كلاس مي باشد.
كل تعريف كلاس ، شامل : كليه اعضائ خود ، بين علامات ابروباز ({) و ابروبسته (})
قرار مي گيرد . استفاده از علامات فوق در جاوا مشابه روش استفاده از آنها در C
و C++ است . فعلا" درباره جزئيات مربوط به يك كلاس نگران نباشيد مگر دقت به اينكه
در جاوا ، كليه فعاليت برنامه اي داخل يك علامت اتفاق مي افتد . اين امر يكي از
دلايلي است كه كليه برنامه هاي جاوا شي ئ گرا هستند .
خط بعدي برنامه يك " توضيح يك خطي "(single-line comment() بصورت زير است :

+ // Your program begins with a call to main.)(


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

+ public static void main( String args [] ){


اين خط شروع كننده روش ()main است . همانطوريكه توضيح متعاقب آن پيشنهاد
مي كند ، اين خطي است كه برنامه در آن شروع به اجرا مي نمايد . كليه برنامه هاي
كاربردي جاوا با فراخواني ()main شروع به اجرا مي كنند. ( درست شبيه C++/C. ).
معناي دقيق بخشهاي مختلف اين خط را فعلا" نمي توان توضيح داد ، زيرا درك آن
مستلزم آگاهي از روش Java براي كپسول سازي است . اما از آنجاييكه اكثر مثالهاي
موجود در بيشتر قسمتهاي اين بحث از اين خط از كط استفاده مي كنند ، بهتر است
مرور كوتاهي بر بخشهاي مختلف آن داشته باشيم .
واژه كليدي public يك توصيفگر دسترسي (access specifier) است كه به برنامه
نويس امكان داده تا قابليت و سطح مشاهده اعضائ كلاس را كنترل نمايد . وقتي كه
عبارت public قبل از يك عضو كلاس قرار مي گيرد ، آنگاه آن عضو را مي توان با
كدهاي خارج از كلاس كه اعلان شده ، مورد دسترسي قرار داد . ( مخالف اين عبارت
عبارت .private است كه از دسترسي به يك عضو توسط كدهاي تعريف شده در خارج كلاس
جلوگيري مي نمايد . ) در اين حالت ()main بايد بعنوان public اعلام شود ، زيرا
بايد توسط كدهاي خارج از كلاس هنگاميكه برنامه آغاز مي شود ، فراخواني شود .
واژه كليدي Static به ()main امكان داده تا بدون معرفي شدن توسط يك كلاس نمونه
فراخواني شود . اين امر ضروري است چون ()main قبل از اينكه هر يك از اشيائ
ساخته شوند توسط مفسر جاوا فراخواني خواهد شد . واژه كليدي Void بسادگي به
كامپايلر مي گويد كه ()main مقداري را بازگردان نمي كند . همانطوريكه خواهيد
ديد ، ممكن است روشها (methods) نيز مقادير را بازگردان كنند . اگر اين مطالب
تا حدي گيج كننده است ، نگران نباشيد . كليه اين مطالب با جزئيات بيشتري در
قسمتهاي بعد بررسي خواهد شد .
همانطوريكه بيان شده ()main روشي است كه هنگام شروع يك برنامه كاربردي جاوا
فراخواني مي شود . بياد آوريد كه جاوا بسيار حساس نسبت به مورد است . بنابراين
براي جاوا Mainو mainو دو مفهوم متفاوت دارند . نكته مهم اين است كه كامپايلر
جاوا فقط كلاسهايي را كه شامل روش ()main نباشند ، كامپايل خواهد نمود . اما
مفسر جاوا راهي براي اجراي اين كلاسها ندارد . بنابراين اگر بجاي main عبارت Main
را تايپ كرده باشيد ، كامپايلر همچنان برنامه شما را كامپايل خواهد كرد .
اما مفسر جاوا يك گزارش خطا مي دهد زيرا توانايي يافتن روش ()main را ندارد .
اطلاعاتي كه لازم است به يك روش ارسال كنيد ، توسط متغيرهاي مشخص شده بين
مجموعه پرانتزهايي كه بعد از نام روش قرار مي گيرند ، دريافت خواهد شد . اين
متغيرها را پارامترها (parameters) مي نامند . اگر براي يك روش داده شده نياز
به پارامتري نباشد ، از پرانتزهاي خالي استفاده مي كنيد . در حال حاضر ()main
فقط يك پارامتر دارد ، كه البته بسيار پيچيده هم هست . String args [] يك
پارامتر با نام args را اعلان ميكند كه يك آرايه از نمونه هاي string كلاس ميباشد.
( آرايه مجموعه اي از اشيائ مشابه هم هستند . ) اشيائ از نوع string ، رشته هاي
كاراكترها را ذخيره مي كنند . در اين حالت ، args هر نوع آرگومان خط فرمان
حاضر در هنگام اجراي برنامه را دريافت مي كند . اين برنامه از اين اطلاعات
استفاده نمي كند ، اما برنامه هاي ديگر چنين استفاده اي را انجام مي دهند .
آخرين كاراكتر روي خط ، علامت { است . اين علامت نشان دهنده شروع بدنه ()main
است . تمامي كدهايي كه يك روش را تشكيل مي دهند بين ابرو باز و ابرو بسته همان
روش قرار مي گيرند .
يك نكته ديگر : ()main نقطه شروع بكار مفسر است . يك برنامه پيچيده شامل
دهها كلاس است كه فقط يكي از آنها لازم است يك روش ()main داشته باشد تا كارها
را شروع نمايد . هنگاميكه ريز برنامه ها (applets) برنامه هاي جاوا كه در
مرورگرهاي وب تعبيه مي شوند را ايجاد مي كنيد ، بهيچوجه از ()main استفاده
نخواهيد كرد، زيرا مرورگرهاي وب از وسائل متفاوتي براي شروع اجراي ريزبرنامه ها
استفاده مي كنند .
خط بعدي كد بقرار زير ميباشد. دقت كنيد كه اين خط داخل ()main قرار ميگيرد.

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


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

[Nesta]

عملگرها

جاوا يك محيط عملگر غني را فراهم كرده است . اكثر عملگرهاي آن را مي توان
در چهار گروه طبقه بندي نمود : حسابي arithmetic رفتار بيتي bitwise رابطه اي ralational
و منطقي logical جاوا همچنين برخي عملگرهاي اضافي براي اداره
حالتهاي خاص و مشخص تعريف كرده است .
نكته : اگر با C++/C آشنايي داريد ، حتما" خوشحال مي شويد كه بدانيد كاركرد
عملگرها در جاوا دقيقا"مشابه با C++/C است . اما همچنان تفاوتهاي ظريفي
وجود دارد .

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

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

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

+ // Demonstrate the basic arithmetic operators.
+ class BasicMath {
+ public static void main(String args[] ){
+ // arithmetic using integers
+ System.out.println("Integer Arithmetic");
+ int a = 1 + 1;
+ int a = a * 3;
+ int a = b / 4;
+ int a = c - a;
+ int a =- d;
+ System.out.println("a = " + a);
+ System.out.println("a = " + b);
+ System.out.println("a = " + c);
+ System.out.println("a = " + d);
+ System.out.println("a = " + e);
+
+ // arithmetic using doubles
+ System.out.println("\nFloating Point Arithmetic");
+ double da = 1 + 1;
+ double db = da * 3;
+ double dc = db / 4;
+ double dd = dc - a;
+ double de =- dd;
+ System.out.println("da = " + da);
+ System.out.println("db = " + db);
+ System.out.println("dc = " + dc);
+ System.out.println("dd = " + dd);
+ System.out.println("de = " + de);
+ }
+ }


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

integer Arithmetic
a=2
b=6
c=1
d=-1
e=1
floating point arithmetic
da=2
db=6
dc=1.5
dd=-0.5
de=0.5



عملگر تعيين باقيمانده The Modulus operator
عملگر تعيين باقيمانده يعني % ، باقيمانده يك عمليات تقسيم را برمي گرداند.
اين عملگر براي انواع عدد اعشاري و انواع عدد صحيح قابل استفاده است . ( اما
در C++/C اين عملگر فقط در مورد انواع عدد صحيح كاربرد دارد . ) برنامه بعدي
نشان دهنده عملگر % مي باشد :

+ // Demonstrate the % operator.
+ class Modulus {
+ public static void main(String args[] ){
+ int x = 42;
+ double y = 42.3;
+
+ System.out.println("x mod 10 = " + x % 10);
+ System.out.println("y mod 10 = " + y % 10);
+ }
+ }


هنگاميكه اين برنامه را اجرا مي كنيد ، خروجي زير حاصل مي شود :

x mod 10=2
y mod 10=2.3



عملگرهاي انتساب حسابي Arithmetic Assignment operators
جاوا عملگرهاي ويژه اي را تدارك ديده كه با استفاده از آنها مي توان يك
عمليات حسابي را با يك انتساب تركيب نمود . احتمالا" مي دانيد كه دستوراتي نظير
مورد زير در برنامه نويسي كاملا" رايج هستند :

+ a = a + 4;


در جاوا ، مي توانيد اين دستور را بصورت ديگري دوباره نويسي نماييد :

+ a += 4;


اين روايت جديد از عملگر انتساب += استفاده مي كند هر دو دستورات يك عمل
واحد را انجام مي دهند : آنها مقدار aرا 4ا واحد افزايش مي دهند .
اكنون مثال ديگري را مشاهده نماييد :

+ a = a % 2;


كه مي توان آن را بصورت زير نوشت :

+ a %= 2;


در اين حالت %= باقيمانده a/2 را گرفته و حاصل را مجددا"در aر قرار مي دهد.
عملگرهاي انتسابي براي كليه عملگرهاي حسابي و دودوئي ( باينري ) وجود دارند .
بنابراين هر دستور با شكل :

Var = var op expression;


عبارت عملگر متغير متغير
را مي توان بصورت زير دوباره نويسي نمود :

var op = expression;


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

+ // Demonstrate several assignment operators.
+ class OpEquals {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;
+ int c = 3;
+
+ a += 5;
+ b *= 4;
+ c += a * b;
+ c %= 6;
+ System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ System.out.println("c = " + c);
+ }
+ }


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

a=6
b=8
c=3



افزايش و كاهش Increment and Decrement
علامات ++ و -- عملگرهاي افزايشي و كاهشي جاوا هستند . اين عملگرها را قبلا"
معرفي كرده ايم . در اينجا آنها را با دقت بيشتري بررسي مي كنيم . همانگونه كه
خواهيد ديد ، اين عملگرها خصلتهاي ويژه اي دارند كه بسيار جالب توجه است . بحث
درباره اين عملگرها را از نحوه كار آنها شروع مي كنيم .
عملگر افزايشي ، عملوند خود را يك واحد افزايش مي دهد . عملگر كاهشي نيز
عملوند خود را يك واحد كاهش مي دهد . بعنوان مثال ، دستور زير را

+ x = x + 1;


مي توان با استفاده از عملگر افزايشي بصورت زير دوباره نويسي نمود :

+ x++;


بطور مشابهي ، دستور زير را

+ x = x - 1;


مي توان بصورت زير باز نويسي نمود :

+ x--;


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

+ x = 42;
+ y = ++x;


در اين حالت ، همانطوريكه انتظار داريد y معادل 43 مي شود ، چون افزايش قبل
از اينكه xبه y منتسب شود ، اتفاق مي افتد . بدين ترتيب خط y=++ معادل دو
دستور زير است :

+ x = x + 1;
+ y = x;


اما وقتي كه بصورت زير نوشته مي شوند :

+ x = 42;
+ y = x++;


مقدار x قبل از اينكه عملگر افزايشي اجرا شود ، بدست مي آيد ، بنابراين
مقدار y معادل 42 مي شود . البته در هر دو حالت x معادل 43 قرار مي گيرد . در
در اينجا ، خط y=x++ معادل دو دستور زير است :

+ y = x;
+ x = x + 1;


برنامه بعدي نشان دهنده عملگر افزايشي است .

+ // Demonstrate ++.
+ class IncDec {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;
+ int c;
+ int d;
+
+ c = ++b;
+ d = a++;
+ c++;
+ System.out.println("a = " + a);
+ System.out.println("b = " + b);
+ System.out.println("c = " + c);
+ System.out.println("d = " + d);
+ }
+ }


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

a=2
b=3
c=4
d=1



عملگرهاي رفتار بيتي The Bitwise operators
جاوا چندين عملگر رفتار بيتي تعريف نموده كه قابل اعمال روي انواع عدد صحيح
شامل long، int،، short،، char،و byteو مي باشند . اين عملگرها روي بيت هاي
تكي عملوندهاي خود عمل مي كنند . اين عملگرها را در جدول زير خلاصه نموده ايم :
نتيجه آن عملگر
Bitwise unary Not
Not يكاني رفتار بيتي ~ Bitwise AND
AND رفتار بيتي & Bitwise OR
OR رفتار بيتي | Bitwise exclusive OR
OR خارج رفتار بيتي ^ shift right
>> حركت براست shift right zero fill
>>> حركت براست پر شده با صفر shift left
<< حركت به چپ Bitwise AND assignment
انتساب AND رفتار بيتي &= Bitwise OR assignment
انتساب OR رفتار بيتي |= Bitwise exclusive OR assignment
انتساب OR خارج رفتار بيتي ^= shift right assignment
انتساب حركت راست = >>shift right zero fill assignment
انتساب حركت براست پر شده با صفر = >>>shift left assignment
انتساب حركت به چپ = <<
از آنجاييكه عملگرهاي رفتار بيتي با بيت هاي داخل يك عدد صحيح سر و كار
دارند ، بسيار مهم است بدانيم كه اين سر و كار داشتن چه تاثيري ممكن است روي
يك مقدار داشته باشد . بخصوص بسيار سودمند است بدانيم كه جاوا چگونه مقادير
عدد صحيح را ذخيره نموده و چگونه اعداد منفي را معرفي مي كند . بنابراين ، قبل
از ادامه بحث ، بهتر است اين دو موضوع را باختصار بررسي نماييم .
كليه انواع صحيح بوسيله ارقام دودوئي ( باينري ) داراي پهناي بيتي گوناگون
معرفي ميشوند. بعنوان مثال ، مقدار byte عدد 42 در سيستم باينري معادل 00101010
است ، كه هر يك از اين نشانه ها يك توان دو را نشان مي دهند كه با 2 به توان 0
در بيت سمت راست شروع شده است . يا موقعيت بعدي بيت بطرف چپ 2'يا 2ا است و به
طرف چپ بيت بعدي 2 به توان 2يا 4ا است ، بعدي 8 ، 16 ، 32 و همينطور الي آخر
هستند . بنابراين عدد 42 بيت 1 را در موقعيتهاي اول ، سوم و پنجم ( از سمت
راست درنظربگيريد ) دارد. بدين ترتيب 42 معادل جمع 5 بتوان 3+2 بتوان 1+2 بتوان 2
يعني 2+8+32 مي باشد .
كليه انواع عدد صحيح ( باستثنائ char ) اعداد صحيح علامت دار هستند . يعني
كه اين انواع مقادير منفي را همچون مقادير مثبت مي توانند معرفي كنند . جاوا
از يك روش رمزبندي موسوم به مكمل دو (two's complement) استفاده مي كند كه در
آن ارقام منفي با تبديل ( تغيير 1به 0 و بالعكس ) كليه بيت هاي يك مقدار و
سپس اضافه نمودن 1 به آن معرفي مي شوند . بعنوان مثال براي معرفي 42 ، ابتدا
كليه بيت هاي عدد 42 (00101010) را تبديل مي نماييم كه 11010101 حاصل مي شود
آنگاه 1 را به آن اضافه مي كنيم . كه حاصل نهايي يعني 11010110 معرف عدد 42
خواهد بود . براي رمز گشايي يك عدد منفي ، كافي است ابتدا كليه بيت هاي آن را
تبديل نموده ، آنگاه 1 را به آن اضافه نماييم . 42- يعني 11010110 پس از تبديل
برابر 00101001 يا 41 شده و پس از اضافه نمودن 1 به آن برابر 42 خواهد شد .
دليل اينكه جاوا( واكثر زبانهاي برنامه نويسي )از روش مكمل دو(two's complement)
استفاده مي كنند ، مسئله تقاطع صفرها (Zero crossing) است . فرض كنيد يك مقدار byte
براي صفر با 00000000 معرفي شده باشد. در روش مكمل يك (one's complement)
تبديل ساده كليه بيت ها منجر به 11111111 شده كه صفر منفي را توليد مي كند .
اما مشكل اين است كه صفر منفي در رياضيات عدد صحيح غير معتبر است . اين مشكل
بااستفاده از روش مكمل دو (two's complement) براي معرفي مقادير منفي حل خواهد
شد . هنگام استفاده از روش مكمل دو ، 1 به مكمل اضافه شده و عدد 100000000
توليد مي شود . اين روش بيت 1 را در منتهي اليه سمت چپ مقدار byte قرار داده
تا رفتار مورد نظر انجام گيرد، جايي كه 0با 0ا يكسان بوده و 11111111 رمزبندي
شده 1 است . اگر چه در اين مثال از يك مقدار byte استفاده كرديم ، اما همين
اصول براي كليه انواع عدد صحيح جاوا صدق مي كنند .
از آنجاييكه جاوا از روش مكمل دو براي ذخيره سازي ارقام منفي استفاده ميكند
و چون كليه اعداد صحيح در جاوا مقادير علامت دار هستند بكار بردن عملگرهاي
رفتار بيتي براحتي نتايج غير منتظره اي توليد مي كند . بعنوان مثال برگرداندن
بيت بالاتر از حد مجاز (high-order) سبب مي شود تا مقدار حاصله بعنوان يك رقم
منفي تفسير شود ، خواه چنين قصدي داشته باشيد يا نداشته باشيد . براي جلوگيري
از موارد ناخواسته ، فقط بياد آوريد كه بيت بالاتر از حد مجاز (high-order)
علامت يك عدد صحيح را تعيين مي كند، صرفنظر از اينكه بيت فوق چگونه مقدار گرفته
باشد .

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

A B A|B A&B A^B ~A
0 0 0 0 0 1
1 0 1 0 1 0
0 1 1 0 1 1
1 1 1 1 0 0

NOT

رفتار بيتي
عملگر NOT يكاني يعني ~ كه آن را مكمل رفتار بيتي (bitwise complement) هم
مي نامند ، كليه بيت هاي عملوند خود را تبديل مي كند . بعنوان مثال ، عدد 42
كه مطابق الگوي بيتي زير است : 00101010

پس از اعمال عملگر NOT بصورت زير تبديل مي شود : 11010101

AND
رفتار بيتي
عملگر AND يعني & اگر هر دو عملوند 1 باشند ، يك بيت 1 توليد مي كند . در
كليه شرايط ديگر يك صفر توليد مي شود . مثال زير را نگاه كنيد : 00101010 42
& 00001111 15

00001010 10

OR
رفتار بيتي
عملگر OR يعني | بيت ها را بگونه اي تركيب مي كند كه اگر هر يك از بيت هاي
عملوندها 1 باشد ، آنگاه بيت حاصله نيز 1 خواهد بود . به مثال زير نگاه كنيد : 00102010 42
| 00001111 15

00101111 47

XOR
رفتار بيتي
عملگر XOR يعني ^ بيت ها را بگونه اي تركيب مي كند كه اگر دقيقا" يك عملوند 1
باشد ، حاصل برابر 1 خواهد شد . در غير اينصورت ، حاصل 0 مي شود .
مثال بعدي چگونگي كار اين عملگر را نشان مي دهد . اين مثال همچنين يكي از
خصلتهاي سودمند عملگر XOR را نمايش مي دهد . دقت كنيد كه هر جا عملوند دوم يك
بيت 1 داشته باشد ، چگونه الگوي بيتي عدد 42 تبديل مي شود . هر جا كه عملوند
دوم بيت 0 داشته باشد ، عملوند اول بدون تغيير مي ماند . هنگام انجام برخي از
انواع عملكردهاي بيتي ، اين خصلت بسيار سودمند است . 00101010 42
^ 00001111 15

00100101 37


استفاده از عملگرهاي منطقي رفتار بيتي
برنامه بعدي نشان دهنده عملگرهاي منطقي رفتار بيتي است :

+ // Demonstrate the bitwise logical operators.
+ class BitLogic {
+ public static void main(String args[] ){
+ String binary[] = {
+ "0000"/ "0001"/ "0010"/ "0011"/ "0100"/ "0101"/ "0110"/ "0111"/
+ "1000"/ "1001"/ "1010"/ "1011"/ "1100"/ "1101"/ "1110"/ "1111"
+ };
+ int a = 3; // 0 + 2 + 1 or 0011 in binary
+ int b = 6; // 4 + 2 + 0 or 0110 in binary
+ int c = a | b;
+ int d = a & b;
+ int e = a ^ b;
+ int f =( ~a & b )|( a & ~b);
+ int g = ~a & 0x0f;
+
+ System.out.println(" a = " + binary[a]);
+ System.out.println(" b = " + binary[b]);
+ System.out.println(" a|b = " + binary[c]);
+ System.out.println(" a&b = " + binary[d]);
+ System.out.println(" a^b = " + binary[e]);
+ System.out.println("~a&b|a&~b = " + binary[f]);
+ System.out.println(" ~a = " + binary[g]);
+ }
+ }


در اين مثال ، aو bو الگوهاي بيتي دارند كه كليه چهار احتمال براي ارقام
دو تايي باينري را معرفي مي كنند . 0-0، 0-1،، 1-0،و 1-1و . مي توانيد مشاهده
كنيد چگونه |و &و روي هر يك از بيت ها با توجه به نتايج در cو dو عمل مي كنند.
مقادير نسبت داده شده به eو fو مشابه بوده و نشان دهنده چگونگي كار عملگر ^
مي باشند . آرايه رشته اي با نام binary معرفي ارقام 0 تا 15 را بصورت باينري و
قابل خواندن براي انسان نگهداري مي كند . در اين مثال ، آرايه فوق طوري نمايه
سازي شده تا معرفي باينري هر يك از نتايج را نشان دهد . آرايه طوري ساخته شده
كه معرفي رشته اي صحيح يك مقدار باينري n را در binary[n] ذخيره مي كند . مقدار ~a
بوسيله عملگر ANDبا oxofا( 00001111 باينري ) عمل شده تا مقدار آن را به
كمتر از 16 كاهش دهد تا بتوان با استفاده از آرايه binary از آن چاپ گرفت .
اكنون خروجي اين برنامه بصورت زير مي باشد :

a=1011
b=0110
a^Eb=0111
a&b=0010
a&b=0101
~a&b^Ea&~b=0101
~a=1100



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

Value << num


تعداد دفعات مقدار
در ايجا num مشخص كننده تعداد مكانهايي است كه بيت هاي موجود در value بايد
كليه بيت هاي موجود در يك مقدار مشخص را <<به چپ انتقال يابند . بدين ترتيب
بتعداد مكانهايي كه در num مشخص شده بطرف چپ حركت مي دهد . براي هر بار حركت
به چپ ، بيت high-order ( بيش از حد مجاز ) منتقل شده و از دست خواهد رفت و
يك صفر در طرف راست مقدار ، جايگزين مي شود . بدين ترتيب هنگاميكه يك حركت به
چپ روي يك عملوند int عمل مي كند ، بيت هاي گذشته از مكان 31 از دست خواهند
رفت . اگر عملوند يك long باشد، بيت ها پس از گذشتن از مكان 63 از دست ميروند.
هنگاميكه مقادير byteو shortو را انتقال مي دهيد ، ارتقائ خودكار انواع در
جاوا نتايج غير منتظره اي ايجاد مي كند . حتما" مي دانيد كه هنگام ارزشيابي
عبارات ، مقادير byteو shortوبه int ارتقائ مي يابند. بعلاوه جواب چنين عبارتي
از نوع int خواهد بود . بنابراين حاصل يك حركت به چپ روي مقادير byteو shortو
يك int خواهد بود و بيت هاي انتقال يافته به چپ تا زمانيكه از مكان بيت 31
نگذرند ، از دست نمي روند . علاوه براين ، يك مقدار منفي byteو shortو هنگاميكه
به int ارتقائ مي يابد ، بسط علامت پيدا مي كند . بنابراين بيت هاي بيش از حد
مجاز با بيت 1 پر مي شوند . بخاطر اين دلايل ، انجام يك حركت به چپ روي byte و short
مستلزم آن است كه از بايت هاي بيش از حد مجاز در جواب int دست بكشيد .
بعنوان مثال ، اگر يك مقدار byte را حركت به چپ بدهيد ، آن مقدار ابتدا به نوع int
تبديل شده و سپس انتقال خواهد يافت . بايد سه بايت بالايي حاصل را از دست
بدهيد . اگر بخواهيد حاصل يك مقدار byte انتقال يافته را بدست آوريد . بايد سه
بايت بالايي حاصل را از دست بدهيد . آسان ترين روش براي انجام اينكار استفاده
از تبديل cast و تبديل جواب به نوع byte است . مثال بعدي همين مفهوم را براي
شما آشكار مي سازد :

+ // Left shifting a byte value.
+ class ByteShift {
+ public static void main(String args[] ){
+ byte a = 64/ b;
+ int i;
+
+ i = a << 2;
+ b =( byte( )a << 2);
+
+ System.out.println("Original value of a :" + a);
+ System.out.println("i and b :" + i + " " + b);
+ }
+ }


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

original value of a:64
i and b :256 0


چون براي اهداف ارزشيابي ، a به نوع int ارتقائ يافته ، دوبار حركت به چپ
مقدار 64 (0000 َ0100) منجر به i مي گردد كه شامل مقدار 256 (0000 َ1 0000)
مي باشد . اما مقدار b دربرگيرنده صفر است زيرا پس از انتقال ، بايت كمتر از
حد مجاز (loworder) اكنون شامل صفر است . تنها بيت دربرگيرنده 1 به بيرون
انتقال يافته است .
از آنجاييكه هر بار حركت به چپ تاثير دو برابر سازي مقدار اصلي را دارد
برنامه نويسان اغلب از اين خاصيت بجاي دو برابر كردن استفاده مي كنند . اما
بايد مراقب باشيد . اگر يك بيت 1 را به مكان بيت بيش از حد مجاز (31 يا 63)
منتقل كنيد ، مقدار فوق منفي خواهد شد . برنامه بعدي همين نكته را نشان ميدهد.

+ // Left shifting as a quick way to multiply by 2.
+ class MultByTwo {
+ public static void main(String args[] ){
+ int i;
+ int num = 0xFFFFFFE;
+
+ for(i=0; i<4; i++ ){
+ num = num << 1;
+ System.out.println(num);
+ }
+ }
+ }


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


1073741816
2147483632
- 32


مقدار آغازين را با دقت انتخاب كرده ايم بطوريكه بيت بعد از چهار مكان حركت
بطرف چپ ، مقدار 32- را توليد نمايد . همانطوريكه مي بينيد ، هنگاميكه بيت 1
به بيت 31 منتقل مي شود ، رقم بعنوان منفي تفسير خواهد شد .

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

value >> num


تعداد دفعات مقدار
در اينجا ، num مشخص كننده تعداد مكانهايي است كه بيت هاي value بايد بطرف
كليه بيت هاي يك مقدار مشخص شده را به تعداد >>راست انتقال يابند . يعني
مكانهاي بيتي مشخص شده توسط num بطرف راست انتقال مي دهد .
كد قطعه اي زير مقدار 32 را دو مكان بطرف راست منتقل مي كند و آنگاه جواب
آن در a معادل 8 قرار مي گيرد :

+ int a = 32;
+ a = a >> 2; // a now contains 8


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

+ int a = 35;
+ a = a >> 2; // a still contains 8


همين عمليات را در شكل باينري نگاه مي كنيم تا اتفاقي كه مي افتد ، روشن تر
شود : 00100011 35
>> 2
00001000 8

هر بار كه يك مقدار را به طرف راست منتقل مي كنيد ، آن مقدار تقسيم بر دو
مي شود و باقيمانده آن از دست خواهد رفت . مي توانيد از مزاياي اين روش در
تقسيم بر دو اعداد صحيح با عملكرد سطح بالا استفاده نماييد . البته ، بايد مطمئن
شويد كه بيت هاي انتهايي سمت راست را به بيرون منتقل نكنيد .
هنگاميكه حركت بطرف راست را انجام مي دهيد ، بيت هاي بالايي ( از سمت چپ )
در معرض حركت بطرف راست قرار گرفته ، با محتوي قبلي بيت بالايي پر مي شوند .
اين حالت را بسط علامت (sign extension) ناميده و براي محفوظ نگهداشتن علامت
ارقام منفي هنگام حركت بطرف راست استفاده مي شوند. بعنوان مثال 1>>8- معادل 4-
است كه به شكل باينري زير مي باشد : 11111000- 8
>> 1
11111100- 4

جالب است بدانيد كه اگر 1- را بطرف راست حركت دهيد، حاصل آن همواره 1- باقي
مي ماند ، چون بسط علامت ، مراقب آوردن يك بيت ديگر در بيت هاي بيش از حد مجاز
خواهد بود .
گاهي هنگام حركت بطرف راست مقادير ، مايل نيستيم تا بسط علامت اجرا شود .
بعنوان مثال ، برنامه بعدي يك مقدار نوع byte را به معرفي رشته اي در مبناي 16
تبديل مي كند . دقت كنيد كه مقدار منتقل شده با استفاده از عملگر ANDيا oxofا
پوشانده شده تا هر گونه بيت هاي بسط يافته علامت را بدور اندازد بطوريكه مقدار
فوق را بتوان بعنوان يك نمايه به آرايه اي از كاراكترهاي در مبناي 16 استفاده
نمود .

+ // Masking sign extension.
+ class HexByte {
+ static public void main(String args[] ){
+ char hex[] = {
+ '0'/ '1'/ '2'/ '3'/ '4'/ '5'/ '6'/ '7'/
+ '8'/ '9'/ 'a'/ 'b'/ 'c'/ 'd'/ 'e'/ 'f'
+ };
+ byte b =( byte )oxf1
+
+ System.out.println("b = ox" + hex[(b >> 4 )& oxof] + hex[b & oxof]);
+ }
+ }


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

b=oxf1



حركت به راست فاقد علامت
بطور خودكار >>اكنون مي دانيد كه هر بار يك انتقال اتفاق مي افتد ، عملگر
جاي خالي بيت بيش از حد مجاز را با محتوي قبلي اش پر مي كند . اين عمل سبب حفظ
علامت آن مقدار مي گردد . اما گاهي تمايلي براي اينكار نداريم . بعنوان مثال
مي خواهيد چيزي را منتقل كنيد كه معرف يك مقدار عددي نيست . بالطبع نمي خواهيد
عمل بسط علامت انجام گيرد . اين حالت هنگام كار با مقادير براساس پيكسل (pixel)
و گرافيك اغلب وجود دارد . در چنين شرايطي لازم است تا مقدار صفر در بيت بيش از
حد مجاز قرار گيرد ، صرفنظر از اينكه مقدار قبلي در آن بيت چه بوده است . اين
حالت را انتقال فاقد علامت (usigned shift) مي گويند. براي اين منظور، از عملگر
استفاده كنيد كه صفرها را در بيت بيش >>>حركت به راست فاقد علامت در جاوا يعني
از حد مجاز منتقل مي كند .
مي باشد . در اينجا >>>كد قطعه اي زير نشان دهنده عملگر a معادل 1- است كه
كليه 32 بيت را در باينري روي 1 تنظيم مي كند . اين مقدار سپس 24 بيت بطرف
راست انتقال مي يابد، و 24 بيت بالايي را با صفرها پر مي كند و بسط علامت معمولي
را ناديده مي گيرد . بدين ترتيب a معادل 255 مي باشد . + int a =- 1;
+ a = a >>> 24;

اينجا همان عمليات را در شكل باينري مشاهده مي كنيد تا بهتر بفهميد چه
اتفاقي افتاده است : 1
در باينري بعنوان يك int 11111111 11111111 11111111 11111111 >>>24
255
در باينري بعنوان يك int َ11111111 00000000 00000000 00000000
اغلب اوقات آنچنان سودمند كه بنظر مي رسد ، نبوده چون فقط براي >>>عملگر
مقادير 32 بيتي و 64 بيتي معني دارد . بياد آوريد كه مقادير كوچكتر در عبارات
بطور خودكار به int ارتقائ مي يابند . بدين ترتيب بسط علامت اتفاق افتاده و
حركت بجاي مقادير 8 بيتي و 16 بيتي روي مقادير 32 بيتي انجام مي شود . يعني
بايد انتظار يك حركت به راست فاقد علامت روي يك مقدار byte داشته باشيم كه در
بيت 7 ، صفر را قرار مي دهد . اما واقعا" اينطور نيست ، چون در واقع مقدار 32
بيتي است كه منتقل مي شود . برنامه بعدي اين تاثيري را نشان مي دهد .

+ // Unsigned shifting a byte value.
+ class ByteUShift {
+ static public void main(String args[] ){
+ char hex[] = {
+ '0'/ '1'/ '2'/ '3'/ '4'/ '5'/ '6'/ '7'/
+ '8'/ '9'/ 'a'/ 'b'/ 'c'/ 'd'/ 'e'/ 'f'
+ };
+ byte b =( byte )oxf1
+ byte c =( byte( )b >> 4);
+ byte d =( byte( )b >>> 4);
+ byte e =( byte(( )b & oxff )>> 4);
+
+ System.out.println(" b = ox"
+ + hex[(b >> 4 )& oxof] + hex[b & oxof]);
+ System.out.println(" b >> 4 = ox"
+ + hex[(c >> 4 )& oxof] + hex[c & oxof]);
+ System.out.println(" b >>> 4 = ox"
+ + hex[(d >> 4 )& oxof] + hex[d & oxof]);
+ System.out.println("(b & oxof )>> 4 = ox"
+ + hex[(e >> 4 )& oxof] + hex[e & oxof]);
+ }
+ }


چگونه هنگام كار با بايت ها عملي >>>خروجي اين برنامه نشان ميدهد كه عملگر
انجام نمي دهد . متغير b بعنوان يك مقدار byte منفي قراردادي در اين نمايش
تنظيم شده است . سپس مقدار byteدر bر كه چهار مكان بطرف راست انتقال بافته به C
منتسب مي شود كه بخاطر بسط علامت مورد انتظار oxff است . سپس مقدار byteدر bر
كه چهار مكان بطرف راست و فاقد علامت منتقل شده به d منتسب مي شود كه انتظار
داريد oxof باشد ، اما در حقيقت oxff است چون بسط علامت هنگاميكه b به نوع int
قبل از انتقال ارتقائ يافته اتفاق افتاده است . آخرين عبارت ، e را در مقدار byte
متغير b كه با استفاده از عملگر ANDبا 8ا بيت پوشانده شده تنظيم نموده و
سپس چهار مكان بطرف راست منتقل مي كند كه مقدار مورد انتظار oxof را توليد
مي كند . دقت كنيد كه عملگر حركت به راست فاقد علامت براي d استفاده نشد ، چون
حالت بيت علامت بعد از AND شناخته شده است .

b=oxf1
b>>4=oxff
b>>>4=oxff
( b&oxff)>>4=oxof



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

+ a = a >> 4;
+ a >>= 4;


بطور مشابه ، دو دستور زير كه a را به عبارت روش بيتي aoRb منتسب مي كنند
معادل يكديگرند :

+ a = a | b;
+ a |= b;


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

+ class OpBitEquals {
+ public static void main(String args[] ){
+ int a = 1;
+ int b = 2;

[Nesta]

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

اين عملگرها تعيين كننده رابطه ها بين يك عملوند با عملوند ديگر هستند. بطور
مشخص ، آنها تساوي يا ترتيب بندي (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و مقادير غيرعادي هستند كه ربطي با صفر يا غيرصفر ندارند. بنابراين
براي آزمون صفر و غير صفر، بايد بطور صريح يك يا چند عملگر رابطه اي را استخدام

[Nesta]

عملگرهاي منطقي بولي Boolean

عملگرهاي منطقي بولي كه در زير نشان داده ايم فقط روي عملوندهاي بولي عمل
مي كنند . كليه عملگرهاي منطقي باينري دو مقدار 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;


در اينجا استفاده از يك علامت & تكي اطمينان مي دهد كه عمليات افزايشي به e