چکیده:
 جاوا از ابتدا به صورت شی گراست در صورتی که سی پلاس پلاس اینطور نیست.
جاوا اشاره گر ندارد ولی سی اشاره گر دارد.
کد سی 10 بار سریعتر از کد جاوا اجرا می شود.
جاوا از کاراکتر های یونی کد استفاده میکند اما سی نه.
نام متغیر ها در دو زبان نسبت به حروف حساس است.
نوع بولین در جاوا نمی تواند با عدد مقایسه شود در صورتی که در سی پلاس پلاس مجاز است.
گرامر جاوا خیلی بزرگتر از سی پلاس پلاس است.
جاوا باز تابش (از اصول شی گرایی) را رعایت نکرده است (باز تابش:استفاده مجدد از کدها و نوشتن برنامه های الحاقی)
 
 
مقدمه:
زبان C پس از تولد ، شوك بزرگي به دنياي كامپيوتر وارد كرد . اين زبان بطور
اساسي شيوه هاي تفكر و دستيابي به برنامه نويسي كامپيوتر را دگرگون ساخت . تولد C
ناشي از نياز به يك زبان ساخت يافته ، موثر و سطح بالا بعنوان جايگزيني براي
كدهاي اسمبلي و پياده سازي برنامه نويسي سيستم بود . هنگاميكه يك زبان برنامه
نويسي جديد متولد مي شود ، مقايسه ها شروع خواهد شد . مقايسه ها براساسمعيارهاي
زير انجام مي گيرند:
راحتي كاربري در مقايسه با قدرتمندي زبانبرنامه نويسي
ايمني در مقايسه با سطح كارآيي
استحكام در مقايسه باتوسعه پذيري
قبل از ظهور زبان C برنامه نويسان با زبانهايي كار مي كردند كهقدرتبهينه سازي يك مجموعه خاص از خصايص را داشتند . بعنوان مثال هنگاميكه از فرترن براي نوشتن برنامه هاي موثر در كاربردهاي علمي استفاده مي كنيم ، برنامههايحاصله براي كدهاي سيستم چندان مناسب نيست. زبان بيسيك با اينكه براحتيآموختهمي شود ، اما قدرت زيادي نداشته و عدم ساخت يافتگي آن در برنامه هايبزرگ مشكلآفرين خواهد شد . از زبان اسمبلي براي توليد برنامه هاي كاملا" موثر استفاده مي شود ، اما آموزش و كار با اين زبان بسيار مشكل است . بعلاوه اشكالزدايي كدهاي اسمبلي بسيار طاقت فرساست . مشكل اصلي ديگر اين بود كه زبانهاياوليه برنامه نويسي نظير بيسيك ، كوبولو فرترن براساس اصول ساخت يافته طراحي نشده بودند . اين زبانها از Goto عنوان ابزارهاي اوليه كنترل برنامه استفاده مي كردند . در نتيجه ، برنامه هاي نوشته
شده با اين زبانها توليد باصطلاح " كدهاي اسپاگتي "(spaghetti code() مي كردندمنظور مجموعه اي در هم تنيده ازپرشها و شاخه هاي شرطي است كه درك يك برنامه طولاني را ناممكن مي سازد . اگر چهزبانهايي نظير پاسكال ، ساخت يافته هستنداما فاقد كارايي لازم بوده و جنبه هاي ضروري براي كاربرد آنها در طيف وسيعي ازبرنامه ها وجود ندارد . ( بخصوص ويرايش پاسكال) استاندارد فاقد ابزارهاي كافيبراي استفاده در سطح كدهاي سيستم بود ) تا قبل از ابداع زبان C )، زبان ديگري قدرت نداشت تا خصلتهاي متضادي كه درزبانهاي قبلي مشاهده مي شد، را يكجا گردآوري كند . نياز به وجود يك چنين زبانيشديدا" احساس ميشد. در اوايل دهه 1970 ميلادي ، انقلاب رايانه اي در حال شكلگيريبود و تقاضا براي انواع نرم افزارها فشار زيادي روي برنامه نويسان وتوانايي هايايشان اعمال ميكرد. درمراكز آموزشي تلاش مضاعفي براي ايجاد يك زبان برنامه نويسي برتر انجام مي گرفت . اما شايد از همه مهمتر توليد و عرضه انبوه سخت افزار
كامپيوتري بود كه بعنوان يك نيروي ثانويه روي زبانهاي برنامه نويسي عمل ميكرد. ديگر رايانه ها و اسرار دروني آنها پشت درهاي بسته نگهداري نمي شد . براي اولين بار بود كه برنامه نويسان واقعا" دسترسي نامحدودي به اسرار ماشينهاي خود پيدانمودند . اين امر زمينه تجربيات آزادانه را بوجود آورد . همچنين برنامه نويسانتوانستند ابزارهاي مورد نيازشان را ايجاد نمايند .
براي بررسي تاريخچه بايد به سال 1967 بازگرديم که مارتين ريچاردز زبان BCPL را براي نوشتن نرم افزارهاي سيستم عامل و کامپايلر در دانشگاه کمبريج ابداع کرد. سپس در سال 1970 کن تامپسون زبان B را بر مبناي ويژگيهاي زبان BCPL نوشت و از آن براي ايجاد اولين نسخه هاي سيستم عامل Unix در آزمايشگاههاي بل استفاده کرد. زبان C در سال 1972 توسط دنيس ريچي از روي زبان B و BCPL در آزمايشگاه بل ساخته شد و ويژگيهاي جديدي همچون نظارت بر نوع داده ها نيز به آن اضافه شد. ريچي از اين زبان براي ايجاد سيستم عامل Unix استفاده کرد اما بعدها اکثر سيستم عاملهاي ديگر نيز با همين زبان نوشته شدند. اين زبان با سرعت بسياري گسترش يافت و چاپ کتاب "The C Programming Language" در سال 1978 توسط کرنيگان و ريچي باعث رشد روزافزون اين زبان در جهان شد.
متاسفانه استفاده گسترده اين زبان در انواع کامپيوترها و سخت افزارهاي مختلف باعث شد که نسخه هاي مختلفي از اين زبان بوجود آيد که با يکديگر ناسازگار بودند. در سال 1983 انستيتوي ملي استاندارد آمريکا (ANSI) کميته اي موسوم به X3J11 را را مامور کرد تا يک تعريف فاقد ابهام و مستقل از ماشين را از اين زبان تدوين نمايد.در سال 1989 اين استاندارد تحت عنوان ANSI C به تصويب رسيد و سپس در سال 1990، سازمان استانداردهاي بين المللي (ISO) نيز اين استاندارد را پذيرفت و مستندات مشترک آنها تحت عنوان ANSI/ISO C منتشر گرديد.
با ظهور زبان C ، زمينهجهشهاي بزرگ در زبانهاي برنامه نويسي مهيا بسياري معتقدند كهايجاد زبان C راهگشاي دوران جديدي در زبانهاي برنامه نويسيبوده است . اين زبانبطور موفقيت آميزي تناقضهاي موجود در زبان هاي برنامه نويسيقبلي را مرتفع نمود . نتيجه فرآيند ايجاد زبان C ، يك زبان قدرتمند ، كارا وساخت يافته بود كهبراحتي قابل آموزش و فراگيري بود . اين زبان يك ويژگي غيرمحسوس اما مهم داشت : زبان C ، زبان برنامه نويسان بود . قبل از ابداع زبان C زبانهاي برنامه نويسييا جنبه هاي آموزشي داشته يا براي كارهاي اداري طراحيميشد . اما زبان C چيزديگري بود . اين زبان توسط برنامه نويسان واقعي و درگيربا كارهاي جدي ، طراحيو پياده سازي شده و توسعه يافت . جنبه هاي مختلف اينزبان توسط افرادي كه باخود زبان سر و كار داشته و برنامه نويسي مي كردند موردبررسي ، آزمايش و تفكر وتفكر مجدد قرار گرفته بود .
اصل اين فرآيند هم زبانيبود كه برنامه نويسان آنرا دوست داشتند. در حقيقت زبان C بسرعت مورد توجهبرنامه نويسان قرار گرفت تاجايي كه برنامه نويسان نسبت به C تعصب خاصي پيدانمودند . اين زبان مقبوليت ومحبوبيت زيادي در بين برنامه نويسان يافت . بطورخلاصه زبان C توسط برنامهنويسان و براي برنامه نويسان طراحي شده است .
نياز به++C طي دهه 1970 واوايل دهه 80 ميلادي زبان C نگين انگشتري برنامه نويسان بود و
هنوز هم در سطحوسيعي مورد استفاده قرار مي گيرد . از آنجاييكه C يك زبان موفقو سودمند بوده ،ممكن است بپرسيد چه نيازي به زبانهاي جديدتر وجود داشته است . پاسخ شما يك كلمهيعني پيچيدگي (Complexity) است . طي تاريخ كوتاه برنامه نويسيپيچيدگي فزايندهبرنامه ها نياز براي شيوه هاي بهتر مديريت پيچيدگي را بوجودآورده است . ++C پاسخي است به اين نياز مديريت پيچيدگي برنامه ها كه زمينه اصليپيدايش++C بودهاست . شيوه هاي برنامه نويسي از زمان اختراع رايانه تاكنون بطور قابل توجهيتغييرنموده اند . بعنوان مثال ، هنگاميكه رايانه ها اختراع شدند ، برنامهنويسي بااستفاده از دستور العملهاي باينري (Binary) ماشين انجام مي گرفت . ماداميكه برنامه ها شامل حدود چند دستور العمل بود ، اين روش كارآيي داشت .
بموازات رشد برنامه ها زبان اسمبلي ابداع شد تا برنامه نويسان بتوانند برنامههايبزرگتر و پيچيده تر را با استفاده از نشانه هايي كه معرف دستورالعملهايماشينبودند ، بنويسند . اما پيشرفت و رشد برنامه ها همچنان ادامه يافت وزبانهاي سطحبالايي معرفي شدند كه ابزارهاي مناسب براي مديريت پيچيدگي روزافزونبرنامه ها رادر اختيار برنامه نويسان قرار مي دادند .
اولين زبان مطرح دراين زمينه فرترن بود . اگر چه فرترن اولين گام در اين مسير بود، اما زباني استكه توسط آن برنامه هاي تميز و سهل الادراك نوشته مي شود.
در دهه 1960 ميلاديبرنامه نويسي ساخت يافته مطرح شد . با استفاده از زبانهايساخت يافته، براياولين بار امكان راحت نوشتن برنامه هاي بسيار پيچيده بوجودآمد . اما حتي باوجود روشهاي برنامه نويسي ساخت يافته ، هنگاميكه يك پروژه بهاندازه معيني ميرسيد ، پيچيدگي آن از توان مديريت برنامه نويس خارج مي شد . دراوائل دهه 1980ميلادي بسياري از پروژه هاي مديريت برنامه نويسي از مرزهايبرنامه نويسي ساختيافته گذشتند . براي حل اين قبيل مشكلات ، يك روش نوينبرنامه نويسي ابداع شد . اين روش را برنامه نويسي شي گرا يا باختصار oop مي نامند .
توصيف مختصراين روش عبارت استاز : oop يك نوع روش شناسي برنامه نويسي است كهامكان سازماندهي برنامه هايپيچيده از طريق بهره گيري از سه روش : وراثت ، كپسولسازي و چند شكلي ، راايجاد مي كند . در تحليل نهايي ، اگر چه C بزرگترين و مهمترين زبان برنامهنويسي جهان استاما محدوديتهايي در مديريت پيچيدگي برنامه ها دارد . هنگاميكهيك برنامه ازمحدوده 25000 تا 100000 خط از كدها تجاوز نمايد، آنچنان پيچيده ميشود كه دركآن بعنوان يك برنامه كلي ناممكن خواهد شد. ++C اين محدوديت را ازبين برده وبه برنامه نويس كمك مي كند تا برنامه هايي از اين بزرگتر را نيز دركو مديريتنمايد.
++C در سال 1979 ميلادي توسط Bjarne stoustrup هنگاميكه درآزمايشگاه بل در Marry Hill ايالت New jersy مشغول كار بود ، ابداع شد . او درابتدا اين زبانجديد را (C with classes) ناميد . اما در سال 1983 ميلادي ناماين زبان جديد به ++ Cتغيير يافت++C. تداوم زبان C بود كه جنبه هاي oop نيز بهآن اضافه مي شد. از آنجايي كه زبان++C براساس زبان C شكل گرفته ، در بر گيرندهكليه جنبه هاخسلتها (attributes) و مزاياي زبان C مي باشد . اين عوامل دلايلقاطعي برايموفقيت حتمي++C عنوان يك زبان برنامه نويسي هستند . ابداع++C درحقيقت تلاشيبراي ايجاد يك زبان كاملا" جديد برنامه نويسي نبود. در حقيقت پروژه++C منجر بهافزايش تواناييهاي زبان موفق C شد . چون++C از ابتداي تولدتاكنون داراي روايتهاي گوناگوني شده است ، در حالحاضر در تلاش استاندارد نمودناين زبان هستند.
با گسترش شبکه و اينترنت، نياز به زباني احساس شد که برنامه هاي آن بتوانند برروي هر ماشين و هر سيستم عامل دلخواهي اجرا گردد. شرکت سان مايکروسيستمز در سال 1995 ميلادي زبان Java را برمبناي C و ++C ايجاد کرد که هم اکنون از آن در سطح وسيعي استفاده مي شود و برنامه هاي نوشته شده به آن برروي هر کامپيوتري که از Java پشتيباني کند(تقريبا تمام سيستمهاي شناخته شده) قابل اجرا مي باشد. شرکت مايکروسافت در رقابت با شرکت سان، در سال 2002 زبان جديدي بنام #C(سي شارپ) را ارائه داد که رقيبي براي Java بشمار مي رود.
 
زمينه هاي پيدايش جاوا:
تاريخچه زبانهاي برنامه نويسي بشرح زير است : زبان B منجر به ظهور زبان C و C
زمينه پيدايش C++ شد و در نهايت زبان جاوامتولد شد . درك زبان جاوا مستلزم :
درك زمينه هاي لازم براي ايجاد جاوا ،نيروهايي كه اين زبان را شكل داده اند
مشخصاتي است كه اين زبان از اسلاف خودبه ارث برده است . نظير ساير زبانهاي
برنامه نويسي موفق ، جاوا نيز عناصر بارثبرده از اسلاف خود را با ايده هاي
ابتكاري كه ناشي از محيط منحصر بفرد اين زبانبوده درهم آميخته است . فصول بعدي
جنبه هاي عملي زبان جاوا شامل دستور زبان (syntax) و كتابخانه ها (libraries)
و كاربردهاي جاوا را توصيف مي كند . فعلا" چگونگي و علت ظهور جاوا و اهميت آن
را بررسي مي كنيم .
اگر چه جاوا تفكيكناپذيري با محيط هاي همزمان اينترنت پيوستگي دارد ، اما
بخاطر بسپاريد كه جاواقبل از هر چيز يك زبان برنامه نويسي است . ابداعات و
پيشرفت ها در زبانهايبرنامه نويسي كامپيوتر بدو دليل بروز مي كنند :
الگوريتم برج هانو
برج هانوي , معمايي است که از سه ميله و N ديسک با اندازه هاي متفاوت . فرض شود که اگر ديسکي روي يک ميله باشد , فقط ديسکي که قطر آن کوچکتر است مي تواند بالاي آن قرار گيرد مسئله چنين است که هر بار فقط يک ديسک انتقال يابد .
را حل : اين مسئله با استفاده از يک الگوريتم باز گشتي حل مي شود .
-اگر فقط يک ديسک باشد آنگاه آن را به ميله مورد نظر انتقال مي دهيم .
-اگر n > 1 باشد ; براي اين کار n-1 ديسک بالاي ميله 1 را به ميله 2 انتقال مي دهيم . حالا ديسک پاييني ميله 1 را ثابت باقي مي ماند . حال ديسک باقيمانده در در ميله 1 را به ميله 3 منتقل ميکنيم . سرانجام بار ديگر بصورت بازگشتي الگوريتم را فرا خانده تا n - 1 ديسک ميله دو را به 3 منتقل کند .
اکنون موفق شديم n ديسک را از ميله 1 به 3 منقل کنيم .
 
معرفي جاوا:
در يكي از مقالات در باره ي زبان شركتSun جاوا را با اين خصوصيات شرح مي دهد :
جاوا يك زبان ساده ، شي گرا ،‌توزيع شده ، تفسير شده ، قدرتمند ، ايمن ، با معماري خنثي ، قابل حمل ، با عملكرد سطح بالا چند نخ كشي شده و پويا است .
Sun تصديق ميكند كه به طور قطع اين كلمات رشته هايي از واژه هاي متداول در زبان برنامه نويسي هستند ، اما حقيقت اين است كه اين واژه ها به طور ماهرانه اي خصوصيات اين زبان را شرح ميدهند .
حال به برخي از خصلت هاي جاوا در پشت اين واژه ها ميپردازيم .
شي گرا :Object Oriented
جاوا يك زبان برنامه نويسي شي گرا است . براي يك برنامه نويس اين به اين معنا است كه به جاي فكر كردن به قسمت هاي رويه برنامه ، بايد به كاربرد داده ها و روش هايي كه روي آن داده ها عمل ميكنند ، توجه شود.
اگر شما به برنامه نويسي با اعلان رويه در C عادت كرده ايد ،ممكن است دريابيد كه به هنگام استفاده از جاوا مجبور به تغيير در روش و چگونگي برنامه تان هستيد . هنگامي كه فهميديد اين الگوي جديد چقدر قدرتمند است ، به سرعت با آن هماهنگ ميشويد .
در يك سيستم شي گرا ، يك كلاس مجموعه اي از داده ها و روش هايي است كه روي آن داده عمل ميكنند. همراه بودن داده ها و متد ها رفتار و حالت يك شي را بيان مي دارد . كلاس ها به صورت سلسله مراتبي مرتب شده اند ، بنابر اين يك زير كلاس ميتواند رفتار هايي را از كلاس بالاتر به ارث ببرد . يك كلاس سلسله مراتبي هميشه يك كلاس ريشه دارد كه كلاسي است با رفتار هاي كاملا عمومي .
جاوا به همراه دسته ي گسترده اي از كلاس هايي است كه در بسته هايي مرتب شده اند و شما مي توانيد از آنها در برنامه ي خود استفاده كنيد . براي مثال جاوا كلاس هايي را ايجاد ميكند كه :
بخش هاي رابط گرافيكي را ميسازند (the java.awt package) ،كلاس هايي كه عمليات ورودي و خروجي را به عهده دارند(the java.io package) و كلاس هايي كه از شبكه پشتيباني ميكنند (the java.net package )
يك شي كلاس(in the java.lang package) به عنوان ريشه كلاس سلسله مراتبي جاوا انجام وظيفه ميكند .
جاوا بر خلاف C++ طوري طراحي شده است كه از همان ابتدا به صورت شي گرا باشد . اكثر چيز ها در جاوا اشيا هستند . ارقام ابتدايي ، كاراكترها و مدل هاي منطقي تنها استثناء ها هستند . حتي رشته ها هم در جاوا به وسيله اشيا حاضر ميشوند ،همان طور كه ساختمان هاي مهم ديگر اين زبان ، مثل نخ ها احضار ميشوند . يك كلاس يك واحد پايه براي كامپايل و اجرا شدن در جاوا است . تمام برنامه هاي جاوا متشكل از كلاس ها است .
درست است كه جاوا طوري طراحي شده است كه مثل C++ باشد و خاصيت هاي آن را داشته باشد ، اما هنگامي كه با آن كار كنيد خواهيد فهميد كه بسياري از پيچيده گي هاي آن زبان را از بين برده است .
اگر شما يك برنامه نويس C++ هستيد حتما لازم است كه ساختار هاي شي گرايي در جاوا را به دقت مطالعه كنيد . اگرچه تركيب و نحوه دستورات آن تقريبا شبيه C++ است ،‌اما رفتار هاي آن خيلي مشابه نيست .
 
(تفسير شده): Interpreted
جاوا يك زبان تفسير شده است . كامپايلر جاوا به جاي ايجاد كد محلي ماشين ، كد بايتي براي ماشين مجازي جاوا ايجاد ميكند . براي اجراي دقيق برنامه ، از مفسر جاوا براي اجراي كد هاي بايتي كامپايل شده استفاده ميشود . به دليل اينكه كد هاي بايتي جاوا به نوع كامپيوتر بستگي ندارند ، برنامه هاي جاوا ميتوانند روي هر نوع كامپيوتري كه JVM(Java Virtual Machine) را دارند ، اجرا شوند .
در محيط تفسير شده ، مرحله لينك استاندارد توسعه برنامه از ديد كاربر پنهان است . اگر جاوا تنها يك مرحله لينك داشت ، فقط بارگذاري كلاس جديد به محيط پردازش ميشد كه يك پردازش نموي سبك وزن است كه در زمان اجرا مشاهده ميشود . كه اين خصوصيت با چرخه كامپايل-لينك-اجرا ي آرام و طاقت فرساي زبان هايي مانند C يا C++ در تضاد است .
 
 (معماري خنثي و قابل حمل): Architecture Neutral and Portable
 
به دليل اينكه برنامه هاي جاوا در فرمت كد بايتي با معماري خنثي كامپايل شده اند ، برنامه كاربردي جاوا ميتواند در هر سيستمي اجرا شود.
البته با اين شرط كه آن سيستم توانايي پياده سازي ماشين مجازي جاوا را داشته باشد . اين مسئله تقريبا براي كاربرد هاي توزيع سده روي اينترنت و يا ديگر شبكه هاي ناهمگن مهم است . اما روش معماري خنثي براي كاربرد هاي بر مبناي شبكه مفيد است .
به عنوان يك توسعه دهنده برنامه هاي كاربردي در بازار نرم افزاري امروز ممكن است بخواهيد مدل هاي كاربردي خود را توسعه دهيد ، به طوري كه بتواند روي Pc ، مكينتاش و سيستم عامل Unix اجرا شود .با وجود گونه هاي مختلف Unix ، Windows روي Pc و مكينتاش قوي جديد ، رفته رفته توليد نرم افزار براي همه انواع اين كامپيوتر ها سخت مي شود . اگر شما برنامه تان را در جاوا بنويسيد ميتواند روي همه ي اين كامپيوترها اجرا شود .
در حقيقت تفسير شده بودن جاوا وتعريف يك استاندارد ، معماري خنثي داشتن و فورمت كد بايتي آن از بزرگترين دلايل قابل حمل بودن آن به شمار مي آيند .
اما جاوا باز از اين هم بيشتر گام برميدارد ،‌ با اطمينان حاصل كردن از اينكه هيچيك از جنبه هاي وابستگي اجرايي زبان را ندارد . براي مثال جاوا به طور صريح اندازه هريك از انواع داده را تعريف ميكند كه اين با C تفاوت دارد ، براي مثال هريک از انواع صحيح مي تواند بسته به نوع کامپيوتر16-32 يا 64 بيت طول داشته باشد .
هنگامي که به صورت تکنيکي امکان نوشتن برنامه هاي غير قابل حمل در جاوا فراهم شد ، جلوگيري از چند خاصيت وابسته به نوع کامپيوتر که توسط جاوا API توليد شده و به طور قطع قابل حمل نوشته شده است ، آسان است .
يك برنامه جاوا به توليد كنندگان نرم افزار كمك ميكند تا از قابل حمل بودن كد هايشان اطمينان حاصل كنند . برنامه نويسان فقط براي پرهيز از دام غير قابل حمل بودن برنامه احتياج به يك تلاش ساده دارند كه شعار تجارتي شركتSun را زنده نگهدارند و آن شعار اين است :

« يك بار بنويس ، همه جا اجرا كن » .
جاوا يك زبان پويا است . هر كلاس جاوا ميتواند در هر زماني روي مفسر جاوا بارگذاري شود . سپس اين كلاس هاي بارگذاري شده ي پويا ميتوانند به صورت پويا معرفي شوند . حتي كتابخانه كد هاي محلي ميتواند به طور پويا بارگذاري شود .كلاس ها در جاوا با كلاس Class فراخواني ميشوند ؛ شما ميتوانيد به طور پويا در مورد يك كلاس در زمان اجرا اطلاعاتي بدست بياوريد . اين خصوصيت در جاوا 1-1 به طور درستي موجود است . با وجود بازتاب API اضافه شده (Application Program Interface ) كه به برنامه ساز امكان ميدهد كه با برنامه از طريق يك برنامه كاربردي ديگر ارتباط برقرار كند .
جاوا حتي با نام زبان توزيع شده نيز خوانده ميشود . به طور ساده اين به اين معنا است كه اين زبان پشتيباني سطح بالايي براي شبكه به وجود مي آورد . براي مثال كلاس URL و كلاس هاي مرتبط با آن در بسته ي Java.net ، خواندن فايل هاي دوردست را به همان سادگي خواندن فايل هاي محلي كرده است . به طور مشابه در جاوا 1-1 ، احضار روش كنترلي RMI
(Remote Method Invocation ) ، API به يك برنامه جاوا اجازه ميدهد كه روش هايي از اشياء دور دست جاوا را به همان صورتي كه اگر آن اشياء محلي بدند آنها را ميخواند ، بخواند .( جاوا حتي از سيستم شبكه اي سطح پايين كه شامل آدرس مقصد و مسير جرياني كه توسط سوكت ها متصل شده است ، نيز پشتيباني ميكند .)
طبيعت توزيع شده ي جاوا زمانيكه با امكانات پوياي بارگذاري كلاس همراه ميشود ، واقعا درخشنده است . اين خصوصيات با هم اين امكان را براي مفسر جاوا به وجود مي آورند كه كد ها را از اينترنت بارگذاري و اجرا كند . ( همان طور كه بعدا خواهيم ديد جاوا باعث ميشود كه با وجود ابزار قدرتمند و ايمن اين كار به طور مطمئن انجام شود .) اين چيزي است كه در هنگام بارگذاري و اجراي يك برنامه كاربردي از اينترنت توسط مرورگر وب ، اتفاق مي افتد . اما داستان پيچيده تر از اين هم ميتواند باشد . تصور كنيد يك پردازشگر كلمه چند رسانه اي در جاوا نوشته شده است . وقتي از اين برنامه پرسيده ميشود كه چند نوع از داده هايي را كه قبلا هرگز وارد نشده را نمايش دهد ، ممكن است به طور ديناميكي يك كلاس را كه ميتواند داده را شناسايي كند ، از شبكه بارگذاري كند و بعد كلاس ديگري را كه بتواند داده را از درون يك پوشه تركيبي بخواند ، باز به طور ديناميكي بارگذاري ميكند . برنامه اي مانند اين از منابع توزيع شده در شبكه براي رشد و سازگاري خودكار كاربران استفاده ميكند .
ساده :Simple
جاوا يك زبان ساده است . طراحان جاوا سعي در اين داشتند تا زباني بوجود بياورند كه برنامه نويسان بتوانند به سرعت آن را ياد بگيرند . بنابراين تعداد ساختار هاي اين زبان تقريبا كم است . هدف ديگر طراحي اين زبان اين بود كه به منظور راحتي انتقال آن ، آن را طوري طراحي كنند كه براي عده ي زيادي از برنامه نويسان آشنا باشد . اگر شما يك برنامه نويس C يا C++ هستيد ، خواهيد فهميد كه جاوا از بسياري از ساختار هاي C و ‍ C++ استفاده ميكند .
براي اينكه اين زبان را هم به طور ساده و هم آشنا و ملموس و هم كوچك نگه دارند بسياري از خصوصيات C و C++ را در آن حذف كردند . اينها خصوصياتي بودند كه باعث مي شدند برنامه نويسي ضعيفي صورت بگيرد يا آنهايي بودند كه به ندرت در برنامه استفاده مي شدند . براي مثال جاوا از دستور goto استفاده نمي كند ، در عوض از دستورهايbreak , continue در مواقع نياز استفاده مي كند .
جاوا از سر فايل ها(header files) استفاده نمي كند و پردازشگر C را هم حذف كرده است . به اين دليل كه جاوا يك زبان شي گرا است ، ساختار هاي C مثل struct , union از آن برداشته شده است . جاوا حتي بارگذاري مجدد و خواص چندگانه ارث بري از C++ را هم حذف كرده است . شايد مهمترين پارامتر ساده بودن جاوا عدم استفاده اين زبان از اشاره گر ها باشد . اشاره گر ها يكي از بيشترين موجوديت هاي دردسرساز در C , C++ هستند . چون جاوا ساختمان ندارد و آرايه ها و رشته ها اشياء آن هستند ، بنابراين احتياجي به اشاره گر نيست .جاوا به طور خودكار آدرس دهي و دستذسي به محتواي موجود در يك آدرس را براي شما انجام ميدهد .
جاوا حتي زباله هاي حافظه اي را هم به طور خودكار جمع آوري ميكند .(Garbage Collectin) (* جمع آوري آشغال فرايندي است براي ترميم خودكار حافظه انباشته شده . بلوك هايي از حافظه كه زماني به فايل ها اختصاص داشتند اما مدتي است كه از آنها استفاده نمي شود و بلوك هايي از حافظه كه هنوز مورد استفاده قرار ميگيرند ممكن است حركت داده شوند تا از به هم پيوستن فضاهاي خالي حافظه بلوك هاي خالي بزرگتري بدست آيد .
[ از كتاب : Microsoft computer dictionary] * ) بنابراين لازم نيست كه نسبت به موضوع مديريت حافظه نگران باشيد ، همه اينها شما را از نگراني در مورد اشاره گر هاي بي ارزش ، خطرناك و هرز هاي حافظه رها ميكنند . بنابر اين شما ميتوانيد وقت خود را صرف بهبود برنامه تان كنيد
قدرتمند :Robust
جاوا براي نوشتن نرم افزارهاي قدرتمند و بسيار ايمن ساخته شده است . جاوا هنوز هم به طور قطع نرم افزار ها را تضمين نميكند . تقريبا هنوز هم امكان نوشتن برنامه هاي مشكل ساز در جاوا وجود دارد ، هرچند كه جاوا برخي از انواع مشخص خطاهاي برنامه نويسي را حذف كرده كه به طرز چشمگيري نوشتن نرم افزار هاي ايمن را آسان تر كرده است .
جاوا يك زبان تايپ شده قدرتمند است ،‌ كه اجازه چك شدن مشكلات و خطاهاي تايپي را در زمان كامپايل مي دهد . جاوا بسيار قويتر از C++ تايپ شده است كه بسياري از خصوصيات انعطاف پذير در زمان كامپايل را از C به ارث برده است . مخصوصا هنگام اعلان توابع .جاوا به مدل اعلان صريح احتياج دارد ، زيرا كه از مدل اعلان صريح C پشتيباني نميكند . اين مسئله مارا از اينكه كامپايلر ميتواند خطاهاي زمان اعلان را بدست آورد ، مطمئن ميكند . مسئله اي كه منجر به ايجاد برنامه هاي ايمن تري ميشود .
يكي از چيزهايي كه باعث شده كه جاوا ساده باشد عدم وجود اشاره گر ها ومحاسبات بر روي آنها است . اين ويژگي حتي قدرت جاوا را هم با از ميان بردن يك كلاس سراسري اشاره گر افزايش ميدهد .
به طور مشابه تمام دسترسي به آرايه ها و رشته ها در زمان اجرا چك مي شوند تا از قطعي بودن آنها اطمينان حاصل شود .با از بين بردن امكان دوباره نويسي حافظه و داده هاي هرزه ، تعويض نقش اشياء از نوعي به نوع ديگر هم در زمان اجرا كنترل ميشود تا از مجاز بودن آن اطمينان حاصل شود .
سرانجام زباله جمع كن خودكار جاوا بسياري از عمليات پاكسازي مرتبط با معماري حافظه را راه اندازي ميكند . چيزي كه از خطاهاي خطر ساز مرتبط با تخصيص و آزاد سازي حافظه جلوگيري ميكند .
 
ايمن): ( Secure
يكي از دلايل پرطرفدار بودن جاوا اين است كه يك زبان ايمن است . اين ويژگي مخصوصا به خاطر طبيعت توزيع شده ي آن بسيار مهم است .بدون وجود امنيت شما قطعا نميخواهيد كه يك كد را از يك سايت تصادفي اينترنت بارگذاري كنيد و به آن اجازه اجرا شدن روي كامپيوتر خودتان را هم بدهيد . اين دقيقا همان چيزي است كه مردم هرروز با يك كد جاوا انجام ميدهند . جاوا به صورت ايمن طراحي شده و چندين لايه كنترل امنيت به وجود مي آورد كه شما را در برابر كد هاي خطرساز محافظت مي كنند و به كاربر اجازه ميدهد كه برنامه هاي ناشناخته را با خيال راحت اجرا كند .
همان طور كه ديديم ، برنامه جاوا نميتواند اشاره گر ها را به حافظه يا آرايه هاي سرريز يا حافظه خواندني خارج از محدوده يك آرايه يا رشته اشاره ، اشاره دهد. اين خصوصيت يكي از اصلي ترين وسايل دفاع جاوا در برابر كدهاي خطرساز است . دومين راه دفاع در برابر كد هاي خطرساز ، پردازش كدهاي بايتي به صورت قابل تصديق و تاييد است كه مفسر جاوا به روي هر كدي كه در حال بار گذاري باشد اعمال ميكند . اين مراحل تاييد از اينكه كد به صورت درستي ساخته شده اطمينان حاصل ميكنند ، كه براي مثال پشته سرريزي يا زيرريزي نداشته باشد ، يا شامل كد هاي بايتي غير مجاز نباشد .
كدهاي بايتي خراب يا خطرساز ممكن است از ضعف هاي اجرايي در مفسر جاوا سوء‌ استفاده كنند . لايه اي كه در اينجا ما را به طور ايمن محافظت ميكند ، مدل جعبه شني (Sand box) است : كدهاي ناشناخته در يك جعبه شني قرار ميگيرند جايي كه ميتوانند به صورت ايمن اجرا شوند ، بدون اينكه هيچ صدمه اي به بقيه اجزاء يا محيط جاوا بزنند .
وقتي يك برنامه كاربردي يا ديگر كدهاي ناشناخته در جعبه شني در حال اجرا است ،‌ چند محدوديت در مورد كاري كه ميتواند انجام دهد ، وجود دارد . واضح ترين اين محدوديت ها اين است كه هيچ دسترسي به هيچ يك از فايل هاي محلي سيستم وجود ندارد . در جعبه شني محدوديت ديگري هم وجود دارد كه به وسيله كلاس مديريت امنيت اعمال ميشود . اين مدل در ابتدا از اينكه سيستم هاي امنيتي را نصب كرده ايد يا نه ، مطمئن ميشود ، چرا كه همه كلاس هاي جاوا نياز به عمليات حساسي مانند دسترسي به سيستم فايل را دارند . اگر فراخواني به وسيله يك كد ناشناخته به صورت مستقيم يا غير مستقيم انجام شد ،‌ مدير امنيت مورد استثناء‌ را مي فرستد و عمليات صورت نمي گيرد .
و سرانجام در جاوا 1-1 يك راه حل ممكن ديگر براي مشكلات امنيتي وجود دارد ، به وسيله ضميمه كردن يك امضاء ديجيتالي به كد جاوا كه اصل آن كد ميتواند به صورت پنهاني و نهفته ساخته شود . اگر شما اعتماد خود را به يك شخص يا يك سازمان مشخص كرده باشيد ، كدي كه امضاء آن هويت مورد اعتماد روي آن قرار دارد ،‌ ايمن و مطمئن است . حتي زمانيكه در حال بارگذاري شدن در شبكه است و ممكن است حتي بدون جلوگيري توسط جعبه شني اجرا شود .
 
عملكرد سطح بالا): (High Performance
جاوا يك زبان تفسير شده است ، بنابر اين هرگز به سرعت زبان كامپايل شده اي مثل C نخواهد بود . گفته ميشود كه جاوا 0-1 به اندازه 20 برابر از C كند تر است . جاوا 1-1 تقريبا سرعتي دو برابر جاوا 1-1 دارد . بنابراين ممكن است عاقلانه باشد اينكه بگوييم كد C كامپايل شده 10 برابر سريع تر از كد هاي تفسير شده ي جاوا اجرا ميشود . اما قبل از اينكه به خاطر اين موضوع مايوس شويد ، آگاه باشيد كه اين سرعت بيشتر از آن چيزي است كه براي برنامه هاي پرسرعت ، كاربردهاي GUI(Graphical User Interface ) ، برنامه هاي برمبناي شبكه ، جايي كه برنامه كاربردي معمولا آماده براي اجرا شدن است ، انتظار براي كاربر كه يك دستوري اعمال كند و يا انتظار براي دريافت از شبكه ، لازم است .
به علاوه قسمت هايي كه به سرعت هاي بالا نياز دارند ، كه كارهايي از قبيل الحاق رشته ها و مقايسه را انجام ميدهند ، با كد محلي جاوا اجرا ميشوند .
علاوه بر اين كارايي ، بسياري از مفسر هاي جاوا اكنون شامل كامپايلر هاي فقط در زمان " just in time " نيز هستند كه ميتواند كدهاي بايتي جاوا را براي هر نوعCPU در زمان اجرا به كد ماشين ترجمه كند . فرمت كد بايتي جاوا با اين كامپايلر هاي در زمان در مركز كافي و مناسب است و انصافا كدهاي خوبي توليد ميكند . در حقيقت Sun ادعا ميكند كه كارايي كد هاي بايتي كه به كد ماشين تبديل شده اند ، تقريبا به خوبي كارآيي آن در C و C++ است .
اگر شما خواهان اين هستيد كه قابل حمل بودن كد ها را قرباني بهبود در سرعت آن كنيد ، ميتوانيد بخش قابل توجهي از برنامه خود را در C و C++ بنويسيد و از روش هاي مخصوص جاوا براي مشترك كردن با اين كد محلي جاوا استفاده كنيد .
چند نخ كشي شده :Multitbreaded
در يك برنامه كاربردي بر مبناي GUI شبكه اي ، مثل مرورگر وب ، تصور اينكه چند چيز بتوانند به طور همزمان اجرا شوند ، آسان است . يك كاربر ميتواند همزمان با اينكه دارد يك صفحه وب را ميخواند به يك كليپ صوتي گوش دهد و همزمان در پس زمينه مرورگر يك عكس را بارگذاري كند .
جاوا يك زبان چندنخ كشي شده است ، كه از چندين رشته اجرايي (گاهي پردازش سبك وزن خوانده ميشود) پشتيباني ميكند و ميتواند چندين كار را انجام دهد . يكي از مزيت هاي چندنخ كشي شده اين است كه عملكرد سطح بالايي براي كاربردهاي گرافيكي براي كاربر فراهم ميكند .
اگر شما سعي كرده ايد كه با نخ ها در C و C++ كار كنيد ، ميدانيد كه كمي مشكل است . جاوا برنامه نويسي با نخ ها را بسيار آسان تر كرده است ، با به وجود آوردن زبان درون ساخته شده اي كه از نخ ها پشتيباني ميكند . بسته jana.lang يك كلاس بوجود آورده است كه از روش هايي براي شروع و پايان يك نخ ، و مرتب كردن ترتيب گره ها در ميان چيز هاي ديگر ، پشتيباني ميكند .
حتي دستورات زبان جاوا از نخ ها پشتيباني ميكنند ، كه با استفاده از كلمات كليدي مطابق شده . اين كلمات كليدي علامت گذاري بخش هاي كد يا تمامي روش هايي را كه بايد فقط با يك نخ در يك زمان اجرا شوند را به شدت آسان كرده است .
به دليل اينكه جاوا استفاده از نخ ها را بسيار ساده ميكند ، كلاس جاوا در شماري از جاها از اين نخ ها استفاده ميكند . براي مثال هر برنامه كاربردي كه انيميشن اجرا ميكند ، از نخ ها استفاده كرده است .
به طور مشابه جاوا از برنامه هاي نا همگام ، ورودي ها و خروجي هاي بلاك نشده با اخطاري به وسيله سيگنال ها يا وقفه ها پشتيباني نميكند ، در اين صورت شما بايد يك نخ بسازيد كه روي هر كانال ورودي خروجي كه با آن كار ميكنيد بلاك شده باشد .
بنيادهاي كلاس java
چيزي كه بايد درباره يك كلاس بدانيد اين است كه كلاس يك نوع جديد داده را تعريف
مي كند . هربار كه اين نوع تعريف شود ، مي توان از آن براي ايجاد اشيائي از
همان نوع استفاده نمود . بنابراين ، يك كلاس قالبي (template) براي يك شي ئ است
و يك شي ئ نمونه اي (instance) از يك كلاس است . چون شي ئ يك نمونه از يك كلاس است .
غالبا" كلمات شي ئ (object) و نمونه (instance) را بصورت مترادف بكار مي بريم .
شكل عمومي يك كلاس
هنگاميكه يك كلاس را تعريف مي كنيد ، در حقيقت شكل و طبيعت دقيق آن كلاس را
اعلان مي كنيد . ابتكار را با توصيف داده هاي موجود در آن كلاس و كدهايي كه روي
آن داده ها عمل مي كنند ، انجام مي دهيد . در حاليكه كلاسها ممكن است خيلي ساده
فقط شامل داده يا فقط كد باشند، اكثر كلاسهاي واقعي هردو موضوع را دربرميگيرند.
بعدا" خواهيد ديد كه كد يك كلاس ، رابط آن به داده هاي همان كلاس را توصيف ميكند.
يك كلاس را با واژه كليدي class اعلان مي كنند داده يا متغيرهايي كه داخل يك كلاس تعريف شده اند را متغيرهاي نمونه instance)
(variables مي نامند . كدها ، داخل روشها (methods) قرار مي گيرند . روشها و
متغيرهاي تعريف شده داخل يك كلاس را اعضائ (members) يك كلاس مي نامند . در اكثر
كلاسها ، متغيرهاي نمونه يا روي روشهاي تعريف شده براي آن كلاس عمل كرده يا توسط
اين روشها مورد دسترسي قرار مي گيرند . بنابراين ، روشها تعيين كننده چگونگي
استفاده از داده هاي يك كلاس هستند .
متغيرهاي تعريف شده داخل يك كلاس ، متغيرهاي نمونه خوانده شده زيرا هر نمونه
از كلاس ( يعني هر شي ئ يك كلاس ) شامل كپي خاص خودش از اين متغيرهاست . بنابراين
داده مربوط به يك شي ئ ، جدا و منحصر بفرد از داده مربوط به شي ئ ديگري است . ما
بزودي اين نكته را بررسي خواهيم نمود ، اما فعلا" بايد اين نكته بسيار مهم را
بياد داشته باشيد .
كليه روشها نظير()main همان شكل عمومي را دارند كه تاكنون استفاده كرده ايم .
اما ، اكثر روشها را بعنوان staticيا publicا توصيف نمي كنند . توجه داشته
باشيد كه شكل عمومي يك كلاس ، يك روش ()main را توصيف نمي كند . كلاسهاي جاوا
لزومي ندارد كه يك روش ()main داشته باشند . فقط اگر كلاس ، نقطه شروع برنامه
شما باشد ، بايد يك روش ()main را توصيف نماييد . علاوه بر اين ، ريز برنامه ها
(applets) اصولا" نيازي به روش ()main ندارند .
نكته : برنامه نويسان C++ آگاه باشند كه اعلان كلاس و پياده سازي روشها در يك
مكان ذخيره شده و بصورت جداگانه تعريف نمي شوند. اين حالت گاهي فايلهاي
خيلي بزرگ java ايجاد مي كند ، زيرا هر كلاس بايد كاملا" در يك فايل منبع
تكي تعريف شود . اين طرح در جاوا رعايت شد زيرا احساس مي شد كه در بلند
مدت ، در اختيار داشتن مشخصات ، اعلانها و پياده سازي در يك مكان ، امكان
دسترسي آسانتر كد را بوجود مي آورد .
آرايه ها در جاوا
يك آرايه گروهي از متغيرهاي يك نوع است كه با يك نام مشترك به آنها ارجاع
مي شود . مي توان آرايه ها را براي هر يك از انواع ايجاد نمود و ممكن است اين
آرايه ها داراي يك يا چندين بعد باشند . براي دسترسي به يك عضو آرايه از نمايه
(index) آن آرايه استفاده مي شود . آرايه ها يك وسيله مناسب براي گروه بندي
اطلاعات مرتبط با هم هستند .
نكته : اگر با Cو C++و آشنايي داريد ، آگاه باشيد . آرايه ها در جاوا بطور
متفاوتي نسبت به زبانهاي ديگر كار مي كنند .
 
آرايه هاي يك بعدي
آرايه يك بعدي بطور ضروري فهرستي از متغيرهاي يكنوع است . براي ايجاد يك
آرايه ، بايد يك متغير آرايه از نوع مورد نظرتان ايجاد كنيد .
آرايه هاي چند بعدي
در جاوا آرايه هاي چند بعدي در واقع آرايه اي از آرايه ها هستند . اين قضيه
همانطوريكه انتظار داريد ظاهر و عملكردي مشابه آرايه هاي چندبعدي منظم (regular)
دارد . اما خواهيد ديد كه تاوتهاي ظريفي هم وجود دارند . براي اعلان يك متغير
آرايه چند بعدي ، با استفاده از مجموعه ديگري از كروشه ها هر يك از نمايه هاي
اضافي را مشخص مي كنيد.
عملگرها ي رياضي و بيتي
جاوا يك محيط عملگر غني را فراهم كرده است . اكثر عملگرهاي آن را مي توان
در چهار گروه طبقه بندي نمود : حسابي arithmetic رفتار بيتي bitwise رابطه اي ralational
و منطقي logical جاوا همچنين برخي عملگرهاي اضافي براي اداره
حالتهاي خاص و مشخص تعريف كرده است .
نكته : اگر با C++/C آشنايي داريد ، حتما" خوشحال مي شويد كه بدانيد كاركرد
عملگرها در جاوا دقيقا"مشابه با C++/C است . اما همچنان تفاوتهاي ظريفي
وجود دارد .
 
انواع ساده The simple Types
 
جاوا هشت نوع ساده ( ياابتدايي ) از داده را تعريف مي كند : short bbyte int
، long،، char،، float،، double،، boolean، اين انواع را مي توان در چهار
گروه بشرح زير دسته بندي نمود :
ؤ integers ( اعداد صحيح ) : اين گروه دربرگيرنده byte، short،، int،و longو
ميباشد كه مختص ارقام علامتدار مقدار كل (whole-valued signed numbers) ميباشد.
ؤ floating-point numbers ( اعداد اعشاري ) : اين گروه دربرگيرنده float و double
است كه معرف اعدادي است با دقت زياد .
ؤ characters ( كاراكترها ) : اين گروه فقط شامل char بوده كه نشانه هايي
نظير حروف و ارقام را در يك مجموعهخاص از كاراكترها معرفي مي كند .
ؤ Boolean ( بولي ) : اين گروه فقط شامل boolean است . كه نوع خاصي ازمعرفي
و بيان مقادير صحيح / ناصحيح مي باشد .
شما مي توانيد از اين انواع همانطوريكه هستند استفاده كرده ، يا آرايه ها و
انواع كلاسهاي خود را بسازيد .
انواع اتمي معرف مقادير تكي و نه اشيائپيچيده هستند . اگر چه جاوا
همواره شي ئ گرا است ، اما انواع ساده اينطورنيستند . اين انواع ، مشابه انواع
ساده اي هستند كه در اكثر زبانهاي غير شي ئگرا مشاهده مي شود . دليل اين امر
كارايي است . ساختن انواع ساده در اشيائ سببافت بيش از حد كارايي و عملكرد
مي شود .
انواع ساده بگونه اي تعريف شده اندتا يك دامنه روشن و رفتاري رياضي داشته
باشند . و زبانهايي نظير Cو C++و امكانمي دهند تا اندازه يك عدد صحيح براساس
ملاحظات مربوط به محيط اجرايي تغيير يابد . اما جاوا متفاوت عمل مي كند . بدليل
نيازهاي موجود براي قابليت حمل جاوا ،كليه انواع داده در اين زبان داراي يك
دامنه كاملا" تعريف شده هستند . بعنوانمثال يك int هميشه 32 بيتي است ، صرفنظر
از اينكه زير بناي خاص محيطي آن چگونهباشد . اين حالت به برنامه هاي نوشته شده
اجازه مي دهد تا با اطمينان و بدون درنظر گرفتن معماري خاص يك ماشين اجراشوند.
ويژگيهاي زبان برنامه نويسي Java
جاوا ويژگيهاي متعددي دارد که آن را منحصربه فرد کرده است . جاوا هم کامپايلر دارد و اينترپرتر . توضيح : ( کامپايلر برنامه اي است که متن برنامه را گرفته و در پايان يک فايل exe توليد مي کند. بعد از کامپايل شدن يک برنامه ، ديگر به وجود کامپايلر نيازي نيست و مي توان برنامه exe را روي هر کامپيوتر سازگاري اجرا کرد . اما اينترپرتر هيچ برنامه exe اي توليد نمي کند و برنامه را خط به خط اجرا مي کند ، براي اجراي برنامه حتما بايد اينترپرتر هم روي کامپيوتر مورد نظر موجود باشد).
هر کامپايلر فقط براي يک سيستم خاص ( مانند اينتل ، اپل يا آلفا ) مي تواند کد اجرايي توليد کند اما کامپايلر جاوا کد اجرايي Exe توليد نمي کند و در عوض يک فايل بينابيني مي سازد که بايت کد Byte code نام دارد و بايت کد چيزي شبيه زبان اسمبلي است ، اما اين زبان مختص هيچ پروسسور خاصي نيست بلکه زبان اسمبلي يک ماشين ويژه بنام ماشين مجازي جاوا ( Java Virtual Mashing) دارد که روي ماشين مجازي جاوا اجرا مي شود ، دستورات فايل بايت کد را به دستورات قابل فهم براي پروسسوري که روي آن اجرا مي شود تبديل خواهد کرد .
 
برنامه نويسي با جاوا:
برنامه اي مي نويسيم يک برنامه متکي به خود است بنام Hello World . تفاوت يک برنامه متکي به خود و يک اپلت آن است که در برنامه متکي به خود ( که از اين به بعد به آن فقط برنامه خواهيم گفت ) از متدي بنام ()main استفاده مي شود در حاليکه اپلت چنين متدي ندارد .

برنامه Hello World بسيار ساده است و فقط جمله “Hello World” را نمايش مي دهد با اين حال مي توان از آن به عنوان سنگ بناي برنامه هاي پيشرفته تر استفاده کرد چون تمام برنامه هاي جاوا ساختار کلي مشابهي دارند .
براي کامپايل کردن برنامه بايد از کامپايلر جاوا (javac) استفاده کرد روش کار چنين است :
Java HelloWorld. java
کامپايلر بعد از پايان کار يک فايل کلاس بنام HelloWorld. Class توليد خواهد کرد . اصولاً کامپايلر براي هر کلاس برنامه يک فايل کلاس جداگانه توليد خواهد کرد . فايل توليد شده يک فايل اجرايي مستقل نيست . براي اجراي اين فايل بايد از اينترپرتر جاوا استفاده کرد . اينترپرتر جاوا، Java نام دارد . براي اجراي فايل کلاس توليد شده چنين بايد کرد :
Java HelloWorld
 
کامپايلر جاوا و اينترپرتر جاوا دو چيز متفاوتند . کامپايلر از فايل متن برنامه يک فايل کلاس مي سازد و اينترپرتر فايل کلاس را اجرا مي کند .
دستورات و عبارات
يک دستور ساده ترين کاري است که در جاوا مي توان انجام داد ، هر دستور يک عمل انجام مي دهد . در ذيل چند دستور ساده جاوا را مشاهده مي کنيد .
 
گاهي يک دستور مقدار برگشتي دارد مثل جمع دو عدد . به اين نوع دستورات عبارت گفته مي شود. مهمترين چيزي که در مورد دستورات لازم جاوا بايد به خاطر داشته باشيد اين است که در پايان هر دستور يک سمي کولون (;) لازم است . در غير اينصورت برنامه بدرستي کامپايل نخواهد شد .
هر جا که بتوان از يک دستور استفاده کرد از يک دستور مرکب ، يا بلوک ، هم مي توان استفاده کرد . دستورات يک بلوک درون يک جفت آکولاد (**}) قرار مي گيرند.
از اين لحاظ جاوا و سي پلاس پلاس با هم مشابهند.
متغيرها و انواع داده
يک متغير (Variable) مکاني است در حافظه که مي توان مقاديري را در آن ذخيره کرد.. هر متغير داراي سه چيز است : نام ، نوع ، مقدار . قبل از استفاده از يک متغير بايد آنرا تعريف (Declare) کنيد . در جاوا سه نوع متغير وجود دارد : متغير وهله ، متغير کلاس ، متغير محلي .
متغيرهاي وهله خواص يک شيء خاص را در خود نگه مي دارند . متغيرهاي کلاس مانند متغيرهاي وهله هستند با اين تفاوت که به وهله هاي يک کلاس مربوط مي شوند . متغيرهاي محلي اغلب در درون متدها مورد استفاده قرار مي گيرند و براي نگهداري مقادير درون متد هستند ، در بلوک ها هم مي توان از متغيرهاي محلي استفاده کرد.همين کد اجراي متد ( يا بلوک ) به پايان رسيد ، متغيرهاي محلي دورن آن هم از بين مي روند .
با آن که نحوه تعريف اين سه نوع متغير يکسان است ، اما نحوه دسترسي به آنها کمي متفاوت است.
نکته :
بر خلاف سي پلاس پلاس ، جاوا متغير عمومي ( همگاني ) ندارد . براي ارتباط بين اشياء از متغيرهاي وهله و کلاس مي توان استفاده کرد . به ياد داشته باشيد که جاوا يک زبان شييء گرا است و شما به هم کنش اشياء فکر کنيد و نه چيز ديگر .
تعريف متغيرها
براي استفاده از يک متغير در برنامه هاي جاوا و سي پلاس پلاس ، ابتدا بايد آن را تعريف کنيد . تعريف متغير از يک نوع و يک نام تشکيل مي شود .
 
تعريف يک متغير مي تواند در هر کجاي يک متد انجام شود ، ولي بهتر است در ابتداي متد باشد .
 
چند متغير از يک نوع را مي توان در يک جا تعريف کرد :
 
و حتي مي توان در هنگام تعريف متغير به آن مقدار داد.
 
به متغيرهاي محلي قبل از استفاده حتماً بايد مقدار داد، در غير اينصورت برنامه بدرستي کامپايل نخواهد شد . مقدار دادن اوليه به متغيرهاي وهله و کلاس الزامي نيست . چون اين متغيرها هنگام تعريف داراي مقدار پيش فرض هستن
نکاتي درباره نام متغيرها
نام متغيرها در جاوا و سي پلاس پلاس مي تواند با يک حرف ، زير خط (_) يا علامت دلار ($) شروع شود ولي نبايد با يک عدد آغاز شود . بعد از حرف اول مي توان از تمام حروف ديگر استفاده کرد ولي هنگام استفاده از % ، * ، @ و مانند آنها ( که در اپراتورها هستند ) به مشکلاتي که مي تواند بروز کند دقت کنيد .
جاوا بر خلاف سي پلاس پلاس از کاراکترهاي يوني کد (Unicode) استفاده مي کند ، يوني کد استانداردي است که بر خلاف اسکي براي هر کاراکتر از دو بايت استفاده مي کند و مي تواند در آن واحد تا 65000 کاراکتر را پشتيباني کند . البته تمام کاراکترهاي ذيل 00CO رزرو شده اند و شما مي توانيد از کاراکترهاي بالاي اين حد آزادانه استفاده کنيد .
نام متغيرها در هر دو زبان نسبت به نوع حروف حساس است و اين دقت زيادي را در در هنگام نوشتن برنامه ها مي طلبد . به همين دليل رعايت يک قرارداد هنگام نامگذاري متغيرها مي تواند کمک بزرگي در مقابله با مشکلات احتمالي باشد .
قراردادهاي استفاده شده چنين اند : نام هاي با معني ، ترکيب چند کلمه ، کلمه اول با حرف کوچک شروع مي شود ، کلمات بعدي با حرف بزرگ شروع مي شوند . به اين مثال در جاوا دقت کنيد :
انواع متغيرها
هنگام تعريف هر متغير علاوه بر نام آن بايد نوع آن هم مشخص شود . نوع متغير تعيين مي کند که يک متغير چه مقاديري را مي تواند بگيرد . هر متغير مي تواند يکي از سه نوع ذيل باشد :
• يکي از هشت نوع داده اوليه
• نام يک کلاس يا واسط
• يک آرايه
هشت نوع داده اوليه جاوا براي کار با اعداد صحيح ، اعداد اعشاري ، کاراکترها و مقادير منطقي ( درست يا نادرست ) هستند ، به آنها انواع اوليه گفته مي شود. در جاوا چهار نوع عدد صحيح (Integer) وجود دارد .
به جدول زير نگاه کنيد .
 
اين انواع همگي علامت دار هستند ، يعني مي توانند اعداد مثبت و منفي را در خود ذخيره کنند . نوع متغير انتخاب شده به عددي که مي خواهيد ذخيره کنيد بستگي دارد . اگر عدد بزرگتر از متغير باشد ، بي سرو صدا قيچي خواهد شد !
براي ذخيره کردن اعدا داراي مميز از نوع اعشاري ( با مميز شناور – floating point ) استفاده مي شود . اعداد اعشاري در جاوا از استاندارد IEEE 754 تبعيت مي کنند . دو نوع عدد اعشاري وجود دارد : float 32bit دقت ساده و Double 64bit دقت مضاعف .
نوع داده کاراکتر (char) براي ذخيره کردن يک کاراکتر است . چون جاوا از يوني کد استفاده مي کند هر متغير Char داراي 16 بيت ( بدون علامت ) خواهد بود .
آخرين نوع داده اوليه در جاوا نوع منطقي (Boolean) است که مي تواند دو مقدار True يا False بگيرد . بر خلاف ++C ، نوع منطقي يک عدد نيست و نبايد آن را با اعداد مقايسه کرد . علاوه بر اين انواع ، متغيرهاي جاوا مي توانند از نوع کلاس هم باشند :
 
اين متغيرها يک وهله از کلاس مربوطه هستند .
در جاوا ( بر خلاف ++C ) ، دستور typedef وجود ندارد . براي تعريف انواع جديد در جاوا ، ابتدا يک کلاس جديد ايجاد کنيد ، و سپس متغيري از نوع اين کلاس تعريف کنيد .
مقدار دادن به متغيرها
بعد از تعريف متغيرها ، با استفاده از عملگر = مي توان به آنها مقدار داد :
 
توضيحات (Comments) :
سه نوع توضيح در اين زبانها وجود دارد . در نوع اول در جاوا و ++C از */ براي شروع و از /* براي ختم آن استفاده مي شود . کامپايلر هر چه را بين اين دو علامت بيابد ناديده خواهد گرفت .
 
*/
اين نوع توضيح مي تواند چند خطي باشد .
در نوع دوم براي توضيحات تک خطي از // مي توان استفاده کرد:
 
در نوع سوم توضيح که برنامه javadoc از آن استفاده مي کند يا **/ شروع و با /* پايان مي يابد . اين نوع توضيح از همه نظر شبيه نوع اول است .
 
 
واژه ها:
براي نمايش مقادير مشخص و ساده از واژه ها (Literal) استفاده مي شود . اين واژه ها مي تواند عدد ، کاراکتر ، رشته يا مقادير منطقي باشند .
 
واژه هاي عددي:
چندين واژه صحيح وجود دارد . مثلاً ، 4 يک واژه صحيح از نوع int است . اگر عدد واژه از يک int بزرگتر باشد بطور خودکار به نوع long تبديل خواهد شد . مي توانيد حتي يک عدد کوچک از نوع long داشته باشيد ، براي اينکار در جاوا بايد جلوي عدد از حرف l يا L استفاده کنيد . مثلاً ، 4L عدد صحيح 4 را در يک واژه long ذخيره مي کند .
واژه هاي اعشاري معمولاً دو قسمت دارند . يک قسمت صحيح و يک قسمت اعشاري . تمام واژه هاي اعشاري صرفنظر از دقت عدد از نوع double خواهند بود مگر اينکه با قيد حرف f ( يا F ) در جلوي آن تصريح شود که عدد مزبور از نوع float بايد باشد . واژه هاي اعشاري را با استفاده از حرف E ( يا e ) مي توان به صورت نمايش هم نوشت – 10e45 يا -3.6E-2 .
واژه هاي منطقي:
در جاوا يک واژه منطقي فقط مي تواند معادل کلمات کليدي True يا False باشد .
 
واژه هاي کاراکتري:
يک واژه کاراکتري عبارت است از يک حرف که با علامت نقل محصور شده باشد ‘a’ ، ‘#’ و غيره .در جاوا واژه هاي کاراکتري به صورت يوني کد ( 16 بيتي ) ذخيره مي شوند در حاليکه در سي پلاس پلاس به صورت اسکي ذخيره مي شوند. . در جدول زير چند کد غير چاپي خاص و کاراکترهاي يوني کد را مشاهده مي کنيد . ( در جدول d نماينده يک رقم است ) .
 
 
واژه هاي رشته اي:
يک رشته (String) عبارتست از مجموعه چند کاراکتر . هر رشته در جاوا وهله ايست از کلاس String . بر خلاف ++C ، رشته ها در جاوا آرايه ساده کاراکترها نيستند ( اگر چه بسياري از خواص آرايه ها را ندارند ) . چون رشته هاي جاوا اشياء حقيقي هستند ، متدهايي دارند که کار با آنها را بسيار زنده مي سازند .
يک واژه رشته اي عبارت است از چند کاراکتر که در علامت نقل دو گانه محصور شده باشند :
 
رشته ها مي توانند شامل کدهاي خاص جدول زير نيز مي باشند :
 
در مثال آخر ، \u2122 کاراکتر يوني کد علامت تجاري ™ است .
 
- اينکه شما مي توانيد در رشته هاي جاوا از کاراکترهاي يوني استفاده کنيد بدان معنا نيست که مي توانيد آن کاراکترها را ببينيد . براي ديدن اينگونه کاراکترها کامپيوتر يا سيستم عامل شما بايد از يوني کد پشتيباني کند و فونت بکار رفته را هم داشته باشد .
- تفاوت واژه هاي رشته اي با ديگر انواع واژه هاي رشته اي ( بر خلاف ديگر واژه ها ) اشياء واقعي (وهله هاي کلاس String ) هستند .
 
 
عبارات و عملگرها:
عبارت (expression) ساده ترين واحد عملياتي است .
عبارت دستوري است که يک مقدار بر مي گرداند . در عبارات از علايم خاصي استفاده مي شود که به آنها عملگر (Operator) گفته مي شود . ساده ترين نوع عبارات به مقايسه مقادير و محاسبه مي پردازد . عبارات را مي توان به يک متغير نسبت داد چون داراي مقدار برگشتي است .

عملگرهاي جاوا عبارتند از عملگرهاي محاسباتي ، انواع مختلف انتساب مقدار ، افزايش و کاهش ، و عمليات منطقي .
 
محاسبات
هر دو زبان داراي پنج عملگر محاسباتي است .
هر عملگر دو عملوند (Operand) لازم دارد . از عملگر تفريق (-) براي منفي کردن اعداد هم مي توان استفاده کرد . تقسيم اعداد صحيح داراي خارج قسمت صحيح خواهد بود و مقدار اعشار آن ناديده گرفته خواهد شد . مثلاً حاصل تقسيم 9/31 معادل 3 خواهد بود . عملگر % باقيمانده تقسيم را بر مي گرداند .
براي مثال حاصل عبارت 9%31 معادل 4 خواهد شد .
حاصل عمليات دو عدد صحيح همواره يک عدد صحيح خواهد بود . نوع داده مقدار برگشتي با نوع داده عملوندي که جاي بيشتري اشغال مي کند معادل خواهد بود .
انتساب مقادير
نسبت دادن مقدار (assignment) به يک متغير نوعي عبارت است ; در حقيقت ، چون هر عبارت يک مقدار برگشتي دارد مي توان چند عبارت انتسابي را به هم پيوند داد:
X=y=z=0;
هميشه ابتدا مقدار عبارت سمت راست محاسبه شده و به عبارت سمت چپ نسبت داده مي شود . اين بدان معناست که عبارت x=x+2 يک عبارت صحيح است ؛ به x دو واحد اضافه شده و حاصل در x قرار داده مي شود . عملياتي از اين دست چنان در برنامه نويسي رايج است که جاوا براي آن عملگر ويژه اي دارد ( اين ويژگي را جاوا از ++C بعاريت گرفته است ) . جدول عملگر هاي ويژه را نشان داده است .
 
در عبارت پيچيده ممکن است نتيجه اين عملگرهاي ويژه با معادلهايشان يکسان نباشد . اين موضوع کاملاً به نوع عبارت ، پيچيدگي آن و ترتيب محاسبه بستگي دارد .
افزايش و کاهش
مانند ++C در جاوا هم براي اضافه يا کم کردن 1 از عملگرهاي ++ يا -- استفاده مي شود . مثلاً عبارت ++X به X يکي اضافه مي کند و معادل x=x+1 است . عبارت X-- هم يکي از x کم مي کند . بر خلاف ++C ، عملوند در عبارات ++ يا -- مي توانند اعشاري هم باشند .
عملگرهاي ++ و -- مي توانند قبل يا بعد از متغير قرار گيرند . در عبارات ساده اين موضوع چندان اهميتي ندارد ، ولي در عبارات پيچيده مي تواند باعث بروز تفاوتهايي شود . براي مثال ، به دو عبارت ذيل دقت کنيد :
y = x++;
y = ++ x;
 
نتيجه اين دو عبارت بسيار متفاوت خواهد بود . در عملگر پسوند ++ يا x-- ، y مقدار x را قبل از تغيير آن مي گيرد ؛ در عملگر پيشوند ( -- يا --x ) مقدار x بعد از تغيير به y داده مي شود . در ليست زير مثالي که اين مطلب را نشان مي دهد آورده شده است .
 
مقايسه ها
هر دو زبان براي مقايسه مقادير عبارات متعددي دارد . تمام اين عبارات يک مقدار Boolean (يعني True يا False ) بر مي گرداند . جدول زير عملگرهاي مقايسه اي را نشان مي دهد :
 
 
    ساختارهاي کليدي: oop
    برنامه نويسي oop، تکنيک نوين برنامه نويسي نيست، بلکه ريشه هايش به Simula-67 باز مي گردد. گر چه اولين اجرا و پياده سازي کاملش به Smalltalk-80 باز ميگردد. oop در نيمه دوم قرن 80 با ظهور بسياري از زبانهاي مختلف مانند
    C++‎, Objective-C, Object and Turbo Pascal, CLOS (an OOP extension of Lisp), Eiffel, Ada
    و اخيراً جاوا رايج شد. در اين مقاله روي C++‎ ، object Pascal و جاوا تمرکز شده است. قبل از اينکه سه زبان بالا را مورد بررسي قرار دهيم تعدادي واژه هاي کليدي را تعريف و توصيف مي کنم.
    اولين مشخصه کليدي تعريف کلاس هاست. معمولاً کلاسها اساس پيمانه اي بودن (Modularity)، انتزاع داده ها و کپسوله سازي در زبانهاي oop هستند.
دومين واژه کليدي وراثت است. که يک روشي براي تعريف يک نوع جديد ارث بري عناصر از يک موجوديت و اصلاح آن موجوديت است . اين کلمه يک لغت تخصصي و عمومي است.
   سومين کلمه به عنوان چند ريختي مشهور شده است. و به شما اجازه مي دهد که به اشيايي از کلاسهاي گوناگون در يک شيوه همگن رجوع کنيد. اين عمل سبب مي شود که حتي کلاس مجدداً قابل استفاده باشد و برنامه ها هم آسانتر گسترش مي يابند.
 
    کلاس ها، وراثت و چند ريختي مشخصه هاي اساسي هستند که بوسيله يک زبان به عنوان زبان oop توصيف مي شوند. از زبانهايي که وراثت و چند ريختي ندارند بلکه کلاس دارند به طور کلي به عنوان يک زبان based–class (برپايه کلاس ) معرفي شده اند. زبانهايoop مختلف به طور کامل خط مشي هاي متفاوتي را دنبال مي کنند ما ميتوانيم مکانيزم هاي کنترل نوع ، توانايي پشتيباني از مدلهاي مختلف برنامه نويسي و پشتيباني از مدل شي را در ميان زبانهاي مختلف oop به صورت برجسته مقايسه کنيم.
    Compile-Time vs. Runtime Type checking (کنترل نوع زمان اجرا در مقابل کنترل نوع زمان کامپايل)
 
    زبان هاي برنامه نويسي مي توانند از لحاظ قدرت کنترل نوع ارزيابي شوند.کنترل نوع به وجود روش هايي که پيشتر گفته شد، پارامترهايشان و چک کردن محدوده آرايه و غيره بستگي دارد.
    C++‎, Javaو Object Pascal هر سه شان کمتر يا بيشتر از کنترل نوع در زمان کامپايل پشتيباني مي کنند. از اين سه زبان شايد C++‎ از دقت کمتري برخوردار باشد. Javaکنترل نوع قوي تري دارد. به اين دليل است که C++‎با زبان c سازگاري دارد از کنترل نوع زمان کامپايل پشتيباني مي کند. براي مثال C++‎ ,c نوع رياضي را به عنوان شروع سازگاري مورد توجه قرار مي دهند. (گر چه وقتي انتساب float به integer صورت مي گيرد کامپايلر اخطار مي دهد).
    در Object Pascalو Javaيک مقدار نوع Boolean وInteger نيست و نوع کارکتر نوع مختلف و ناسازگار ديگري است.Java در زمان اجرا يک بايت کد (byte-code ) را اجرا مي کند. اين به اين معني نيست که زبان کنترل نوع در زمان کامپايل را از دست مي دهد و بالعکس.
    کنترل نوع در اين زبان کامل تر است. در عوض زبان هاي oop ديگر مانند small talkو CLOS تمايل دارند تا اغلب کنترل نوع را در زمان اجرا انجام دهند.
    Hybrid vs. Pure OOP Languages (زبان هاي شي گراي Hybrid در مقابل pure)
    تفاوت ميان زبان هاي شي گراي pure ,Hybrid در اين است که زبان هاي شي گرا فقط يک نوع مدل برنامه نويسي را مي پذيرند از آنجا زبان هاي pure به زبان هايي اطلاق مي شودکه شما مي توا نيد در آنها کلاس ها و متدها را تعريف کنيد اما نمي توانيد از procedure و function هاي قديمي و داده محلي استفاده کنيد و در مقابل زبان هاي pure، زبان هاي Hybridبه برنامه نويس اين امکان را مي دهند تا از پارامترهاي زبان هاي قديمي هم استفاده کنند. درميان اين سه زبان فقط جاوا يک زبان pureاست (مانند Eiffel , Smalltalk) که در ابتدا اين ايده مثبت به نظر مي رسد. به هر حال شما مي توانيد به استفاده از روش هاي استاتيک و داده استاتيک که تفاوتي با استفاده از داده ها و تابع ها دارد خاتمه دهيد. علاوه بر آن syntaxزبان هم پيچيده تر مي شود .به عقيده ي من زبان هاي pure براي تازه وارد هاي oop منفعت دارد. زيرا برنامه نويسان مجبور به بهره وري و يادگيري مدل برنامه نويسي oop مي شوند. C++‎و object Pascalدو نمونه از زبان هاي Hybrid هستند که به برنامه نويس ها اجازه مي دهد تا از زبان cقديمي (سنتي)و رويکرد هاي برنامه نويسي پاسکال بهره مند شوند. توجه کنيد small talk همين مفهوم را گسترش داد که در سطح تعريف فقط شي را داشته با شيم. به عنوان مثال اشيايي همچون نوع هايي داده از پيش تعريف شده مانند character ,integer و ساختار هاي زبان (مثلا حلقه ). اين عمل از لحاظ تئوريک جالب است اما تقريباً تا حدود زيادي کارايي کاهش مي يابد.
    Plain Object Model vs. Object Reference Model (Object Reference Model در مقابل Model Plain Object)
    سومين پارامتر متمايز کنند? زبان هاي OOP مدل شيء شان است. برخي زبان هاي قديمي OOP به برنامه نويسان اين اجازه را مي دهند که شيء هايي را در Stack، حافظ? پويا و استاتيک ايجاد کنند. در اين زبان ها يک متغير نوع داده با يک شيء در حافظه مطابقت دارد. C++‎ با اين روش کار مي کند. به نظر مي رسيد که بعداً گرايشي به بهره وري از يک مدل مختلف که مدل مرجع شيء نام گرفت وجود داشته باشد. در اين مدل به هر شيء به صورت پويا، Heap اختصاص داده مي شود و عملاً متغيري از يک نوع کلاس، مرجعي براي شيء در حافظه است.( از لحاظ تکنيکي شبيه يک اشاره گر است). Java و Object Pascal هر دو اين مدل مرجع را مي پذيرند. زماني که با اين مورد برخورد مي کنيم بدان معني است که شما بايد حافظه اي براي شي اختصاص دهيد.
 
    Classes, Objects, References
    ويژگي: از آنجايي که ما دربار? زبان OOP بحث مي کنيم بعد از اين مقدمه نکت? آغازين بحث در خصوص کلاس ها و اشياء مي باشد. اميدوارم که همگان به روشني اختلاف بين اين دو واژه را درک کنند. به طور مختصر اين کلاس يک نوع داده است و يک شيء يک نمونه از يک نوع کلاس است. حالا چگونه مي توانيم از اين اشياء در زبان با استفاده از مدل هاي مختلف شي استفاده کنيم؟
    C++‎: اگر در C++‎، ما يک کلاس MyClass با متد MyMethod داشته باشيم پس مي توانيم بنويسيم:
    MyClass Obj;
    Obj.MyMethod();
    و به يک شيء از کلاس MyClass که Object ناميده مي شود دست مي يابيم. معمولاً حافظه مورد نياز براي اين شيء در حافظه تعبيه شده و شما مي توانيد براي استفاده از اين شي از خط دوم بالا آغاز کنيد.
    Java: در جاوا يک دستورالعمل مشابه تنها فضاي حافظه براي دسترسي و ادار? شيء را اختصاص مي دهد نه خود شيء را.
    MyClass Obj;
    Obj = new MyClass();
    Obj.MyMethod()
    پيش از اينکه از شيء استفاده کنيم بايد کلاس جديدي را فراخواني کنيد تا حافظه اي را براي شيء اختصاص دهد. البته در صورت امکان شيء را تعريف کنيد و آنرا با يک عبارت تنها مقداردهي اوليه کنيد تا از دستکاري اشيايي که مقدار دهي اوليه نشدند اجتناب کنيد.
 
    MyClass Obj = new MyClass();
    Obj.MyMethod();
 
    Object Pascal: پاسکال شي گرا رويکرد مشابهي دارد امّا به عبارات متفاوتي براي تعريف و مقدار دهي اوليه نياز دارد.
 
    var
    Obj: MyClass;
    begin
    Obj := MyClass.Create;
    Obj.MyMethod;
 
    تذکر: هنگامي که برنامه نويس احساس مي کند که مدل مرجع شيء نياز به کار بيشتري دارد. بايد تفکر کند که در C++‎ شما اغلب بايد از نشانگرها براي اشياء و ارجاع به اشياء استفاده کنيد. به طور مثال تنها با استفاده از نشانگرها و مرجع به چند درختي دست مي يابيم. در عوض مدل مرجع شي نشانگرها و پيش فرض ها را بنا مي سازد. در ماوراي آنها عملکرد بهينه دارد. بويژه در جاوا رسماً هيچ نشانگري وجود ندارد. اما نشانگرها همه جا هستند. تنها برنامه نويس ها هيچ کنترل مستقيمي روي آنها ندارند به گونه اي که آنها به دلايل امنيتي نمي توانند به محل هاي حافظ? موقت دسترسي يابند.
 
   : Recycle Bin
 
    ويژگي ها: هنگامي که شي را ايجاد کرديد و از آن استفاده کرديد سپس براي جلوگيري از اشغال حافظه نياز به تخريب آن داريد .
 
    C++‎: در برنامه C++‎ تخريب اشيايي که در پشته تخصيص داده شده اند نسبتاً سهل و آسان است. از سوي ديگر در دست گرفتن تخريب اشيايي که به صورت پويا تخصيص داده شده اند اغلب عملي پيچيده است. اينجا راه حل هاي بسياري وجود دارند که 'شمارش مرجع' و 'نشانگرهاي هوشمند' را شامل مي شوند امّا اين عمل فراتر از يک عمليات ساده است اولين اثري که C++‎ بر روي برنامه نويسان دارد آنست که بهره وري از يک مدل شيء مرجع شرايط را حتي بدتر مي سازد.
 
    Java: از آنجايي که virtual machine (ماشين مجازي) الگوريتمgarbage collection را در background اجرا مي کند قطعاً اين موضوع براي Java مسئله اي نيست. اين چيزي است که برنامه نويسان آزادانه به آن دست مي يابند. امّا چيزهايي ممکن است عملکرد برنامه ها را تحت تأثير قرار دهد ننوشتن destructor ها (آشغالدان ها) ممکن است منجر به ايجاد errorهاي منطقي در کد Clean up شود.
 
    Object Pascal: در عوض پاسکال شي گرا هيچ مکانيزم جمع آوري زباله ندارد. به هر حال Componentهاي دلفي از ايد? owner object پشتيباني مي کند. مالک مسئول تخريب تمامي اشياء مخصوص خودش است. اين عملکرد ادار? تخريب اشياء را بسيار ساده و آسان مي کند.
 
    Defining New Classes (تعريف کلاس جديد)
 
    ويژگي: حالا که ما دريافتيم چگونه اشياء کلاس هاي موجود را ايجاد کنيم مي توانيم براي تعريف کلاس هاي جديد تمرکز کنيم در يک تعريف ساده يک کلاس مجموع? روش هايي جهت انجام عمليات در برخي داده هاي محلي است.
 
    C++‎:
    يک مثال ساده از تعريف کلاس ها در C++‎:
    class Date {
    private:
    int dd;
    int mm;
    int yy;
    public:
    void Init (int d, int m, int y);
    int Day ();
    int Month ();
    int Year ();};
 
 
    و تعريف يک متد به شکل زير است:
    void Date::Init (int d, int m, int y)
    {
    dd = d;
    mm = m;
    yy = y;
    }
 
    Java:
    جاوا يک Syntax ساده تر نسبت به C++‎ دارد:
 
    class Date {
    int dd = 1;
    int mm = 1;
    int yy = 1;
    public void Init (int d, int m, int y) {
    dd = d; mm = m; yy = y; }
    public int Day () { return dd; }
    public int Month () { return mm; }
    public int Year () { return yy; }
    }
 
    مهمترين اختلاف ميان C++‎ و Java آنست که کد هر متد مستقيماً هنگامي که آن دستورالعمل اعلان مي شود نوشته مي شود. ( بدون ساختن تابع inline function به عنوان تابع happens در C++‎). و آنکه مي توانيم به اجزاي اوليه يک کلاس مقدار دهي اوليه کنيم .اگر شما موفق به انجام عمليات نشديد بنابراين جاوا با استفاده از يک مقدار پيش فرض به همه اجزا داده شما، مقدار اوليه مي دهد
: ((سازنده ها  Constructors
    ويژگي: کلاس بالا بسيار ساده است. اولين چيزي که ما مي توانيم بيافزاييم يک سازنده است که تکنيک خوبي براي حل مشکل مقدار دهي اوليه اشياء است.
 
    C++‎: در C++‎مانند جاوا ، سازنده ها يک نام مشابه با کلاس دارند .اگر شما يک سازنده تعريف نکنيد، کامپايلر يک سازنده پيش فرض را ترکيب مي کند (تطبيق مي دهد) و به کلاس مي افزايد. در هر دوي اين زبانها شما مي توانيد چندين سازنده داشته باشيد. در هر دوي زبانها امکان overload روي سازنده ها وجود دارد.
 
    Java: در جاوا همه چيز همانند c عمل مي کند گر چه سازنده ها ، مقدار اوليه ناميده مي شوند.حقيقت آنست که جاوا براي ايجاد اشياء هنگامي که شما کدي را در يک سازنده مي نويسيد شي جديد الايجاد را به سادگي مقدار دهي اوليه مي کند. ( همچنين چندين رويدادهايي نيز در object Pascal حادث مي شود.)
    Object Pascal: در Object Pascal از کلمه کليدي Constructor استفاده مي کنيم. در اين زبان هيچ روش Over loading يافت نمي شود. اما از آنجايي که سازنده ها نام هاي رايجي دارند شما مي توانيد سازنده هاي بسياري با نام هاي مختلف تهيه کنيد. در اين زبان هر کلاس سازنده create پيش فرض دارد. گرچه شما آن را با يک سازنده ايي که نام يکسان دارد و حتي پارامتر ها ي آن متفاوت هستند، سرانجام باطل مي کنيد.
 
    :Destructor and finalize (مخرب ها و پايان دهنده ها)
 
    ويژگي: يک مخرب نقش متفاوتي نسبت به سازنده دارد و کلاً هنگامي فرا خوانده مي شود که يک شي تخريب شود . گر چه اکثر کلاسها نياز به يک سازنده دارند . تنها مقدار اندکي از آنها نياز به يک مخرب دارند . مخرب بايد منابع اختصاص داده شده به وسيله سازنده را آزاد کند ( يا با روش هاي ديگري در طول عمر اشياء ) اين منابع شامل حافظه فايل ها، جداول، پايگاه داده و غيره مي شود.
 
    C++‎: مخرب هاي C++‎ به صورت خودکار هنگامي فرا خوانده مي شوند که يک شي از حوزه خارج مي شود يا بخواهيد به صورت پويا شي خاص (تخصيص داده شده) را پاک کنيد. هر کلاس تنها مي تواند يک مخرب داشته باشد.
 
    Object Pascal: مخرب هاي Object Pascal شبيه مخرب هاي C++‎ است، Object Pascal از يک مخرب مجازي استاندارد بهره مي برند که destroy ناميده مي شود. استاندارد اين مخرب را متد free ناميدند. همه اشياء پويا هستند بنابراين شما براي خطاب قرار دادن free براي هر شي که ايجاد مي کنيد پشتيباني مي شويد. گر چه هر مالکي مسئول تخريب خودش است. در اين تئوري شما مي توانيد چندين مخرب را بيان کنيد که اين حس را ايجاد مي کند زيرا شما با کد خودتان مخرب ها را فراخواني مي کنيد هيچ چيز خودکاري وجود ندارد .
 
    Java: جاوا مخرب ندارد. اشياء بدون مراجع توسط الگوريتم garbage collection تخريب مي شوند، که مانند يک فرمان Background (پيش زمينه) عمل مي کنند. اولين مخربي که garbage collection را فراخواني مي کند متد finalize()ناميده ميشود.
    به هر حال هيچ تضميني وجود ندارد که اين متد واقعاً آنگونه که ناميده شد عمل کند.( حداقل در Java 1.0). به همين علت اگر به منابع آزاد نياز داريد بايد روش رايجي را بر آن بيافزاييد. و اطمينان حاصل کنيد که آن برنامه فراخواني شده است.
 
    Class Encapsulation (Private and Public)
 
    ويژگي: المنت رايج از اين زبان وجود سه تصريح کننده جهت دسترسي به سطوح مختلف کپسوله سازي کلاس هستند که عبارتند از: public, protected و private. Public براي هر کلاسي قابل دسترسي است. protected براي کلاس هاي مشتق شده قابل دسترسي است. و private يعني غير قابل دسترسي .بهر حال جزييات متفاوت هستند.
 
    C++‎: در C++‎ شما مي توانيد از friend keyword در کوتاه ترين مدت به encapsulation دسترسي پيدا کنيد. ( دسترسي پيش فرض براي کلاس ازprivate و براي يک strut، Public است .)
 
    Object Pascal: در Object Pascal ، publicوprotected تنها براي کلاسهايي در واحد هاي مختلف موثر ند. يک کلاس دوستي از ديگر کلاسهايي است که در همان unit تعريف شده. ( يا فايل کد منبع)
    Delphi دو تصريح گر بيشتري براي دسترسي دارد. Published و automated.
    Published اطلاعات RTT را براي هر عنصر automated توليد مي کند. يک رابط اتوماتيک OLE است.
 
    Java: در جاوا، تفاوت نحوي آن است که براي هر جزء کلاس، تصريح گرها تکرار شده اند اختلاف عمده تر آن است که پيش فرض در جاوا ، friendly است ، که به عنصري اشاره مي کند که توسط ديگر کلاس هاي همان بسته قابل دسترس است. (يا فايل کد منبع همانند آن چيزي که درObject Pascal رخ مي دهد.) کلمه ي کليدي protected به دسترسي به زيرگروه ها اشاره مي کند. اما به ديگر کلاس هاي همان بسته نيز اشاره مي کند. هنگامي که ترکيب هاي private با protected منطبق مي شوند.
 
    Conclusion: Languages and Programming Environments
   : نتيجه گيري: زبان ها و محيط هاي برنامه نويسي
 
    هما نگونه که در بالا ذکر شد، گر چه سعي ام بر اين بوده که تنها اين زبان ها را به واسطه مقايسه ساختارهاي املايي و معنايي آزمايش کنيم مهم آنست که آنها را در جايگاه خودش درست و صحيح درک کنيد. اين زبان ها جهت حل مشکلات مختلف با روش هاي گوناگون بکار گرفته شده اند. و در سطحي وسيع با محيط هاي برنامه نويسي گوناگون مورد استفاده قرار گرفتند گر چه هر دو اين زبان ها و محيط شان ساختار هاي يکديگر را کپي مي کنند ولي با نيازهاي مختلف در ذهن تشکيل شده اند. و اين چيزي است که مي توانيد به هنگام کمپينگ ساختارهايشان به عينه ببينيد.هدفC++‎ توانمندي و کنترل در راستاي پيچيدگي است. هدف دلفي برنامه نويسي ويژوال آسان است بدون از دست دادن توانمندي وافر و ارتباط قوي با ويندوزها . هدف جاوا قابل حمل بودن است حتي با از دست دادن مقداري از سرعت و برنامه هاي توزيع شده يا محتويات قابل اجراي وب. چيزي که مي تواند موفقيت اين سه زبان را تعيين کنند ساختارهايي نيستند که من در اين مقاله پوشش دادم. وضع مالي کنترل سيستم عمليات مايکروسافت ، ترويج sun در شبکه جهاني اينترنت (حقيقتي که بوضوح به عنوان ضد مايکروسافت توسط عده اي رواج يافت). فاکتورهايي هستند که انتخابات شما را بيشتر ازعناصرتکنيکي تحت تا ثير قرار مي دهند به فرض مثال يک زبان خوب مانند Eiffel. از آنجايي هر دو زبان جاوا و object Pascal الهامات بيشتري گرفتم هرگز به هيچ اشتراک فروش واقعي نرسيدند گرچه اين عمل در تمامي جهان ترويج يافتند . تنها به فکر بسپاريد که "trendy" لغتي رايج در دنياي کامپيوتر شده که پيشتر نبوده . هنگامي که کاربرها دوست دارند تا اين مدل سال را داشته باشند برنامه نويسان به کار با آخرين زبان برنامه نويسي عشق مي ورزند و مي خواهند اولين کسي باشند که آن را ايجاد مي کند مي توانيم بگوييم که "جاوا آخرين زبان oop نيست" و افرادي در سالهاي آتي با زباني جديد خواهند آمد.همه افراد با اين زبان جديد همراه مي شوند با اين تصور که از اين جريان عقب نمانند. و فراموش کنند که اکثر برنامه نويسان در جهان هنوز بر روي کيبوردهايشان عبارت"کوبول خوب را"مي نويسند.
 
مقايسه خواص عمومي يک کلاس در C++ و C#
 
قبل از بررسي تفاوت بين کلاسها بين C++ و C# ابتدا خاصيت هاي عمومي يک کلاس را بررسي کرده سپس به بررسي تفاوت بين اين دو زبان قدرتمند خواهيم پرداخت.
 
تعريف. کلاس در حالت ساده مجموعه اي از خواص(attributes) و روش ها (methodes) است که در رابطه با هم هدف مشترکي را دنبال مي کنند و خدماتي را ارائه مي کنند. البته اين تعريف در حد يک تعريف علمي مي باشد ولي ذکر اين نکته ضروري است که اکثر تعاريف در شي گرايي در طبيعت وجود دارد و در ساده ترين حالت براي تعريف يک کلاس مي توان از تعريف انسان استفاده کرد که  اين بحث در اين مقاله نمي گنجد. در هر حال ما به تعريف فوق اکتفا کرده و بحث را ادامه مي دهيم.
 
خواص ها و روش ها که در تعريف کلاس ارائه شد مي تواند نحوه دسترسي متفاوتي مانند public و private و protected داشته باشد که براي برنامه نويسان C++ نيازي به توضيح نيست.
 
تفاوت در تعريف يک کلاس:
 
چنانچه در مقاله لايه ها در C# نيز اشاره شد يک کلاس در يک برنامه C# در داخل يک لايه تعريف خواهد شد(اجباري نيست). تعريف يک کلاس در C# تفاوتهايي با C++ دارد که سعي خواهيم کرد اين تفاوت ها را با چند مثال توضيح دهيم.
 
فرض کنيد کلاس زير در C++ تعريف شده است که اين کلاس را به يک کلاس C# تبديل خواهيم کرد.
 
      // Test.h
 
      class CTest{
 
            private:
 
                  int   m_at1;
 
                  int   f1();
 
            public:
 
                  float m_at2;
 
                  int   f2();
 
                        CTest();
 
                        ~CTest();
 
      };
 
    
 
      // Test.cpp
 
      #include “test.h”
 
      CTest::CTest(){
 
            m_at1 = 0;
 
            m_at2 = 0.0;
 
      }
 
      CTest::~CTest(){
 
            // cout
 
      }
 
      int CTest::f1(){
 
                  return m_at1;
 
      }
 
      int CTest::f2(){
 
            return m_at1+(int)m_at2;
 
      }
 
  
 
تفاوت اول:
 
بر خلاف C++ در C# تعريف و نحوه عملکرد يک تابع يا Method در خود تعريف کلاس قرار داده مي شود. در C++ غالبا تعريف کلاس در فايل .h و بدنه توابع در فايل .cpp قرار مي گرفت. البته ذکر اين نکته ضروري است که مي توان همين عمل را در .h نيز قرار داد ولي در يک برنامه بزرگ اين عمل کنترل برنامه را از دست برنامه نويس خارج کرده و همچنين مشکلات ديگري را براي برنامه نويسان ايجاد مي کند که برنامه نويسان C++ با اين مشکلات آشنا هستند.
 
تفاوت دوم:
 
بر خلاف C++ در C# يک دسته از متغييرها را نمي توان بصورت public يا private و … تعريف کرد و براي هر متغيير بايد نحوه دسترسي به آن نيز مشخص شود.
 
تفاوت سوم:
 
بر خلاف C++ در C# تابع destructor وجود ندارد و خود C# مسئول از بين بردن يک شي مي باشد که اين از بين بردن با توجه به محدوده تعريف اين شي انجام مي شود. البته تعريف destructor وجود دارد ولي نمي توان destructor را فراخواني کرد . در C++ فراخواني Destructor با استفاده از عملگر delete قابل انجام بود ولي چون C# مديريت object ها را خود بعهده مي گيرد شي ايجاد شده نميتواند توسط برنامه خراب شود. اين مطلب در مقالات بعدي مورد بررسي قرار خواهد گرفت.
 
با توجه به تفاوتهاي ذکر شده مي توان اين کلاس را به صورت زير براي يک کلاس C# ارائه کرد.
 
      // Test.cs
 
      using System;
 
      namespace NS
 
      {
 
            publicclass CTest
 
            {
 
                  privateint   m_at1;
 
                  public  float m_at2;
 
                  privateint   f1()
 
                  {
 
                              return m_at1;
 
                  }
 
                  public  int   f2()
 
                  {
 
                              return m_at1+(int)m_at2;
 
                  }
 
                  public CTest()
 
                  {
 
                        m_at1 = 0;
 
                        m_at2 = 0.0f;
 
                  }
 
                  ~Test()
 
                  {
 
                        // Console.WriteLine(“destructor call”);
 
                  }
 
            }
 
      }
 
ايجاد يک کلاس در ++ و #
در موقع استفاده از يک کلاس اگر از default constructor براي ايجاد يک کلاس استفاده مي شود در C# بايد constructor بصورت void فراخواني شود ( مانند توابع void معمولي)
 
به مثال زير دقت کنيد.
 
            // C++ code
 
            CTest            *a;
 
            a = new CTest;
 
            // C# Code
 
            CTest             a;
 
            a = new CTest();
 
 ذکر اين نکته ضروري است که در C# وقتي کلاسي تعريف مي شود در واقع اشاره گر به آن کلاس معرفي مي شود بنابراين با تعريف CTest    a کلاسي از CTest ايجاد نمي شود و فقط يک اشاره گر از CTest تعريف مي شود و براي ايجاد يک کلاس استفاده از عملگر new اجباري است.
 
ولي در C++  تعريف CTest     a به منزله ايجاد يک کلاس و فراخواني Default Constructor مي باشد.
 
 
 
همانطور که از نام آنها پيداست از اين عملگرها براي مقايسه استفاده مي گردد، و به طور کل در شرط ها و حلقه ها جهت کنترل کردن مورد يا مواردي (که در آنها از عمل مقايسه کمک گرفته مي شود) استفاده مي گردد.
 
در بسياري از موارد اتفاق مي افتد که براي انجام شدن دستور يا دستوراتي نياز داريم که شرايط خاصي وجود داشته باشد، مثلا مقايسه اي صورت پذيرد و يا چيزي با يک شرايط خاص مقايسه شود در اينصورت استفاده از اين عملگرها معني پيدا مي کند:
 
 
عملگر
 
از اين عملگر براي مقايسه ي کوچکتري به شکل « عملوند سمت راست a > b استفاده مي شود و در آن اگر عملوند سمت راست کوچکتر از عملوند سمت چپ باشد جواب عبارت، درست (True) و در غير اينصورت جواب، نادرست (False) مي باشد.
 
 
عملگر =
 
اين عملگر نيز همانند عملگر بالايي مي باشد با اين تفاوت که اگر عملوند يا عبارت سمت راست مساوي با عملوند يا عبارت سمت چپ باشد نيز جواب، درست خواهد بود.
 
 
عملگر >
 
اين عملگر نيز در مقايسه ي عملوند ها يا عبارت ها، و براي مقايسه ي بزرگتري استفاده مي گردد اگر عملوند يا عبارت سمت راست بزرگتر از عملوند يا عبارت سمت چپ باشد جواب، درست در غير اينصورت جواب، نادرست مي باشد.
 
 
عملگر =>
 
همانند عملگر بالايي مي باشد با اين تفاوت که اگر هر دو عملوند يا عبارت با هم مساوي هم باشند جواب، درست مي باشد و در صورتي جواب، نادرست است که عملوند يا عبارت سمت راست کوچکتر از عملوند يا عبارت سمت چپ باشد.
 
 
عملگر ==
 
اين عملگر براي مقايسه ي تساوي بين دو عملوند و يا عبارت استفاده مي گردد، اگر هر دو عملوند يا عبارت با هم مساوي باشند آنگاه جواب، درست؛ و در غير اينصورت جواب، نادرست مي باشد.
 
 
نکته: در استفاده از اين عملگر بايد کمال دقت را نمود، به دليل اينکه بسياري از برنامه نويسان مبتدي زبان هاي بالا به جاي استفاده از == (دو علامت مساوي همزمان) که براي مقايسه ي تساوي دو عبارت به کار مي رود از علامت = (يک علامت مساوي) استفاده مي نمايند که در اين زبانها براي انتساب مقادير کاربرد دارد.(بعدا در همين سايت به عملگر انتساب خواهيم پرداخت)
 
 
عملگر =!
 
اين عملگر درست عکس عملگر قبل (تساوي) عمل مي نمايد يعني اگر عملوند يا عبارت ها با هم متفاوت باشند جواب، درست؛ در غير اينصورت جواب، نادرست مي باشد.
 
 
تذکر: لازم به ذکر است که عملگرهاي بالا فقط در مقايسه کردن عبارات و متغيرهاي عددي و يا نويسه اي (کاراکتري) قابل استفاده هستند و نمي توان از آنها براي مقايسه کردن رشته ها استفاده نمود.
 
 
مثالهايي در مورد عملگرهاي بالايي:
 
A = 13, B = 4, C = 23, D = 17, E = 4
 
نکته: در نام هاي بالا از حروف بزرگ استفاده شده است که بيانگر اين است که مي تواند به جاي آنها يک عبارت باشد که مقادير فوق را توليد کرده است.
 
فرض: اگر در مثالهاي زير هر کدام از متغيرها مقادير مذکور  را داشته باشند؛ آنگاه جواب هاي به دست آمده با يک علامت ? نمايش داده خواهد شد:
 
A
 
A
 
A
 
A
 
A
 
A
 
D > E ? False
 
D > C ? False
 
C > C ? False
 
C >= E ? True
 
C >= D ? True
 
D >= D ? True
 
A == B ? False
 
D == E ? False
 
E == B ? True
 
E == E ? True
 
A != C ? True
 
B != E ? False
 
C != D ? True
 
B != B ? False
 
 
 
 
 
 
 
عملگرهاي منطقي:
عباراتي که مقدار برگشتي آنها Boolean است را مي توان با اپراتورهاي منطقي AND ، OR ، XOR با هم ترکيب کرد .
براي AND کردن دو عبارت بايد از & يا && استفاده کرد . حاصل عبارت زماني درست خواهد بود که هر دو قسمت درست باشند ، در غير اينصورت حاصل عبارت نادرست خواهد شد . تفاوت اين دو عملگر در نحوه ارزيابي عبارت است . با عملگر& ، هر دو قسمت عبارت ارزيابي مي شوند . اما با عملگر && اگر سمت چپ عبارت نادرست باشد ، براي تمام عبارت مقدار False برگشت داده مي شود و سمت راست عبارت ارزيابي نخواهد شد .
براي OR کردن دو عبارت از | يا || استفاده مي شود . حاصل عبارت زماني درست خواهد بود که يکي يا هر دو قسمت آن درست باشند ، فقط وقتي عبارت نادرست است که هر دو قسمت آن نادرست باشند . با عملگر | هر دو قسمت عبارت ارزيابي مي شوند . ولي عملگر || اگر قسمت اول درست باشد ، براي تمام عبارت مقدار True برگشت داده مي شود و سمت راست عبارت فقط ارزيابي نخواهد شد .
هنگام XOR کردن دو عبارت ( که عملگر آن ^ است ) فقط زماني حاصل عبارت درست خواهد بود که در قسمت آن ارزش متضاد داشته باشد و اگر هر دو قسمت عبارت هم ارزش باشد ، حاصل عبارت نادرست خواهد شد . در کل ، عملگرهاي || و && براي عمليات منطقي و عملگرهاي | ، & و ^ براي عمليات منطقي بيت گرا (Bitwise) مورد استفاده قرار مي گيرند .
عملگر NOT (!) فقط روي يک آرگومان عمل کرده و ارزش آن را معکوس مي کند . مثلاً ، اگر x درست باشد ، X ! نادرست خواهد بود .
بر خلاف C++ ، متغيرهاي Boolean فقط مقادير True يا False مي گيرند و نمي توانند عدد بگيرند .
 
 
عملگرهاي بيت گرا:
عملگرهاي بيت گرا روي بيت هاي عملوند ها عمل مي کنند . چون عمليات بيت گرا جزء مباحث پيشرفته برنامه نويسي است در جدول زير اين عملگرها را مشاهده مي کنيد :
تفاوتها:
جاوا به زبان (++C نتيجه مستقيم زبان C ) وابسته است . بسياري از خصلتهايجاوا بطور مستقيم از اين دو زبان گرفته شده است . دستور زبانجاوا منتج ازدستور زبان C است . بسياري از جنبه هاي oop زبان جاوا ازC++ بعاريت گرفته شدهاست . در حقيقت بسياري از خصلتهاي زبان جاوا از اين دو زبانمشتق شده يا باآنها مرتبط است . علاوه بر اين ، توليد جاوا بطور عميقي متاثراز روال پالايش وتطبيقي است كه طي سه دهه گذشته براي زبانهاي برنامه نويسيموجود پيش آمده است .
جاوا يک زبان بسيار ساده است چون شما را وادار نمي کند تا در محيط جديد ( و نا آشنايي ) کار کنيد و اين براي کساني که اطلاعات فني ناچيزي درباره کامپيوتر دارند بسيار مهم است . ساختار زبان جاوا در نگاه اول بسيار شبيه C و ++C است و اين به هيچ وجه تصادفي نيست . C زباني است ساخت يافته و ++C زبانيست شيء گرا و مهمتر از همه قسمت اعظم برنامه نويسان دنيا از آنها استفاده مي کنند از سوي ديگر اين شباهت حرکت به طرف جاوا را براي اين قبيل افراد ساده خواهد کرد. بنابراين طراحان جاوا براي اجتناب از دوباره کاري از زبانهاي C و ++C بعنوان مدل استفاده کردند .
جاوا با دور انداختن اشاره گرها و بر دوش کشيدن بار مديريت حافظه ، برنامه نويسان C و++C را براي هميشه از اين کابوس ها رهايي بخشيده است . علاه بر آن چون جاوا زباني براي اينترنت است، از ايمني و حفاظت ذاتي بالايي برخوردار است . طراحان جاوا از ابتدا يک محيط برنامه نويسي امن را مد نظر داشته اند . مسئله حفاظت سيستم ها رابطه تنگاتنگي با اشاره گرها دارد . اکثر مهاجمان براي ورود غير قانوني به سيستم هاي ديگران از اين اشاره گرها استفاده مي کنند و جاوا با حذف اشاره گرها اين راه را سد کرده است . جاوا مکانيزم هاي حفاظتي ديگري هم دارد.
جاوا شباهت‌هايي به سي‌پلاس‌پلاس دارد، ولي قابليت انتقال آن بهتر است و استفاده از آن ساده تر از ++C است. همچنين مديريت حافظه نيز توسط خود ماشين مجازي جاوا انجام مي‌شود. طراحي اين زبان به گونه ايست که داراي اطمينان بسياري بوده و وابسته به سيستم عامل خاصي نيست. و دليل اين موضوع اين است که جاوا يک ماشين مجازي در سيستم شما راه مي‌اندازد و برنامه‌ها را در آن ماشين مجازي اجرا مي‌کند. اين ماشين مجازي «ماشين مجازي جاوا» يا به اختصار JVM ناميده مي‌شود. البته راه انداختن يک ماشين مجازي باعث دو مشکل مي‌شود. هنگامي که نرم‌افزار شما در يک ماشين مجازي اجرا مي‌شود سرعت کمتري خواهد داشت، همچنين شما نياز داريد قبل از اجراي برنامه‌هاي جاوا يکبار سيستم مجازي جاوا را که حجم نسبتاً بالايي دارد، از اينترنت بارگذاري و يا از جاي ديگري تهيه و نصب کنيد ولي مزيت آن عدم وابستگي به سيستم عامل مقصد است.
مهم‌ترين ايرادي که برنامه نويسان ساير زبان‌ها به زبان جاوا مي گيرند سرعت اجرايي بسيار پايين جاوا است. يک برنامه جاوا به صورت بايتکد مي باشد و بايد در ماشين مجازي جاوا اجرا گردد. به همين دليل سرعت اجراي پاييني را در مقابل زبان‌هاي قدرتمندي همچون ++C دارد. به صورت ديگر يک برنامه ++C به طور متوسط تا 10 برابر سريعتر از برنامه مشابه جاوا اجرا مي‌گردد. جاوا علي رقم شيء گرا بودن در بخشي از قسمت‌ها براي ايجاد انعطاف بيشتر يا بازاريابي بهتر برخي اصول شي گرايي را ناديده گرفته است. از جمله اين قسمت‌ها قابليت بازتابش Reflection مي باشد. هدف اصلي بازتابش اين است که استفاده مجدد از کدها و گسترش کدهاي موجود و مهم‌تر از همه نوشتن برنامه‌هاي الحاقي آسان گردد ولي اين مهم با زير پا گذاشتن بعضي اصول ممکن شده است. براي نمونه با کمک بازتابش به راحتي مي‌توان متدهاي خصوصي ديگر کلاس‌ها را فراخواني کرد!
زبان جاوا در مقابل زباني مثل ++C ساده تر و يادگيري ان آسانتر است. اين آسانتر بودن به سادگي به دست نيامده است بلکه با حذف بسياري از موارد که باعث قدرتمند تر بودن زبان ++C بوده‌اند ايجاد شده است. مهم‌ترين اين موارد اشاره گرها و وراثت چندگانه بوده‌اند که در زبان جاوا يافت نمي شوند. از آنجايي که جاوا زباني با عدم وابستگي به بستر مي باشد پس استفاده از توابع سيستم عامل را در برنامه نمي پذيرد. به همين صورت نمي‌توان از واسط‌هاي برنامه نويسي غير از جاوا در آن استفاده نمود.
جاوا از وراثت منفرد Single استفاده مي کند . وراثت منفرد يعني هر کلاس جاوا مي تواند فقط يک فوق کلاس داشته باشد . اما عکس آن درست نيست ، يعني يک کلاس مي تواند چندين زير کلاس داشته باشد .
در زبانهاي شيء گراي ديگر ، مانند ++C، يک کلاس مي تواند از چند فوق کلاس به ارث ببرد . به اين وضعيت وراثت چند گانه (Multiple) گفته مي شود . با وراثت چند گانه مي توان کلاس هاي فوق العاده جالبي بوجود آورد ، ولي کد نويسي آنها بسيار دشوار است .
ديديد که در جاوا هر کلاس فقط از يک فوق کلاس ارث مي برد . با اينکه وراثت منفرد برنامه نويسي را ساده تر مي کند ولي کمي محدودتر هم هست . مثلاً ، اگر در شاخه هاي مختلف يک سلسله مراتب متدهاي مشابهي داشته باشيد ، بايد تمام آنها را جداگانه پياده سازي کنيد . جاوا با استفاده از مفهومي بنام واسط مشکل به اشتراک گذاشتن متدها را حل کرده است .
واسط عبارت است از مجموعه ي نام چند متد ، بدون تعريف آنها ، که واسط آنها در اختيار کلاس استفاده کننده مي گذارد .
يک کلاس جاوا مي تواند در آن واحد از چندين واسط استفاده کند ، و با اين کار کلاس هاي بسيار متفاوت مي توانند رفتارهاي مشابهي داشته باشند .
در جاوا کلاس و واسط هاي مرتبط با هم در يک بسته گرد آورده مي شوند . کلاس هاي اصلي جاوا در بسته اي بنام java گرد آورده شده اند و فقط محتويات اين بسته است که در تمام نسخه هاي جاوا ثابت مي ماند . البته در بسته Java بسته هاي ديگري وجود دارند ولي بسته Java.lang به طور پيش فرض در اختيار تمام برنامه هاست . براي استفاده از بسته هاي ديگر بايد آنها را به طور صريح تعريف کرد . نام بسته ها و کلاس ها در هنگام تعريف با نقطه (.) از هم جدا مي شوند . مثلاً براي استفاده از کلاس Color که در بسته awt ( که خود در داخل بسته Java مي باشد ) قرار دارد ، بايد چنين نوشت.
 
 
 
منابع:
 
 
http://www.mypersianforum.com/showthread.php?t=76774&page=2#axzz2mofcTsoR
http://www.pl-group.blogfa.com/post/2
http://www.a00b.com/ProjectsDetail.aspx?ProjID=3347
http://pdfgozar.com/?p=1144