אז ככה הנה התרגיל פחות או יותר:

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

כתוב לי:

הגדירו מחלקה מופשטת בשם MyFile. מחלקה זו תייצג קובץ. עליכם להחליט בעצמכם אלו

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

עכשיו כתוב לי שלכל קובץ יהיו השיטות הבאות

public Object open() -פעולה שמחזירה Object שמכיל את תוכן הקובץ לפי המתואר בהמשך

public int getSize()

public String getName ()

TextFile-מחלקה שהיא קובץ טקסט ,בנאיString name , String text)

text= תוכן הקובץ

ImageFile-מחלקה שהיא קובץ תמונה, בנאי(String name, char [ ] [ ] image)

בנאי שמקבל את שם הקובץ ואת התמונה0מערך דו מימדי של תווים). על הקובץ להחזיק עותק של התמונה

(התמונות הן תמונות שנקראות ASCII art =יוצרים תמונות בעזרת תווים)

Directory- מחלקה שהיא קובץ תיקייה ,בנאי (String name) שמקבל את שם התיקייה ויוצר תיקייה ריקה.

שיטה שקיימת במחלקה הזאת:

public boolean addFIle(MyFile file)d

עכשיו יש לי כמה שאלות:

1) השיטה Object, מה היא מחזירה בעצם? היא יכולה להחזיר כל מה שקשור לאובייקט? int char String?

2) מופיע במחלקה Directory שיטה שאמורה בעצם ליצור אובייקט מטיפוס MyFile, אם אני מבין נכון?

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

אז איך ניתן בעצם יכול להפעיל את השיטה addFile שמופיעה במחלקה Directory?

תודה לעוזרים מראש.

קודם כל, תאמר באיזו שפה אתה כותב.

(אני מניח ג'אווה? או שמא #C? מומלץ שתערוך את הכותרת בהתאם)

לגבי השאלות שלך:

1. אני מניח שאתה מתייחס לזה:

public Object open() 

שים לב ש-Object הוא לא שם השיטה (שם השיטה הוא open), אלא הטיפוס של ערך ההחזרה שלה.

Object יכול למעשה להיות כל טיפוס, כי כל טיפוס יורש ממנו (אולי חוץ ממשתנים פרימיטיביים כמו int ו-char, אני לא סגור על זה, ונראה לי שזה תלוי באיזו שפה אתה כותב).

2. הפונקציה addFile לא יוצרת אובייקט מטיפוס MyFile, אלא מקבלת אובייקט מטיפוס זה. היא לא צריכה ליצור אותו, רק לדעת איך להתייחס אליו.

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

אחת הדוגמאות הנפוצות למחלקות מופשטות היא מחלקה שמייצגת צורה גיאומטרית (Shape), אבל כיוון שלא מדובר בצורה גיאומטרית ספציפית (ריבוע/מעגל/משולש וכו'), זו צריכה להיות מחלקה מופשטת. על מנת ליצור אובייקט מטיפוס Shape, מגדירים קודם כל מחלקה לא מופשטת שמייצגת צורה ספציפית (כגון Square, Circle, Triangle) שיורשת מ-Shape, ולמעשה יוצרים אובייקט מהטיפוס הזה.

נ.ב. מחלקה מושפטת (abstract) כן יכולה להגדיר constructor. אבל, אפשר יהיה לקרוא לבנאי הזה אך בבנאי של מחלקה שיורשת מהמחלקה המופשטת.

יופי שניצל, תגיב לפני... ממש בוגר

אבל אם כבר כתבתי את התגובה שלי...

לעתיד,

תשתמש בטאג Code בשביל שיהיה יותר קל לקרוא את מה שהוא קוד (בעת כתיבת הודעה - לחץ על הכפתור עם התמונה של "#" שמופיע מעל הסמיילי הזה - )

אני מניח שאתה מדבר על #C אגב, למרות שלא ציינת (בגדול התשובות יהיו דומות עד זהות עבור שפות אחרות, כגון JAVA)

ולנושא,

1. אם מתודה מוגדרת כמחזירה Object אז זה אומר שהיא יכולה להחזיר הכל (כי הכל יורש מ-Object), כלומר int, string, double, MyFile, ImageFile וכל דבר אחר שמוגדר כבר בשפה או מחלקה חדשה שאתה יוצר

2. אתה לא מבין נכון. כתבת שזאת החתימה של המתודה:

public boolean addFIle(MyFile file)

נכון?

זה אומר שהמתודה מקבלת אובייקט מסוג MyFile (או אובייקט שיורש ממנו) ומחזירה ערך בוליאני (אמת/שקר) שכנראה המשמעות

שלו זה האם הפעולה הצליחה (האם הוא הצליח להוסיף את האובייקט file מסוג MyFile שהעברת לו או לא)

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

הבסיס, שהיא מופשטת (המחלקה MyFile)

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

רק מתוך מחלקות שיורשות (להלן: מחלקות יורשות) ממחלקת הבסיס.

למשל בדוגמא, אולי תרצה להגדיר במחלקת הבסיס בנאי אשר מקבל כפרמטר את שם הקובץ - string name אשר נראה משהו כזה:

private MyFile(string name)
{
	this.name = name;
}

ואז כל אחת מהמחלקות היורשות תקרא לבנאי הנ"ל בתוך הבנאי שלה (במקום שכל אחת תעשה את הפעולה הנ"ל בעצמה)

קודם כל תודה על התגובות.

כן אתם צודקים אני פשוט התבלבלתי בענין בשיטה

אני מבין שהיא צריכה לקבל אובייקט מסוג myFile ולהחזיר בוליאן.

השאלה שלי איך עושים את זה?

ז"א לפני התשובה של שניצל הבנתי שאני צריך ליצור מחלקה שיורשת את 3 השיטות שיש במחלקה abstract MyFile?

עדין לא הבנתי איך יהיה ניתן ליצור אוביקט מטיפוס MyFile? , הוא לא יהיה מטיפוס המחלקה החדשה שיורשת את MyFile?

(אני הבנתי שלא ניתן ליצור בנאים למחלקות מופשטות)

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

כן, הוא יהיה מטיפוס שיורשת מ-MyFile, כלומר אחד מהטיפוסים TextFile, ImageFile או Directory.

אבל מכיוון שהוא יורש מ-MyFile אז ניתן להתייחס אליו כאל אובייקט מסוג MyFile ולכן ניתן להעביר

אותו לכל מתודה שמקבלת משתנה מסוג MyFile

כלומר אתה לא יוצר אובייקט מסוג MyFile, אתה יוצר אובייקט שיורש מ-MyFile ומתייחס אליו בתור MyFile

למשל, אתה יכול לכתוב משהו כזה:

MyFile file = new Directory("whatever")

אבל אתה לא יכול לכתוב משהו כזה:

MyFile file = new MyFile("whatever")

בדוגמא הראשונה, יצרת אובייקט מסוג Directory ואתה מסתכל עליו כאילו הוא מסוג MyFile (אפשרי, כי Directory יורשת מ-MyFile)

הדוגמא השנייה לא תקינה, כי אי אפשר ליצור אובייקט מסוג MyFile

אוקיי אני חושב שהבנתי..

נגיד וTextFile יורשת את MyFile ואני יוצר אובייקט מטיפוס תמונה

MyFile picture = new TextFile("kovez", "file number one");

אני יוצר תיקייה חדשה

MyFile file = new Directory ("folder");

ואז אני מפעיל את השיטה:

file.addFile(picture);

(נגיד והשיטה addfile מוסיפה קובץ לתיקייה)

אז בעצם השיטה תעבוד והוספתי קובץ מטיפוס TextFile בשם kovez לתיקייה file?

"אובייקט מטיפוס תמונה" - אני משער שהתכוונת לטיפוס מסוג קובץ טקסט?

אם כן, כדאי לקרוא לו בשם מתאים (ולא picture)

אם לא, אז אתה קורא לבנאי הלא נכון, וזה היה צריך להיות:

MyFile picture = new ImageFile("Image", charArr)

בהנחה ש-CharArr הוא מערך דו-מימדי של תווים, כפי שדורש הבנאי

הקוד הזה לא בדיוק יעבוד, כי מכיוון שהוא לא יודע שהמשתנה file הוא מסוג Directory

הוא לא יכול להפעיל עליו את המתודה addFile בלי לעשות casting

מה שצריך לעשות זה ככה (קרוב למדי למה שעשית, אבל קצת שונה):

MyFile text = new TextFile("kovez", "file number one");
Directory dir = new Directory("Folder");
dir.addFile(text);

במקום השורה הראשונה ניתן להצהיר על המשתנה גם ככה:

TextFile text = new TextFile("kovez", "file number one");

בשניהם הקטע קוד יעבוד כמו שצריך, אבל אם נשתמש בשני אז נוכל להתייחס למשתנה text כאל קובץ טקסט ולא סתם קובץ

ולהפעיל עליו מתודות שמתאימות לו, ולא רק למחלקת הבסיס שלו

כן אתה צודק התבלבלתי בהתחלה עם הpicture..

הבנתי את מה שכתבת, תודה.

ובכל זאת אם הייתי רוצה להשתמש בcasting איך הייתי עושה את זה?(אם יש אפשרות ?)

כן, זה אפשרי

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

ככה תעשה את זה: (שוב, הקוד מתאים ל-#C אבל סביר שזה דומה עד זהה ב-JAVA)

TextFile text = new TextFile("kovez", "file number one");
MyFile dir = new Directory("Folder");
((Directory)dir).addFile(text);

שים לב לשורה השלישית, שם בעצם כל השינוי

שוב,

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

סיבה לעשות זאת אלא אם כן חייבים. במקרה הנ"ל לא חייבים.

הבנתי אותך , תודה רבה על כל העזרה, עזרת לי המון