אני רוצה שמחלקה מסויימת בJAVA, תדע איך קוראים לה.
כלומר, איך אני יכול לשמור String, עם השם של המחלקה, שימלא את עצמו אוטומטית.
אני יודע שצריך להעזר בreflections.

אשמח לעזרה.

תומר

תפעול מכשירים, סלולרי וגאדג'טים

חיפשת בגוגל?

this.getClass().getName()

כמובן

אבל זה לא נותן לי לבצע זאת בטענה שהמתודה סטטית.
ואם אני משנה אותה ללא סטטית זה יוצר בעיה אחרת.
לדוגמא:

קוד:

public class test {

	public static void main(String[] args) {
		System.out.println(this.getClass().getName());
	}
}

אני עובד עם Eclipse, והוא נותן לי את השגיאה הבאה על this:

ציטוט:

Cannot use this in a static context

ושניסיתי להעביר את הבעיה למקום אחר:

קוד:

public class test {

	public static void main(String[] args) {
		System.out.println(returnName());
	}

	public String returnName(){
		return this.getClass().getName(); 
	}
	
}

הבעיה עברה למשתנה returnName, עם השגיאה:

ציטוט:

Cannot make a static reference to the non-static method returnName() from the type test

אשמח לעזרה.

תומר

תפעול מכשירים, סלולרי וגאדג'טים

אם יש לך אובייקט, אתה יכול לשאול אותו האם הוא instance of של מחלקה, אבל זו דרך די עקומה להשיג מה שרצית.
איך ע"י שימוש ב reflection אני יכול לדעת מאיזו מחלקה האובייקט שלי?

בברכה, מתן.
www.MatanNarkiss.com

מה זאת אומרת איך? כתבתי למעלה.
אתה שואל כל משתנה שיורש מ-Object (שזה כל משתנה חוץ מסט קבוע של primitives) מה המחלקה שלו על-ידי הפונקציה getClass.

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

אני לא חזק ב Java, אבל מן הסתם אתה צריך לעשות משהו כזה:

קוד:

 System.out.println(new test().returnName());

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

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

תומר

תפעול מכשירים, סלולרי וגאדג'טים

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

בברכה, מתן.
www.MatanNarkiss.com

ואז שיש לי מערך של מחלקות שיורשות, עליהם אני עושה את המתודה שמביאה את השם?

תומר

תפעול מכשירים, סלולרי וגאדג'טים

אתה נראה לי מתבלבל בין מחלקה (Class) למופע (Instance). אין כזה דבר מערך של מחלקות. מערך מאכסן מופעים בלבד.
(אפשר לקרוא למערך של מופעי המחלקה Class "מערך של מחלקות" אבל לא נראה לי שלזה התכוונת)

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

בברכה, מתן.
www.MatanNarkiss.com

אז אתה יכול לעשות פשוט ()arr[i].getClass().getName
או ליצור מתודה לא סטטית במחלקת האב שמחזירה ()this.getClass().getName

http://www.fresh.co.il/vBulletin/sh...176&postcount=3

בברכה, מתן.
www.MatanNarkiss.com

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

בברכה, מתן.
www.MatanNarkiss.com

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

פולימורפיזם? Generics?

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

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

לפי מה שאני זוכר Generics ב-Java זה סוג של בלוף כי תמיד מדובר באותו class מאחורה. כלומר מופע שהוא רשימה של T הוא בעצם מופע של רשימה של Object (בניגוד ל-NET. שם יש מעין sub class נפרד לכל generic ולא ניתן לעשות cast מאחד לשני (אגב ב-C# 4 דווקא אפשר באופנים מסוימים)).
לכן אין הבדל אם אתה מקבל רשימה של T או רשימה של S.
אני לא מספיק מכיר, אז יתכן שאני טועה.

אתה צודק, אבל אתה גם טועה.

Generics בג'אווה זה באמת בלוף במובן שזה רק syntactice sugar לפולירמופיזם, בניגוד
ל-C++‎ לדוגמה שבה קיים מנגנון ה-templates שבו משתמשים כמעין חלופה ל-Generics
(שחסר ב-C++‎ במידה מסוימת). אבל זה בלוף באותה מידה ב-C#‎.

ה-containers (כלומר המחלקות List, Queue, Set וכו' ב-java.util שיורשות מ-Collection - לא
כולל Array שזה משהו אחר) בג'אווה הם באמת ה-containers שהיו לפני הוספת ה-Generics,
עם תוספת הפיצ'ר של ה-Generics - הפיצ'ר שמאפשר וידוא שמכניסים (ולכן גם מוציאים) רק
אלמנטים מהטיפוס הנכון ב-compile-time במקום זוועת cast-ים ו-exceptions ב-run-time.

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

• http://72.5.124.102/thread.jspa?messageID=2606858
• http://www.javadocexamples.com/java...ters%28%29.html
• http://java.itags.org/java-core-apis/26760/

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

זה נראה מאמר רציני בנושא, ויכול להיות שהוא גם עונה על השאלה שלי (איך זה עובד למרות
מנגנון ה-type erasure), אבל אין לי כרגע זמן לקרוא אותו.

ב-C# זה לא בלוף, לפחות לא באותה מידה.
דבר ראשון, יש בזמן ריצה מעין תת-טיפוסים, ולא ניתן לעשות cast מרשימה של T לרשימה של S למשל.
בנוסף בקריאה למתודות, אין casting שרץ מאחורי הקוד.
כמו"כ, Generics שמוגדרים על primitives או structs לא עושים boxing אלא ממש מקצים values ולא references.
איזה עוד סיבות צריכות לשכנע אותך שזה לא בלוף?

זה בלוף טילים.

כל מה שנותנים Generics ב-C# זה syntactic sugar לפולימורפיזם. הטריק של זה שלא
עושים boxing (אגב, אתה יודע שבג'אווה כן יש autoboxing במקרה הזה?) הוא באמת
פולימורפיזם ב-C# בניגוד לבג'אווה, מאחר ובג'אווה הטיפוסים הפרימיטיביים הם שונים באופן
מהותי מכל המחלקות שיורשות מ-java.lang.Object, בעוד שבב-CTS של דוטנט (וזה כולל
את C#...) כל הטיפוסים (כולל "פרימיטיביים") יורשים מ-System.Object.

זה שאין casting ב-C# מ-containers גנריים שונים זה העדר פיצ'ר ולא תכונה גאונית של
ה-Generics ב-C#, והיא אמורה להיות מתוקנת ב-C# 4.0. אני ממליץ לך לקרוא את הפוסטים
הרלבנטיים בבלוג של אריק ליפרט (ובכלל את הבלוג שלו).

הביטוי "בקריאה למתודות, אין casting שרץ מאחורי הקוד" אינו מובן.

זה בלוף טילים.

כל מה שנותנים Generics ב-C# זה syntactic sugar לפולימורפיזם.
תצטרך להיות יותר ברור מה כוונך.
אני משער ששנינו מסכימים כי Generics נותנים ליצור מעין מחלקה אבסטרקטית שפרטי המימוש שלה זה המחלקות בה היא משתמשת. אני לא יודע אם זה יכול להיכנס למילים שלך.

הטריק של זה שלא
עושים boxing (אגב, אתה יודע שבג'אווה כן יש autoboxing במקרה הזה?) הוא באמת
פולימורפיזם ב-C# בניגוד לבג'אווה, מאחר ובג'אווה הטיפוסים הפרימיטיביים הם שונים באופן
מהותי מכל המחלקות שיורשות מ-java.lang.Object, בעוד שבב-CTS של דוטנט (וזה כולל
את C#...) כל הטיפוסים (כולל "פרימיטיביים") יורשים מ-System.Object.
אולי לא הייתי ברור כי אני לא מבין איך נכנס לדיון הקטע של הירושה מ-Object. הירושה מ-Object בעיקר בעלת משמעות במקרה של boxing, וזה בדיוק מה שהסברתי שלא קורה.
אני אסביר שוב:
נגיד מגדירים מחלקה גנרית <Bla<T עם Data member מטיפוס T. אם עושים <new Bla<object אז יוקצה לאובייקט מקום נוסף בגודל של pointer ואם עושים <new Bla<int יוקצה לאובייקט מקום נוסף בגודל של int לאסכון הערך.
העובדה כי int יורש מ-Object אינה משנה כלל להסבר הנ"ל.

זה שאין casting ב-C# מ-containers גנריים שונים זה העדר פיצ'ר ולא תכונה גאונית של
ה-Generics ב-C#, והיא אמורה להיות מתוקנת ב-C# 4.0. אני ממליץ לך לקרוא את הפוסטים
הרלבנטיים בבלוג של אריק ליפרט (ובכלל את הבלוג שלו).
אני מכיר את מה שיש בC# 4 אבל שים לב שבניגוד ל"פיצ'ר" של java, ניתן לעשות cast רק למחלקות יורשות או מחלקות אב, וזה רק אם הן מוגדרות כ-out או in (בהתאם או הפוך, לא זוכר). מיקרוסופט עשו הכל כדי לשמור עדיין על type safety.
תחשוב שאם יש לך מחסנית של T, לא הגיוני שתוכל לעשות cast למחסנית של Object כי אז ה-Push לא יהיה אtype safe ולא הגיוני שתוכל לעשות cast למחסנית של K היורש מ-T כי אז Pop לא יהיה type safe.

הביטוי "בקריאה למתודות, אין casting שרץ מאחורי הקוד" אינו מובן.
הכוונה היא למשל כאשר למחסנית של T עושים Pop אז לא מתבצע cast מ-Object ל-T (אין בדיקה ואין פתח ל-CastException, הכל type safe).