תיאור מחלקה ומושג העצם

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

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

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

הגדרת מחלקות ויצירת עצמים

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

class person { int pid; int pdate; String pname; void insert (int id,int date,String name) { pid = id; pdate = date; pname = name; } }

הסבר:
הצהרנו על מחלקה בשם person שלה 3 משתנים. שני משתנים מסוג int, לייצוג של מספר ת"ז ותאריך לידה, ומשתנה מסוג String, לייצוג שם האדם. בנוסף הצהרנו גם על פונקציה בשם insert שמקבלת 3 משתנים בהתאם ומשימה אותם לתוך ערכי הפונקציה.
הערות:
אפשר לאתחל (לתת ערך התחלתי) כל משתנה בזמן ההגדרה. הערך ינתן למשתנה עם יצירת העצם. ערכים שלא יאותחלו יקבלו את הערך 0 בתור ברירת מחדל (false למשתנים בוליאניים ו null למצביעים).
לכל פונקציה תנתן אפשרות להגבלת הגישה אליה ע"י נתינת הערכים public, protected ו private, כשברירת המחדל היא package.

יצירת עצמים

יצירת עצמים בג'אווה כוללת שני שלבים:
1. נתינת שם לעצם ספציפי עפ"י המחלקה - הגדרת reference.
לדוגמא:

;person p1, p2 ;car volvo

כלומר, הגדרנו מופעים p1,p2 של המחלקה person ומופע volvo של המחלקה car.
2. הקצאת העצם - הקצאת העצם תעשה ע"י הוראת new.

;( ) <שם המחלקה > new = <שם המופע>

לדוגמא:

;( )p1 = new person ;( )p2 = new person ;( )volvo = new car

אפשר להקצות גם מערך שלם. לדוגמא:

;[ ]person p

למערך של עצמים כזה לא תספיק הוראת new אחת (כדוגמת ++C):

;[p = new person[2

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

;( )p[0] = new person ;( )p[1] = new person

אפשר לשלב את שני השלבים לשלב אחד:

;( )person p = new person ;[person q [ ] = new person[2

בקרת גישה

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

• private - הגישה מותרת רק לפונקציות של המחלקה עצמה.
• protected - הגישה מותרת גם לפונקציות היורשות את המחלקה.
• package - הגישה מותרת לכל הפונקציות ששיכות למחלקות שבאותה חבילה כמו המחלקה שלנו.
• public - הגישה מותרת לכל פונקציה שהיא.

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

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

אתחול עצמים - constructor

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

class car { private String model; private int number; private int year; public car(String m,int n,int y) { model = m; number = n; year = y; } }

קריאה ל constructor

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

public class world { car cars[] = new car[2]; void init() { cars[0] = new car("volvo", 3246512, 2000); cars[1] = new car("ford", 8732567, 2002); } }

הצהרנו על מערך של עצמים מסוג car ואתחלנו בעזרת ה constructor את העצמים. כעת יש שני עצמים בתוכנית מסוג car עם הערכים המתאימים שאתחלנו.

העמסת ה constructor

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

class car { private String model; private int number; private int year; public car(String m,int n,int y) { model = m; number = n; year = y; } public car(String m,int n) { model = m; number = n; year = 2001; } }

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

public class world { car cars[] = new car[2]; void init() { cars[0] = new car("volvo", 3246512, 2000); cars[1] = new car("ford", 8732567); } }

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

constructor מחדל

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

constructor העתקה

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

	public car(car c) { model = c.model; number = c.number; year = c.year; }
והקריאה לפונקציה תהיה:
	car c1 = new car("volvo", 3246512, 2000); car c2 = new car(c1);

המצביע this

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

public car(String m, int n, int y) { this(m,n); year = y; } public car(String m, int n) { model = m; number = n; year = y; }

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

פונקצית סיום - destructor

משתנה סטטי

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

class car { private String model; private int number; private int year; static int counter =0; public car(String m,int n,int y) { model = m; number = n; year = y; counter++: } }

הוספנו משתנה מסוג static int לתכונות המחלקה. כל קריאה לעצם חדש מסוג car תגרום, ע"י הקונסטרקטור, לעלייתו של המשתנה הסטטי באחד וכך נוכל לעקוב בתוכנית כמה עצמים בדיוק מסוג car קיימים כרגע בתוכנית.

פונקציות סטטיות

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

class car { private String model; private int number; private int year; private static int counter = 0; public car(String m,int n,int y) { model = m; number = n; year = y; counter++: } public static int getCount() { return counter; } }