שאלה בג'אווה על ירושה:

[מתבוננת מהשחקים]

שאלה בג'אווה על ירושה:

class A { private int a; public get_a() { return a; } class B extends A{ public int a; } main: B b = new B()... b.geta();​

והשאלה היא כזו: לאיזה משתנה תיגש ה main , היא בעצם לא יכולה לגשת ישירות לa של A כי הוא private , אבל רק דרך הפונקציה get_a אבל, ל B בעצם יש 2 a-ים לאיזה a היא תיגש? האם מותר לי בכלל להגדיר פעם שניה את a? ואגב רציתי לומר לכם שהיו כאן כמה שאלות שפתרתם לי בפורום ושאלו אותי את השאלות בראיון עבודה וידעתי את התשובה בצ'יק בגלל שקראתי כאן את הדיון על השאלה והפתרון , אז תודה

 

[selalerer]

אני לא בטוח בJava אבל ב++C זה הפונק

ציה יודעת למי היא ניגשת, אין לה שום סיבה לגשת לa של B, זה לא כמו מטודה (וירטואלית ב++C) שהוא עושה לה איזשהו resolving בזמן ריצה, פה בזמן הקימפול הוא יודע לאיזה זיכרון הוא ניגש (מה ההיסט שלו במבנה נתונים A).

 

[מתבוננת מהשחקים]

זה נכון לגביי מתודות :

יש טבלת lookup שדרכה הוא יודע לאיזה טבלה לגשת, אבל כאן מה שבילבל אותי זה ה"דריסה"/"הסתרה" של ה attribute ותודה , אבל אני צריכה את התשובה בג'אווה.... חחחח, אגב בדקתי את זה עכשיו והוא החזיר לי את הערך של a של A אז רציתי לשאול אם אפשר לקבל הסבר לגביי "דריסה" של attributes ואם צריך לשים גם לב לחתימה שלהם private/public וכאלה , איך זה בדיוק הולך?<בג'אווה> יש overloading כמו במתודות?

 

[מתבוננת מהשחקים]

לאיזה *מתודה* לגשת

 

[tennez]

ב Java אפשר לעשות override רק

למתודות ולא לממברים. אם נקרא למתודה x מתוך מתודה y ב class A, נעשה override ל x ב class B, יורש של A ונקרא למתודה y דרך class B, את המתודה x יחפשו ב class שקרא לה (class B) ולכן x של class B תקרא. לעומת זאת, אם נקרא לממבר x מתוך מתודה y ב class A, נעשה "override" ל x ב class B, יורש של A ונקרא למתודה y דרך class B, את הממבר x יחפשו ב class שאליו שייכת המתודה y ולא ב class שקרא לה ולכן נגיע ל x של class A.

 

[Desslok of Gamilon]

זה לא קשור ל private/public זה קשור לאיזו פונקציה את מריצה. מתודה של A לא מכירה כלל את החלק ה B-י של האובייקט. בואי נסבך את הדוגמא שלך:

class A { private int a; public get_a() { return a; } class B extends A{ public int a; } class C extends A{ } class D extends A{ public int a; } main: B b = new B()... C c = new C()... D d = new D()... b.geta(); c.geta(); d.geta();​

חלק מהמחלקות היורשות מגדירות מחדש את a, וחלק לא. למקרה הנוחות, הפונקציה geta מתנהגת תמיד אותו הדבר - היא פונקציה של A, והיא מחזירה את האיבר של A.

 

[מתבוננת מהשחקים]

אלללה יסטור

ואם אני אעשה

A a = new B()...; ?​

ואם אני אגדיר בB מחדש את הפונקציה geta אז בכלל לא תהייה לי גישה לA.a?

 

[Desslok of Gamilon]

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

int x = super.a;​

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