אובייקט (מדעי המחשב)

מתוך ויקיפדיה, האנציקלופדיה החופשית
קפיצה אל: ניווט, חיפוש

במדעי המחשב, אובייקט או עצםאנגלית: object) הוא מקום בזיכרון המחשב שיש לו ערך וקיים אליו קישור (reference) ממזהה כלשהו. אובייקט יכול להיות משתנה, פונקציה, או מבנה נתונים. עם ההופעה של תכנות מונחה-עצמים, המילה "אובייקט" קיבלה משמעות נוספת המתייחסת למופע ספציפי של מחלקה.

ניתן להגדיר אובייקט גם כיישות בעלת מזהה ייחודי, והיא מאופיינת על ידי המצב וההתנהגות שלה:

  • מזהה: התכונה של אובייקט אשר מבדילה בינו לבין אובייקטים אחרים.
  • מצב: מתאר את הנתונים המאוחסנים באובייקט.
  • התנהגות: מתארת את המתודות בממשק של האובייקט, באמצעותן ניתן להשתמש באובייקט.

האובייקט כפי שהוא מוכר כיום וגישת התכנות מונחה-עצמים הוצגו לראשונה בשפת התכנות Simula שהופיעה בשנת 1967, הפכו לפופולריים עם ההופעה של שפת Smalltalk שהופיעה שנתיים מאוחר יותר ב-1969, והפכו לכלים סטנדרטיים עם ההתפשטות של שפת ++C שהופיעה בשנת 1983.

אובייקטים הם הבסיס לתכנות מונחה-עצמים והם טיפוסי הנתונים החשובים ביותר בשפות תכנות מונחות עצמים. שפות כאלה מספקות תמיכה תחבירית וסמנטית רחבה לטיפול באובייקטים. הן כוללות מערכת טיפוסים היררכית, כתיב מיוחד להצהרה וקריאה למתודות ואמצעים להסתרת משתנים נבחרים ממתכנתי לקוח. עם זאת, ניתן להשתמש באובייקטים ובתכנות מונחה-עצמים כמעט בכל שפת תכנות.

שימוש באובייקטים מקל על תחזוקת התוכנה, על ניהול ספריות ועל חלוקת העבודה בתוך צוותי מתכנתים. יתרון נוסף של עבודה עם אובייקטים הוא בכך שאותו קטע קוד יכול להשתמש באובייקטים שונים מאוד, כל עוד יש להם את המתודות המתאימות.

תכנות מונחה עצמים[עריכת קוד מקור | עריכה]

בתכנות מונחה-עצמים, אובייקטים הם מבני נתונים ביחד עם שגרות העיבוד המצורפות אליהם. אובייקט הוא מופע (instance) של מחלקה (class). מחלקה משמשת כדי להגדיר פעם אחת את משתני המחלקה (properties) וההתנהגות (הפונקציות), ולאחר מכן ניתן להשתמש בה ליצירת הרבה מופעים (אובייקטים) מהסוג של אותה מחלקה. להבחנה זו בין מחלקה לאובייקט קיימות מקבילות גם בתחומי מדע אחרים. לדוגמה, בביולוגיה ואבולוציה קיימת ההבחנה הטקסונומית בין סוג ומין.

אובייקט הוא בדרך כלל סט ארעי של תכונות (משתני מחלקה; באנגלית: properties או attributes) והתנהגויות (מתודות או שגרות) המכמסות ישות כלשהי. בצורה כזו, מתקיימת הבחנה בין טיפוסי נתונים פשוטים או פרימיטיביים המהווים יחידות אינפורמציה בדידות, לבין אובייקטים של תכנות מונחה-עצמים המהווים טיפוסי נתונים מורכבים הכוללים הרבה יחידות מידע ותכונות ספציפיות. לדוגמה, ניתן ליצור אובייקט המייצג קובץ: אוסף של נתונים ביחד עם מתודות הקריאה והכתיבה המשויכות אליהם. ההגדרה הכללית של "קובץ" כלשהו תהיה מחלקה, וכאשר יווצר מופע של "קובץ" ספציפי הוא יהיה אובייקט מטיפוס "קובץ". שלא כמו טיפוסי נתונים פרימיטיביים, להם ניתן לבצע השמה של ערך (לדוגמה, int a = 10), אובייקטים צריכים ל"היבנות" על ידי קריאה לפונקציית constructor.

אחד הרעיונות החשובים בתכנות מונחה-עצמים הוא רעיון הירושה (inheritance) המאפשר להגדיר יחס מסוג is-a בין אובייקטים. לדוגמה, "a car is a vehicle", כלומר, "מכונית היא סוג של כלי רכב". ניתן לממש יחס כזה בתכנות מונחה-עצמים על ידי מימוש מחלקת Vehicle (כלי רכב) ומימוש של מחלקה נוספת Car (מכונית) שיורשת מהמחלקה Vehicle. בדוגמה זו המחלקה Vehicle היא מחלקת האב (superclass) והמחלקה Car היא המחלקה היורשת (subclass). לאחר שהוגדרה המחלקה Car, ניתן ליצור מספר בלתי מוגבל של אובייקטים (מופעים) מהטיפוס Car אשר כולם כוללים את כל התכונות (לדוגמה, "מהירות מרבית") וההתנהגויות (לדוגמה, "לנסוע") שהוגדרו במחלקה Car. ניתן ליצור גם היררכיה מורכבת יותר של ירושה בין מחלקות, לדוגמה: "בעל חיים" יכולה להיות מחלקת אב של המחלקה "יונק" שממנה יורשת המחלקה "פרימט" שממנה יורשת המחלקה "אדם". פרטים ספציפיים כמו "יוסי לוי" ו"משה כהן" יהיו אובייקטים ממחלקת ה"אדם" ולכן יהיו להם גם כל התכונות הנכללות במחלקות: "אדם", "פרימט", "יונק" ו"בעל חיים".

דוגמה ליצירת אובייקט ושימוש בו בשפת Java[עריכת קוד מקור | עריכה]

קטע הקוד הבא בשפת Java מגדיר את המחלקה Calculator (מחשבון) הכוללת מימוש למתודות: add (חבר), subtract (חסר), multiply (הכפל) ו-divide (חלק):

public class Calculator {
 
 public float add(float a, float b) {
 return a + b;
 }
 
 public float subtract(float a, float b) {
 return a - b;
 }
 
 public float multiply(float a, float b) {
 return a * b;
 }
 
 public float divide(float a, float b) {
 return a / b;
 }
}

כמעט בכל שפות התכנות מונחות העצמים אופרטור הנקודה (.) משמש כדי לקרוא למתודה ספציפית של האובייקט כאשר הוא נמצא בין האובייקט לבין שם המתודה. קטע הקוד הבא כולל יצירה של אובייקט בשם calculatorObject שהוא מופע של המחלקה Calculator, קריאה למתודות של האובייקט והדפסת תוצאות החישוב שבוצעו על ידי האובייקט. (יצירת האובייקט בשורה השלישית):

public class CalculatorExample {
 
 public static void main(String[] args) {
 
 Calculator calculatorObject = new Calculator(); // creating an instance of the Calculator class
 
 float a = 10;
 float b = 2;
 
 float result1 = calculatorObject.add(a, b);
 float result2 = calculatorObject.subtract(a, b);
 float result3 = calculatorObject.multiply(a, b);
 float result4 = calculatorObject.divide(a, b);
 
 System.out.println(result1); // prints: 12.0
 System.out.println(result2); // prints: 8.0
 System.out.println(result3); // prints: 20.0
 System.out.println(result4); // prints: 5.0 
 }
}

אובייקטים מיוחדים[עריכת קוד מקור | עריכה]

ישנם אובייקטים מיוחדים הנוצרים על סמך תבנית עיצוב מסוימת. בדרך כלל אובייקטים כאלה נקראים על שם תבנית העיצוב שלפיה הם נוצרו. ביניהם:

  • Factory object (אובייקט בית חרושת): אובייקט שמטרתו ליצור אובייקטים אחרים.
  • Singleton object: אובייקט שהוא המופע היחיד של המחלקה שלו לאורך כל זמן הריצה של התוכנית.
  • Prototype (אב טיפוס): אובייקט מיוחד שלפיו יכולים להווצר אובייקטים נוספים על ידי העתקה.
  • Immutable object (אובייקט שלא ניתן לשינוי): אובייקט המקבל מצב קבוע בזמן היצירה שלו והוא אינו משתנה לאחר מכן. אובייקטים מהמחלקה String ב-Java הם דוגמה ל-Immutable objects.
  • Function object: אובייקט שיש לו מתודה אחת והיא פועלת כפונקציה (בדומה למצביע לפונקציה בשפות C ו-++C). ב-++C ניתן לממש function object על ידי העמסת (overloading) המתודה ()operator.
  • God object (אובייקט אלוהים): אובייקט שיודע יותר מדי או עושה יותר מדי. God object הוא דוגמה ל-anti-pattern.
  • Container: אובייקט שיכול להכיל אובייקטים אחרים.

ראו גם[עריכת קוד מקור | עריכה]