تحقیق دانشجویی

فهرست:

 

مقدمه...................................................................................................1

++C ..................................................................................................1

تاریخچه...........................................................................................1

ساختار برنامه ها...............................................................................1

جاوا .....................................................................................................1

تاريخچه...........................................................................................1

تکامل جاوا ......................................................................................2

ويژگيهاي زبان جاوا .............................................................................3

....................................................................4C++ مقایسه اجمالی جاوا و

شي ئ گرایی ........................................................................................6

دلایل استفاده ازشي ئ گرایی..................................................................7

شیئ گرایی و طبیعت ..............................................................................7

تاریخچه زبان های شیئ گرا.......................................................................7

بدون شیئ گرا .......................................................................................7

Abstraction چیست؟...............................................................................8

سهاصل oop .........................................................................................9

كپسول سازي encapsulation ...................................................................9

آبجكت‌ها (Objects) ................................................................................10

وراثت Inheritance..............................................................................11

چند شكلي( polymorphism).................................................................15

مقایسه اصل شي گرايي در ++C و جاوا..................................................17

مقایسه كپسولسازي در جاوا و C++ ....................................................19

مقایسه چند شكلي در جاوا و C++ ......................................................20

مقایسه وراثت (inheritance) در C++ و جاوا ...........................................21

وراثتدر جاوا ......................................................................................21

دسترسي به اعضائ ووراثت .................................................................23

استفاده از Final با وراثت ......................................................................29

وراثت در C++ ...................................................................................32

مقایسه جاوا و C++

از نظر وراثت منفرد و چندگانه ................................................................33

مقایسه کلاس ها در C++ و جاوا ..........................................................34

كلاسها در جاوا ..................................................................................34

تعریف یک کلاس در جاوا ......................................................................38

سازندگان Constructors ......................................................................39

سازندگان Constructorsدر جاوا .............................................................39

سازندگان پارامتردارشده (parameterized) .............................................41

وقتي كه سازندگان فراخواني مي شوند..................................................43

استفاده از كلاسهاي مجرد (abstract)....................................................44

انباشتن روشها…...........................................................................48

انباشتن سازندگان Overloading constructors.....................................52

جمع آوري زباله Garbage collection..................................................55

کلاس ها در C ++..........................................................................55

تخصص حافظه به صورت پویا با

اشاره گرهای new و delete در ++ c..............................................57

ايجاد يك زيركلاس در جاوا ...............................................................58

ایجاد سلسله مراتب کلاس .............................................................59

وراثت چگونه عمل میکند؟............................................................61

واسط ها (Interface) و

بسته­ها (Package) در جاوا .........................................................62

ايجاد يك سلسله مراتب

چند سطحي (Multilevel)............................................................63

استثنائات توكار جاوا ....................................................................67

كتابخانه هاي كلاس جاوا…...........................................................69

مدل نخ در جاوا ...........................................................................69

كشف كلاس رشته اي (string)......................................................73

جمع بندی(مزایای شیئ گرایی

در حوزه مهندسی نرم افزار).........................................................77

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

مقایسه زبان های برنامه نویسی جاوا و C++ از نظر شئ گرایی

 

 

 

مقدمه:

++C

++C يک زبان برنامه نويسی همه منظوره و سطح بالا است. ++C يک زبان چندرگه است که از برنامه نويسی رويه‌ای، تجريد داده‌ها و برنامه نويسی شئ گرا پشتيبانی می‌‌کند. ++C به همراه جد خود C از پرطرفدارترين زبانهای برنامه نويسی تجاری هستند.

زبان برنامه‌نویسی ++C یک زبان برنامه‌نویسی کامپیوتری سطح بالا و عمومی (با کاربرد های متنوع) می باشد. این زبان از تمام روش های مرسوم برنامه نویسی از قبیل برنامه‌نویسی شی‌گرا، برنامه نویسی ساخت یافته و برنامه نویسی پایه پشتیبانی می کند.

تاریخچه: زبان ++C در سال ۱۹۸۳ ميلادی در آزمایشگاه های Bel (Bell Labs) توسط Bjarne Stroustrup و بر مبنای زبان سی و برای بهبود C، با افزودن امکانات برنامه نویسی شی گرا ساخته شد.در آن زمان نام ++C ,سی با کلاسها`(c with classes) بود.اين زبان در سال 1998 توسط موسسه ANSI استاندارد شد. این زبان از حوالی سال ۱۹۹۰ میلادی یکی از پرکاربردترین زبان‌های برنامه نویسی به شمار می رود که برای برنامه نویسی سیستمی و برنامه نویسی ویژوال (بر مبنای GUI) در محیط های مختلف از قبیل ویندوز و لینوکس به صورت وسیع به کار می رود.

ساختار برنامه ها: ساختار برنامه ها در این زبان بدین صورت است که همانند زبان سی، هر برنامه بایستی یک تابع اصلی (main) به عنوان بدنه برنامه داشته باشد. هر برنامه معمولا از تعداد زیادی فایل تشکیل می شود که به هم الحاق می گردند (با دستور include) و به این فایل های الحاقی سرآیند (Header) می‌گوییم. فایل های الحاقی حاوی کد ها یا نسخه های اجرایی کلاس ها (مجموعه متغیر ها و توابع) می باشند که در بدنه اصلی برنامه از آنها استفاده می شود. معمولاً هر کلاس (که تعریف یک نوع داده ای با متد های مربوط به آن است) را در یک سرآیند می‌نویسند. هر سرآیند که معمولا تنها تعاریف (معرفی) کلاس را در خود دارد به همراه فایل های پیاده سازی به زبان ++C یا پیاده سازی های کامپایل شده (به صورت فایل اشیا مانند dll یا so یا ... ) می تواند به کار برده شود. به مجموعه های یکپارچه ای از کلاس های پیاده سازی شده (به صورت فایل های سرآیند با پیاده سازی های کد یا اشیای زبان ماشین) که برای برنامه نویسی به کار می روند، یک کتابخانه ++C گفته می شود و قدرت اصلی این زبان در امکان به کارگیری کتابخانه های آماده می باشد. کتابخانه های بزرگ ++C مانند STL، MFC، QT و ... مجموعه قدرتمندی برای تولید برنامه در این زبان ایجاد کرده اند.

جاوا

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

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

تکامل جاوا

جاوا هم مانند اکثر اختراعات مهم حاصل تلاش گروهی دانشمند پیشتاز است. اما نکته جالب درباره جاوا آن است که جاوا از ویرانه­های یک پروژه شکست­خورده سربرآورد. اگر پروژه Green که شرکت سان در سال 1991 آن را شروع کرد به موفقیت می­انجامید امروز نه سان دیگر یک شرکت کامپیوتری می­بود و نه جاوا تولید می­شد.

در سال 1991 ، شرکت سان میکروسیستمز در آغاز راه تبدیل شدن به بزرگترین تولید­کننده ایستگاههای کاری یونیکس بود و در طول فقط 5 سال درآمدش را از 210 میلیون دلار به 5/2 میلیارد دلار رسانده بود و بنظر می­رسد هیچ چیز نمی­تواند جلودار آن باشد. عامل عمده موفقیت سان کارهای پیشتازانه­اش در ایجاد شبکه­های باز بود و در این زمینه هیچ­کس به پای آن نمی­رسید.

مدیران سان به این فکر افتادند تا کاری کنند که این رشد برای مدتی طولانی ادامه یابد. یکی از زمینه­های موردعلاقه سان بازار و لوازم الکترونیکی بود، پروژه گرین بوجود آمد تا برای این بازار نرم­افزاری پیشرفته خلق کند. مهندسان سان توجه خود را به ميكروپروسسورهايي معطوف كردند كه داراي قابليت استفاده در اينگونه سيستمها باشند. اگر پروژه گرين مي­خواست موفق باشد بايد كاري مي­كرد تا سيستم مزبور بتواند به راحتي به بسترهاي سخت افزاري مختلف منتقل شود. براي اين منظور ابتدا از كامپايلر C++ استفاده شد ولي به زودي نارسايي­هاي C++ در اين زمينه خود را نشان دادند. مهندسان سان خيلي سريع دريافتند كه براي ادامه كار بايد چيزي جديد و قوي خلق كنند. در همين زمان بود كه James Gosling كار بر روي زبان جديد Oakرا شروع كرد. تقدير آن بود كه اين زبان جاوا ناميده شود، چون اداره ثبت نامهاي تجاري نام Oak را ردكرده بود.

به تدريج مهندسين يك دستگاه شبه PDA (Personal Digital Assistant) ساختند كه در آن از سيستم عامل، زبان برنامه­نويسي و واسط كاربر جاوا استفاده شده بود و با وجود ابتدايي بودن توانست توجه مديران سان را به خود جلب كند. بعدها گروهي كه در پروژه گرين كار كرده بودند شركت Java Soft را بنيان نهادند.

متاسفانه بخت با پروژه گرين يار نبود و بعد از چند شكست متوالي، سان آن را كنار گذاشت. در همين زمان بود كه عده­اي از محققان NCSA شركت نت اسكيپ را تاسيس كردند و اين اتفاقات با آتشي كه به سرعت دنيا را درمي­نورديد و WWW نام داشت همزمان شد. بنابراين اتفاقي نبود كه مهندسان پروژه گرين به سمت اينترنت و وب به عنوان بستر پروژه سان جلب شوند. چهار سال بعد پروژه گرين به بار نشست و جاوا تبديل به داغترين موضوع اينترنت شد. همه، از برنامه­نويسان و طراحان صفحات وب گرفته تا كاربران اينترنت مي­خواهند از جاوا استفاده كنند.

سان بلافاصله براي جاوا يك كاوشگر هم توليد كرد. اين اولين كاوشگري بود كه مي­توانست اپلت­هاي جاوا را اجرا كند و نام آن هم Hot Java بود.

ويژگيهاي زبان جاوا

جاوا ويژگيهاي متعددي دارد كه آن را منحصربفرد كرده است. جاوا هم كامپايلر دارد و هم اينترپرتر. كامپايلر برنامه­اي است كه متن برنامه را گرفته و در پايان يك فايل exe توليد مي­كند. بعد از كامپايل شدن يك برنامه، ديگر به وجود كامپايلر نيازي نيست و مي­توان برنامه exe را روي هر كامپيوتر سازگاري اجرا كرد. اما اينترپرتر هيچ برنامه exeاي توليد نمي­كند و برنامه را خط به خط اجرا مي­كند. براي اجراي برنامه حتما بايد اينترپرتر هم روي كامپيوتر موردنظر موجود باشد. هر كامپايلر فقط براي يك سيستم خاص(مانند اينتل، اپل يا آلفا) مي­تواند كد اجرايي توليد كند. اما كامپايلر جاوا كد اجرايي توليد نمي­كند و در عوض يك فايل بينابيني مي­سازد كه byte code نام دارد. byte code چيزي شبيه زبان اسمبلي است اما اين زبان مختص هيچ پروسسور خاصي نيست بلكه زبان اسمبلي يك ماشين ويژه به نام ماشين مجازي جاوا (Java Virtual Machine) است. در هنگام اجراي چنين برنامه­اي، اينترپرتر زمان اجراي جاوا (Java Runtime Interpreter) كه روي ماشين مجازي جاوا اجرا مي­شود، دستورات فايل بايت­كد را به دستورات قابل فهم براي پروسسوري كه روي آن اجرا مي­شود تبديل خواهد كرد. در شكل زير اين فرآيند نشان داده شده است:

برنامه­هاي كاربردي جاوا
اشياء جاوا
ماشين مجازي جاوا
مكينتاش	ويندوز يا OS2	يونيكس
سيستم عامل

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

با آنكه C و C++ زبانهاي بسيار قدرتمندي هستند اما اشكالاتي ذاتي دارند. عمده­ترين اين اشكالات در مديريت حافظه و اشاره­گرهاي C/C++ است. با آنكه جاوا به دليل محبوبيت فوق­العاده C++ ظاهري شبيه به آن دارد ولي در جاوا مديريت حافظه بطور خودكار انجام مي­شود و اشاره­گر هم اساسا در جاوا وجود ندارد. جاوا در زمينه بهينه­كردن استفاده از حافظه بسيار قوي است. يكي از ويژگيهاي جاوا پاكسازي خودكار حافظه از چيزهاي بي­مصرف است. (اين برنامه با نام آشغال جمع­كن Garbage Collectionشناخته مي­شود)

شي­گرايي در جاوا به غايت خود رسيده است. جاوا در استفاده از اشيا بسيار مقيد است. در C++ شما مي­توانيد از اشيا به موازات برنامه­نويسي به سبك قديم استفاده كنيد و اكثرا در پايان كار چنان وضعي بوجود مي­آيد كه مديريت آن نه با روشهاي برنامه­نويسي شي­گرا امكان دارد نه با روشهاي قديمي. جاوا ديگر به شما اجازه نمي­دهد تا خود را درچنين مخمصه­اي گرفتار كنيد.

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

Sun تصديق ميكند كه به طور قطع اين كلمات رشته هايي از واژه هاي متداول در زبان برنامه نويسي هستند ، اما حقيقت اين است كه اين واژه ها به طور ماهرانه اي خصوصيات اين زبان را شرح ميدهند .

 

مقایسه اجمالی جاوا و C++ :

جاوا یک زبان برنامه نویسی است که در اوایل دهه 90 توسط Java Soft ، بخش نرم افزاری شرکت Sun توسعه داده شد . هدف آن بود که جاوا زبانی ساده ، قوی و همه منظوره باشد . جاوا تمام جنبه های مثبت C و ++C را در خود دارد ، و آن چیزهایی که برنامه نویسان ++C از آن نفرت داشته اند ( مانند وراثت چند گانه ، تحریف اپراتورها و اشاره گرها ) را به کناری گذاشته است .

مهمترین ویژگیهای جاوا این است که اساساً شیء گرا است . اولین ادعای OOP توانایی استفاده مجدد از کد است : چیزی که ++C با تمام ادعاهایش هرگز نتوانست بدان دست یابد . اما در اولین قدم خواهید دید جاوا در این زمینه تا چه اندازه صحت دارد . تصورش را بکنید که با صرف کمی وقت بتوانید برنامه ای بنویسید که در سیستم های ویندوز ، یونیکس و مکینتاش براحتی اجرا شود . همین که یک شرکت نرم افزاری بتواند برای تمام پلاتفرم های موجود در آن واحد پروژه ای را تولید کند ( و مقادیر عظیمی پول صرفه جویی کند ) خود می تواند بهترین دلیل اقبال جاوا باشد و امروز دیگر همه ( و نه فقط شرکتهای نرم افزاری ) به سمت جاوا کشیده شده اند . با این ویژگی ( استقلال از پلاتفرم ) یک برنامه نویس می تواند برای سیستمی برنامه بنویسد که هرگز با آن کار نکرده است . این ویژگی اصلی ترین علت توفیق جاوا در اینترنت است . اینترنت شبکه پیچیده ای است از میلیونها کامپیوتر مختلف در سراسر دنیا ، و مقاومت در مقابل این وسوسه که بتواند برنامه ای بنویسد که روی تمام این سیستم های متفاوت و نا متجانس اجرا شود چندان ساده نیست . جاوا یک زبان بسیار ساده است چون شما را وادار نمی کند تا در محیط جدید ( و نا آشنایی ) کار کنید و این برای کسانی که اطلاعات فنی ناچیزی درباره کامپیوتر دارند بسیار مهم است . ساختار زبان جاوا در نگاه اول بسیار شبیه C و ++C است و این به هیچ وجه تصادفی نیست . C زبانی است ساخت یافته و ++C زبانیست شیء گرا و مهمتر از همه قسمت اعظم برنامه نویسان دنیا از آنها استفاده می کنند از سوی دیگر این شباهت حرکت به طرف جاوا را برای این قبیل افراد ساده خواهد کرد بنابراین طراحان جاوا برای اجتناب از دوباره کاری از زبانهای C و ++C بعنوان مدل استفاده کردند . جاوا با دور انداختن اشاره گرها و بر دوش کشیدن بار مدیریت حافظه ، برنامه نویسان C و++C را برای همیشه از این کابوس ها رهایی بخشیده است . علاه بر آن چون جاوا زبانی برای اینترنت است ، از ایمنی و حفاظت ذاتی بالایی برخوردار است . طراحان جاوا از ابتدا یک محیط برنامه نویسی امن را مد نظر داشته اند . مسئله حفاظت سیستم ها رابطه تنگاتنگی با اشاره گرها دارد . اکثر مهاجمان برای ورود غیر قانونی به سیستم های دیگران از این اشاره گرها استفاده می کنند و جاوا با حذف اشاره گرها این راه را سد کرده است .

جاوا در مقایسه با سایر زبان‌ها همچون C++ یا Basic یا Fortran زبان نسبتاً جدیدی است. جاوا شباهت‌هایی به ++C دارد، ولی قابلیت انتقال آن بهتر است و استفاده از آن ساده تر از ++C است. همچنین مدیریت حافظه نیز توسط خود ماشین مجازی جاوا انجام می‌شود. طراحی این زبان به گونه ایست که دارای اطمینان بسیاری بوده و وابسته به سیستم عامل خاصی نیست. و دلیل این موضوع این است که جاوا یک ماشین مجازی در سیستم شما راه می‌اندازد و برنامه‌ها را در آن ماشین مجازی اجرا می‌کند. این ماشین مجازی «ماشین مجازی جاوا» یا به اختصار JVM نامیده می‌شود. البته راه انداختن یک ماشین مجازی باعث دو مشکل می‌شود. هنگامی که نرم‌افزار شما در یک ماشین مجازی اجرا می‌شود سرعت کمتری خواهد داشت، همچنین شما نیاز دارید قبل از اجرای برنامه‌های جاوا یکبار سیستم مجازی جاوا را که حجم نسبتاً بالایی دارد، از اینترنت بارگذاری و یا از جای دیگری تهیه و نصب کنید ولی مزیت آن عدم وابستگی به سیستم عامل مقصد است.هدف این پروژه ایجاد یک زبان جدید شبیه به C++ بود که نویسنده اصلی آن، جیمز گاسلینگ، آن را بلوط Oak می نامید. اما بعدها به دلایل مشکلات حقوقی نام آن به جاوا تغییر کرد. پروژه گرین به دلیل مشکلات بازاریابی در شرف لغو شدن بود تا اینکه گسترش وب در سال 1993 باعث نمایش توانایی‌های وافر جاوا در این عرصه گشت. و به اینگونه بود که سان در می 1995 جاوا را رسما افتتاح کرد. هدف آن بود که جاوا زبانی ساده، قوی و همه منظوره باشد. جاوا تمام جنبه های مثبت C و ++C را در خود دارد و آن چیزهایی که برنامه نویسان ++C از آن نفرت داشتند (مانند وراثت چندگانه(Multiple Inheritance) ، تحریف اپراتورها (Operator Overloading) و اشاره گرها (Pointer)) را به کناری گذاشته است. مهمترین ویژگی جاوا این است که اساساً شی ­گرا(bject-Oriented) است. اولین ادعای OOP (Object Oriented Programming) توانایی استفاده مجدد از کد است، چیزی که ++C با تمام ادعاهایش هرگز نتوانست بدان دست یابد، اما در اولین قدم خواهید دید که ادعای جاوا در این زمینه تا چه اندازه صحت دارد. تصورش را بکنید که با صرف کمی وقت بتوانید برنامه­ای بنویسید که در سیستمهای ویندوز، مکینتاش و یونیکس به راحتی اجرا شود. همین که یک شرکت نرم افزاری بتواند برای تمام پلاتفرم های موجود در آن واحد پروژه­ای را تولید کند (و مقادیر عظیمی پول صرفه جویی کند) خود می تواند بهترین دلیل اقبال جاوا باشد. و امروزه دیگر همه (و نه فقط شرکتهای نرم افزاری) به سمت جاوا کشیده شده­اند.

با این ویژگی (استقلال از پلاتفرم) یک برنامه نویس می تواند برای سیستمی برنامه بنویسد که هرگز با آن کار نکرده است. این ویژگی اصلی ترین علت توفیق جاوا در اینترنت است. اینترنت شبکه پیچیده­ای است از میلیونها کامپیوتر مختلف در سراسر دنیا، و مقاومت در مقابل این وسوسه که بتوانید برنامه­ای بنویسید که روی تمام این سیستمهای متفاوت اجرا شود چندان ساده نیست.

جاوا یک زبان بسیار ساده است چون شما را وادار نمی کند تا در محیط جدیدی کار کنید و این برای کسانی که اطلاعات فنی ناچیزی در مورد کامپیوتر دارند بسیار مهم است. ساختار زبان جاوا در نگاه اول بسیار شبیه C و ++C است و این به هیچ وجه تصادفی نیست. C زبانی است ساخت یافته و ++C زبانی است شی گرا، و مهمتر از همه قسمت اعظم برنامه نویسان دنیا از آنها استفاده می ­کنند. از سوی دیگر این شباهت حرکت به طرف جاوا را برای این قبیل افراد ساده خواهد کرد. بنابراین طراحان جاوا برای اجتناب از دوباره کاری از زبانهای C و ++C به عنوان مدل استفاده کردند.جاوا با دور انداختن اشاره گرها و بر دوش کشیدن بار مدیریت حافظه، برنامه نویسان ++C/C را برای همیشه از این کابوس ها رهایی بخشیده است. علاوه بر آن، چون جاوا زبانی برای اینترنت است، از ایمنی و حفاظت ذاتی بالایی برخوردار است. طراحان جاوا از ابتدا یک محیط برنامه نویسی امن را مدنظر داشته­اند. مسئله حفاظت سیستمها رابطه نزدیکی با اشاره­گرها دارد. اکثر مهاجمان برای ورود غیرقانونی به سیستمهای دیگران از این اشاره­گرهااستفاده می­کنند و جاوا با حذف اشاره گرها این راه را سد کرده است. جاوا مکانیزم های حفاظتی دیگری هم دارد که در جای خود به آنها اشاره خواهیم کرد.مهم‌ترین ایرادی که برنامه نویسان سایر زبان‌ها به زبان جاوا می گیرند سرعت اجرایی بسیار پایین جاوا است. یک برنامه جاوا به صورت بایتکد می باشد و باید در ماشین مجازی جاوا اجرا گردد. به همین دلیل سرعت اجرای پایینی را در مقابل زبان‌های قدرتمندی همچون ++C دارد. به صورت دیگر یک برنامه C به طور متوسط تا 10 برابر سریعتر از برنامه مشابه جاوا اجرا می‌گردد. جاوا علی رقم شیء گرا بودن در بخشی از قسمت‌ها برای ایجاد انعطاف بیشتر یا بازاریابی بهتر برخی اصول شی گرایی را نادیده گرفته است. از جمله این قسمت‌ها قابلیت بازتابش Reflection می باشد. هدف اصلی بازتابش این است که استفاده مجدد از کدها و گسترش کدهای موجود و مهم‌تر از همه نوشتن برنامه‌های الحاقی آسان گردد ولی این مهم با زیر پا گذاشتن بعضی اصول ممکن شده است. برای نمونه با کمک بازتابش به راحتی می‌توان متدهای خصوصی دیگر کلاس‌ها را فراخوانی کرد! زبان جاوا در مقابل زبانی مثل ++C ساده تر و یادگیری آن آسانتر است. این آسانتر بودن به سادگی به دست نیامده است بلکه با حذف بسیاری از موارد که باعث قدرتمند تر بودن زبان ++C بوده‌اند ایجاد شده است. مهم‌ترین این موارد اشاره گرها و وراثت چندگانه بوده‌اند که در زبان جاوا یافت نمی شوند. از آنجایی که جاوا زبانی با عدم وابستگی به بستر می باشد پس استفاده از توابع سیستم عامل را در برنامه نمی پذیرد. به همین صورت نمی‌توان از واسط‌های برنامه نویسی غیر از جاوا در آن استفاده نمود

شي ئ گرایی

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

دلایل استفاده از شي ئ گرایی:

1- سادگی و سرعت در ایجاد برنامه های بزرگ

2- پشتیبانی ساده تر و ارزان تر

3- مناسب برای پروژه های گروهی

4- مناسب برای طراحی و پیاده سازی

شیئ گرایی و طبیعت

• تمام چیزهایی که در دنیای واقعی با آنها سر و کار داریم نوعی شیئ هستند.
• یک شیئ یک هدف کلی را تعریف می کند.
• نظام سلسله مراتبی در شیئ گرایی وجود دارد (یعتی بستگی دارد که از چه سطحی به شیئ نگاه کنیم)

تاریخچه زبان های شیئ گرا

• Simula I و Simula67 اولین زبان های شیئ گرا که در سال 1965 توسط KristenNygard و Ole-john Dahl در نروژ پدید آمد.
• Small Talk در سال 1970
• در سال های 1980 تا 1983 وارد زبان C شد و C++ شکل گرفت
• و اکنون C#, C++, JAVA, ……

بدون شیئ گرا

در برنامه نویسی معمولی ما از روال ها در برنامه اصلی (main prog) استفاده می کنیم. اشکالاتی که پیش می آید بدین شرح است:

1. تعداد زیاد روال ها در برنامه های بزرگ و ..
2. جستجوی روال ها مشکل و طاقت فرسا

برای رفع این اشکال به دسته بندی روی آوردند (برنامه نویسی ماژولار)

Module یا ماژول یا پیمانه شامل بخش کوچکی به نام روال است.

این روش هم دارای اشکالاتی بود

1. یک ماژول دارای یک وضعیت یا State می باشد.
2. مقدار دهی اولیه و فراخوانی روال ها به صورت دستی
3. ارسال اطلاعات زیاد به توابع
4. عدم کنترل پارامترهای ارسالی به توابع و خیلی مشکلات دیگر که با برنامه نویسی شیئ گرا این مشکلات حل شد.

Abstraction چیست؟

ایجاد ساختاری ساده شده از یک مساله مبهم که در آن مساله را به داده ها یا Data و اعمال روی داده ها یا Operation تقسیم کنند

ایده شیئ گرایی : همه چیز را در قالب اشیا و روابط بین آنها دیدن

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

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

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

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

سهاصل oop

كليه زبانهاي برنامه نويسي شي ئگرا مكانيسمهايي را در اختيار شما قرارميدهند
تا مدل شي ئگرا را پياده سازي نماييد. اين مدل شامل كپسول سازي (encapsulation)
وراثت (inheritance) و چند شكلي (polymorphism) مي باشد . اكنون نگاه دقيقتري
به اين مفاهيم خواهيم داشت .

 

 

 

شامل ورد 77 ص ای