תכנות מתקדם ב-Java/אובייקטים: הבדלים בין גרסאות בדף

מתוך ויקיספר, אוסף הספרים והמדריכים החופשי
תוכן שנמחק תוכן שנוסף
בעבודה
Mintz l (שיחה | תרומות)
מ שוחזר מעריכה של 82.166.76.222 (שיחה) לעריכה האחרונה של Johnny Zoo
שורה 1: שורה 1:
{{בעבודה}}
'''אובייקטים''' או '''עצמים''', הם אבני היסוד של התכנות מונחה העצמים.
'''אובייקטים''' או '''עצמים''', הם אבני היסוד של התכנות מונחה העצמים.


שורה 114: שורה 113:
}
}
</source>
</source>
זהו המימוש של מוצר במכולת. המחלקה מכילה את כל השדות (המשתנים הפנימיים) והשיטות הדרושות לנו (כפי שפורטו למעלה). לשם הפשטות תאריך התפוגה נקבע באמצעות מספר שלם שסופר את הימים עד התפוגה. נראה כאן את קוד המחלקה האחראית על ניהול המלאי:<!--
זהו המימוש של מוצר במכולת. המחלקה מכילה את כל השדות (המשתנים הפנימיים) והשיטות הדרושות לנו (כפי שפורטו למעלה). לשם הפשטות תאריך התפוגה נקבע באמצעות מספר שלם שסופר את הימים עד התפוגה. נראה כאן את קוד המחלקה האחראית על ניהול המלאי:
<source lang = "java">
<source lang = "java">
// Stock.java
// Stock.java
שורה 170: שורה 169:
}
}
</source>
</source>
-->

גרסה מ־03:30, 19 בדצמבר 2007

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

הקדמה - תכנות מונחה עצמים

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

דוגמה - מכולת

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

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

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

מבנה

כל טיפוס של אובייקט נקרא "מחלקה" (Class). מחלקה מכילה בנאים (והורסים), מתודות/שיטות (Methods) ומשתנים פנימיים. בדוגמה שלנו, קיימות שתי מחלקות: מלאי, ומוצר. המלאי מכיל את השיטות "חשב ערך כולל", "הדפס מלאי", "הוסף מוצר למלאי", וכן הלאה. הוא מכיל את הנתונים לגבי המוצרים: מערך מטיפוס "מוצר". המוצר יכיל כמה שיטות משלו: "הדפס מוצר", "צור מוצר חדש", וכדומה. הוא יכיל משתנים פנימיים: משתנה שיכיל בתוכו את מחיר המוצר, משתנה שיכיל את שם המוצר, וכן הלאה.

בנאים

בנאי (Constructor), כשמו, הוא כלי באמצעותו יוצרים אובייקט. לכל אובייקט קיים בנאי, ולפעמים גם כמה סוגים של בנאים. חוץ מיצירת האובייקט, הבנאי יכול להכיל פעולות כאוות נפשו של המתכנת. הערה: בניגוד לשפות (כמו C++), בהן קיים צורך להשמיד (Destruct) כל אובייקט לאחר השימוש בו כדי לפנות את הזיכרון בו נעשה שימוש, בג'אווה אין צורך בכך - כלי בשם Garbage Collector (אוסף האשפה) אחראי על פינוי הזיכרון, ומסיר בכך את הנטל מעל כתפי המתכנתים. נעיר כי העדפה זו של הנוחות עולה במחיר מה של מהירות הריצה.

משתנים פנימיים

משתנים פנימיים הם המשתנים אותם מכיל האובייקט בתוכו. הם יכולים להיות מכל סוג שהוא - משתנים פשוטים כמו int או String, מערכים, או אף אובייקטים אחרים. לעיתים קרובות הם מכונים גם "שדות".

שיטות

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

איך זה נראה בג'אווה

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

בנאי

הבנאי הוא שיטה ששמה כשם המחלקה, ושאינה מחזירה ערך משום סוג. אם נניח ששם המחלקה הוא MyClass, הבנאי יראה כך:

public MyClass() {
	// Some code
}

בנאי יכול לקבל ערך, או ערכים רבים, מכל סוג, בצורה הבאה:

public MyClass(int x, float y) {
	// Some code
}

הקריאה לבנאי מתבצעת בעזרת המילה השמורה new, בצורה הבאה: MyClass obj = new MyClass(); או, אם הבנאי מקבל ערכים, למשל - בנאי שמקבל int ו-float: MyClass obj = new MyClass(1, 2.3); מרבית הקוראים בוודאי יתמהו: מדוע להכריז בצורה כזו על האובייקט? מדוע שלא להכריז על אובייקט כמו שמכריזים על משתנה פשוט - MyClass obj;? למען האמת, מורכבת ההכרזה שהצגנו כאן משני חלקים. החלק הראשון, הימני - MyClass obj מקצה מקום בזיכרון עבור אובייקט מטיפוס MyClass. המחשב מקצה את המקום הדרוש, אך לא יוצר בו אובייקט. החלק השני, השמאלי, בו אנו פונים לבנאי, הוא החלק שיוצר את האובייקט, במקום שכבר הוקצה עבורו בזיכרון. כשתלמדו כמה צדדים מתוחכמים יותר של התכנות מונחה העצמים תוכלו להבין טוב יותר מדוע קיימת ההפרדה הזו.

משתנים ושיטות

צורת העבודה עם המשתנים והשיטות דומה מאוד לזו שכבר הכרנו, אך ללא המילה static. בעבודה עם אובייקטים נהוג להשתמש במשתנים גלובליים - של האובייקט.

פנייה למשתנים ושיטות

נקודת ההסתכלות צריכה לעבור מהפך, כאשר מתעסקים בתכנות מונחה עצמים. כעת, כל פעולה שמתבצעת - מתבצעת על אובייקט. כדי לבצע פעולה כלשהי על אובייקט, משתמשים בצורה obj.action(arguments) כדי לבצע את השיטה action (עם הארגומנטים arguments) על האובייקט obj, או obj.variable כדי לפנות למשתנה variable, שהוא משתנה פנימי של האובייקט obj.

שיטות בתוך האובייקט עצמו, כלומר - שיטות בתוך המחלקה - יכולות לפנות ישירות למשתני המחלקה (אך לא למשתנים סטטיים). שיטות מתוך האובייקט יכולות לפנות ישירות גם לשיטות (לא סטטיות) אחרות של המחלקה. גם הפניות האלה נעשות אל אובייקט - אל אותו האובייקט עצמו.

תוכנית המכולת

נראה כאן מימוש בג'אווה של ה"מכולת" אותה תיארנו קודם. נעבוד עם שני קבצים: Item.java יכיל את המחלקה המטפלת במוצרים. Stock.java יכיל את המחלקה המטפלת במלאי.

// Item.java

public class Item {
	
	// Item's name
	String _name;
	// Item's description
	String _description;
	// Item's price
	double _price;
	// Quantity of that item
	int _quantity;
	// Days left for that item until expired
	int _daysLeft;
	
	/*
	 * Constructor
	 */
	public Item(String name, String desc, double price, int quantity, int days) {
		_name = name;
		_description = desc;
		_price = price;
		_quantity = quantity;
		_daysLeft = days;
	}
	
	// Set days left until expiration
	public void SetDaysLeft(int newDaysLeft) {
		_daysLeft = newDaysLeft;
	}
	
	// Set item's quantity
	public void setQuantity(int newQuantity) {
		_quantity = newQuantity;
	}
	
	// Get item's price
	public double getPrice() {
		return _price;
	}
	
	// Print item details
	public void printItem() {
		System.out.println("Item: "+_name);
		System.out.println("Description: "+_description);
		System.out.println("Price: "+_price+" Quantity in stock: "+_quantity+
				" Days until expiration: "+_daysLeft);
	}

}

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

// Stock.java

public class Stock {
	
	public final int MAX_ITEMS = 10;
	
	// Array that holds all items in the stock
	Item[] _stock;
	
	/*
	 * Constructor
	 */
	public Stock() {
		// Build the array of items
		_stock = new Item[MAX_ITEMS];
	}
	
	// Add item to stock
	public void addItem(Item it, int serial) {
		if(_stock[serial] != null) {
			System.out.println("Cannot add item: this cell is full");
			return;
		}
		_stock[serial] = it;
	}
	
	// Print all items in stock
	public void printStock() {
		for(int i=0; i<_stock.length; i++) {
			if(_stock[i] != null)
				_stock[i].printItem();
		}
	}
	
	// Calculates the value of all items in stock
	public double sumStock() {
		double sum = 0.0;
		for(int i=0; i<_stock.length; i++) {
			if(_stock[i] != null)
				sum+=_stock[i].getPrice();
		}
		return sum;
	}
	
	// Set new quantity for that item
	public void setItemQuantity(int serial, int newQuantity) {
		if(_stock[serial] == null) {
			System.out.println("No such item!");
			return;
		}
		_stock[serial].setQuantity(newQuantity);
	}
}