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

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

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

האובייקט כפי שהוא מוכר כיום וגישת התכנות מונחה-עצמים הוצגו לראשונה בשפת התכנות 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: אובייקט שיכול להכיל אובייקטים אחרים.

ראו גם
------

* מחזור חיים של אובייקט
* תכנות מונחה-עצמים
* מחלקה (תכנות)
* בנאי (מדעי המחשב)
* תוכנה - מונחים