למה אי אפשר לכתוב שיטות סטטיות ב-Interface? וגם אי אפשר לכתוב חתימות של Const. נראה לי שזה קשור..

שוב פישול אבטחה של Sun?

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

ולגבי const, גם אני תהיתי לגבי זה בעצמי. חיפשתי קצת בגוגל והצלחתי למצוא דיון ארוך ומייגע בפורומים של sun, לגבי האם צריך להיות const בשפה, ושם לא הגיעו לתשובה חד משמעית...

אוקי הבנת את מה שאתה אומר בקשר לזה שאסור לכתוב שיטה ססטית ב-Interface,

אבל זה בכל זאת נשמע לי לא הגיוני. נגיד שאני רוצה שיהיה לי factory ממומש בכל מחלקה, אז רק בגלל זה אני יצטרך לכתוב מחלקה רגילה עם protected ולהשאיר עיצוב ריק והכל מכוער!?

וכשאמרתי Const. התכוונתי ל-Constructor מצטער אם חשבת אחרת..

אה, חשבתי שאתה מתכוון ל-const methods, כמו שקיים ב-C++.

הקיצור של constructor הוא לרוב ctor.

INTERFACE הוא ממשק בלבד. הרעיון הוא להגיד למשתמש איזו פונקציונליות הוא נותן למי שמשתמש במי שיורש אותו. אתה לא יכול/אמור ליצור מופעים שלו, ולכן אין לו CTOR.

אה, חשבתי שאתה מתכוון ל-const methods, כמו שקיים ב-C++.

הקיצור של constructor הוא לרוב ctor.

לא כ"כ מכיר C++ אבל בJAVA יש FINAL METHODE, אולי לזה התכוונת?

INTERFACE הוא ממשק בלבד. הרעיון הוא להגיד למשתמש איזו פונקציונליות הוא נותן למי שמשתמש במי שיורש אותו. אתה לא יכול/אמור ליצור מופעים שלו, ולכן אין לו CTOR.

כן אבל נניח אני רוצה לכפות על מי שממש את הממשק ( =] ) לתת לי איזשהו קונסטרקטור עם חתימה מסוימת, אז מה רע בזה?!

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

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

לא התכוונתי ל-final. התכוונתי ל-const method, שאומר שהמתודה לא משנה שום דבר בקלאס (זה אומר, בין השאר, שהמתודה לא יכולה לקרוא למתודות אחרות באותו הקלאס שאינן const).

למה אתה צריך לכפות על קלאס את ה-ctor שלו? שהקלאס ייבנה איך שהוא רוצה.

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

גם ככה אי אפשר לקרוא ל-ctor מתוך ה-interface, אז למה אתה צריך שהקלאס יחויב להשתמש ב-ctor מסוים?

אני פשוט רוצה שיהיו לכל המחלקות שיממשו אותו FACTORY או לחילופין CTOR..

לא התכוונתי ל-final. התכוונתי ל-const method, שאומר שהמתודה לא משנה שום דבר בקלאס (זה אומר, בין השאר, שהמתודה לא יכולה לקרוא למתודות אחרות באותו הקלאס שאינן const).

לפי ההגדרה שלך זה בדיוק מה שעושה static

אז תגדיר ב-interface מתודהבשם getNewInstance שיוצרת instance חדש של הקלאס.

static אומר שהמתודה היא של הקלאס, ולא של ה-instance-ים שלו. היא לא יכולה להשתמש בכלל ב-member-ים אחרים של הקלאס, מלבד ממברים סטטיים אחרים.

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

כמו שאמרתי, const לא קיים בג'אווה.

אז תגדיר ב-interface מתודהבשם getNewInstance שיוצרת instance חדש של הקלאס.

והמטודה הזו צריכה להיות סטטית, אבל לא איאפשר ליצור שם מתודה סטטית =\

אוקי הבנתי מה זה CONST, לא קיים באמת...

למרות שאני לא רואה את הצורך בזה.. במילא מי שרושם שהמטודה היא CONST יודע מה הוא עושה בתוך,

אז שיעשה מה שהוא רוצה וזהו ואם הוא לא רוצה לשנות אז שלא ישנה =]

ואם זה באינטרפייס אז אפשר לעקוף את זה במימוש..

מוזר משהו....

למה המתודה צריכה להיות סטטית? איך אתה מצפה בכלל לקרוא לה? (אני אשמח לדוגמה)

לגבי ה-const, אתה צריך את זה כדי להגביל את עצמך ב-compile time, ואת מי שקורא לך. מנגנון ה-const ב-C++ מאפשר הגדרה של אובייקט כ-const, כך שלא תוכל לשנות אותו, אבל כן תוכל לקרוא ממנו. כשיש לך ביד אובייקט const, אתה יכול לקרוא לכל המתודות שלו שהוגדרו כ-const.

אני אתן לך דוגמה:

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

איך עושים את זה? אני מגדיר את הרשימה כ-member של אותו קלאס. אני מגדיר מתודה שמחזירה const reference לאותו member. המתודות של הרשימה שאינן משנות אותה (כגון אלו שציינתי לעיל) מוגדרות ב-const, ולכן מי שניגש לרשימה הזו יוכל לקרוא רק להן, ובכך לא יוכל לשנות אותה. מצד שני, הקלאס עצמו מחזיק את הרשימה כ-non const, ולכן יכול לגשת לכל המתודות שלה ולא רק ל-const.

נניח אני בונה כמה משחקי רשת, אז יש לי GameInterface

ואני רוצה להכריח את כל מי שרוצה להכניס משחק נוסף על השרת שלי לכתוב שיטה נניח Numbers.factory()

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

אבל אני רוצה שהמשחק יאותחל עם הערכים שאני מביא לו ולא איך שבא לו..

בקשר ל-const ולדוגמא שנתת, ב-Java יש פתרונות אחרים לנושא, למשל Iterator..

למרות שברור שזה פתרון צולע לעומת זה שאפשר פשוט לרשום const, במקום לכתוב מחלקה שלמה.

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

לגבי ה-const - נכון, יש פתרונות שעוקפים את זה. נניח, אפשר להגדיר קלאס בשם ConstList שמממש רק את המתודות שלא משנות אותו, וקלאס List שיורש ממנו וממש את כל שאר המתודות. פשוט ב-C++ זה חלק מובנה בשפה, בניגוד לג'אווה ו-C#.

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

מז"א פונקציית init? איך לכתוב כזה דבר?

אתה מתכוון לכתוב פונקציה לא סטטית שתהיה init ושהוא יעשה עם הקונסטרקטורים מה שבא לו?!

סתם מתודה שנקראת init (זה סתם שם, קרא לה איך שאתה רוצה), כמו כל שאר המתודות בקלאס.

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

כשתבוא להשתמש בקלאס, צור אותו באמצעות ה-ctor ומיד אחרי זה קרא ל-init.