בג'אווה, ה' ClassCastException ” עוזר לזהות בעיות תאימות מסוג בזמן ריצה, על ידי כך שהוא מאפשר למפתחים לתפוס אותן בשלב מוקדם של שלב הפיתוח. זה גם מבטיח בטיחות סוג, מונע חוסר עקביות בתוכנית. ה-ClassCastException עוזר רבות בתהליך של איתור באגים, בדיקה, יציקת סוג נכון וכו'.
מדריך זה מדגים את ההליך לפתרון ClassCastException ב-Java.
איך ClassCastException מתעוררים ב-Java?
ה ' ClassCastException ” מבטיח יציקת סוגים נכונה ומונע שגיאות זמן ריצה הנגרמות מהמרות סוגים לא תואמים. במילים פשוטות, חריג זה נזרק כאשר מנסים להטיל אובייקט לסוג שאינו תואם.
לדוגמה, בקר בקוד שלהלן לגבי ' ClassCastException ' ב-Java:
יְבוּא java.io.* ;
יְבוּא java.lang.* ;
יְבוּא java.util.* ;
מעמד לינוקס רמז {
//יצירת כיתת נהגים
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args )
{
לְנַסוֹת {
לְהִתְנַגֵד הוֹרֶה = חָדָשׁ לְהִתְנַגֵד ( ) ;
חוּט יֶלֶד = ( חוּט ) הוֹרֶה ;
מערכת . הַחוּצָה . println ( יֶלֶד ) ;
}
לתפוס ( יוצא מן הכלל ו ) {
מערכת . הַחוּצָה . println ( ו ) ;
}
}
}
הסבר על הקוד לעיל:
- בתוך ה ' לְנַסוֹת ' בלוק, המופע של אובייקט ' הוֹרֶה 'מוכרז על ידי שימוש ב-' חָדָשׁ ' מילת מפתח.
- לאחר מכן, נעשה שימוש ב-typecasting שבו ' לְהִתְנַגֵד ' סוג נמצא בטיפוס ויש לו את השם ' יֶלֶד '.
- ה-typecasting זה מפר את הכלל שלפיו אסור להטיל את כיתה האב לכיתה הבת שלה. לכן יוצא החריג מכיוון ש' לְהִתְנַגֵד סוג הוא כיתת הורה.
- בסופו של דבר, ה' לתפוס נעשה שימוש בגוש שלוקח את ' יוצא מן הכלל ” כפרמטר ומדפיס הודעה בקונסולה.
לאחר סיום שלב הביצוע:
תמונת המצב שלמעלה מציגה את ההתרחשות של ClassCastException ב-Java.
כיצד לפתור את ClassCastException ב- Java?
נעשה שימוש בשלושה פתרונות אפשריים שהמפתח יכול לפתור בקלות או למנוע את הסיכוי להעלות את ' ClassCastException ' בג'אווה.
פתרונות אלה מתוארים להלן בנפרד:
פתרון 1: שימוש ב-'instanceof' אופרטור
ה ' מופע של ' המפעיל מוודא אם ' לְהִתְנַגֵד ” הוא מופע מהסוג הרצוי או לא. אימות זה מסייע במניעת התרחשות של ' ClassCastException '. לדוגמה, בקר בגוש הקוד שלהלן:
פּוּמְבֵּי מעמד TypeCheckingLinuxHint {פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
לְהִתְנַגֵד הוֹרֶה = 'משפחת LinuxHint' ;
אם ( הוֹרֶה מופע של חוּט ) {
חוּט יֶלֶד = ( חוּט ) הוֹרֶה ;
מערכת . הַחוּצָה . println ( 'לאחר שידור מחרוזת: ' + יֶלֶד ) ;
} אַחֵר {
מערכת . הַחוּצָה . println ( 'אובייקט הוא מופע מהסוג הרצוי String.' ) ;
}
}
}
הסבר על הקוד לעיל:
- קודם ה ' הוֹרֶה נוצר אובייקט שמאוחל עם ערך דמה בתוך ה-' לְנַסוֹת ' לחסום.
- לאחר מכן, השתמש ב- 'אם' הצהרה שבה ' מופע של אופרטור ' משמש כדי לבדוק את המופע של ' הוֹרֶה ' חפץ עם ' הרצוי ' חוּט 'סוג.
- לאחר מכן, אם התנאי חוזר ' נָכוֹן 'הטיפוס מבוצע ומוצג בקונסולה.
- אחרת, הודעת השגיאה המותאמת אישית מוצגת במסוף.
לאחר סיום שלב הביצוע:
תמונת המצב מראה ש-typecasting נעשה בהצלחה ו-ClassCastException נפתרה באמצעות ' מופע של ' מפעיל.
פתרון 2: סקור ותקן את פעולת ה-Typecasting
פתרון נוסף הוא לבדוק את הקוד מספר פעמים ולסקור את הסוגים התואמים ל-typecasting. לדוגמה, בקר בקוד שלהלן שבו ' ClassCastException ' נעצר עקב סוג רצוי שאינו תואם לטיפוס:
פּוּמְבֵּי מעמד TypeCheckLinuxHint {פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
לְהִתְנַגֵד הוֹרֶה = 'משפחת LinuxHint' ;
מספר שלם convertedNumber = ( מספר שלם ) הוֹרֶה ;
מערכת . הַחוּצָה . println ( 'מספר לאחר הטיפקאסט: ' + convertedNumber ) ;
}
}
בקוד לעיל, המתכנת הטיל בצורה שגויה את ' חוּט ' ל ' מספר שלם '.
לאחר סיום שלב ההידור:
תמונת המצב שלמעלה מראה את התרחשות של ClassCastException.
פתרון 3: שימוש בגנריות
המתכנתים יכולים להשתמש ב' גנריות ' כדי לציין את הסוגים הצפויים ולאכוף בטיחות סוג בזמן הקומפילציה.
לדוגמה, בקר בקוד הבא:
יְבוּא java.util.ArrayList ;יְבוּא java.util.List ;
פּוּמְבֵּי מעמד באמצעות Generics {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
רשימה < חוּט > empName = חָדָשׁ רשימת מערך <> ( ) ;
empName. לְהוֹסִיף ( 'לְהָצִיק' ) ;
empName. לְהוֹסִיף ( 'קַדָר' ) ;
חוּט התחלתי = empName. לקבל ( 0 ) ;
חוּט סופי = empName. לקבל ( 1 ) ;
מערכת . הַחוּצָה . println ( 'שם פרטי: ' + התחלתי ) ;
מערכת . הַחוּצָה . println ( 'שם שני: ' + סופי ) ;
}
}
הסבר על הקוד לעיל:
- ראשית, כלי השירות הנדרשים מיובאים לקובץ Java, ומחלקה של ' באמצעות Generics ' מוצהר.
- לאחר מכן, ה' רשימת מערך 'מהסוג' חוּט 'מוכרז בשם ' empName ' ואותחל על ידי מתן שני רכיבי נתוני דמה.
- לאחר מכן, צור שני משתנים מסוג מחרוזת בשם ' התחלתי ' ו' סופי '. לאחר מכן, הקצה ערכים על ידי גישה למספרי האינדקס.
- בסופו של דבר, הצג את שני המשתנים כדי לראות את התוצאה.
לאחר סיום הביצוע, הפלט נראה כך:
תמונת המצב לעיל ממחישה שהטיפוס בוצע באמצעות שימוש גנרי.
סיכום
כדי לפתור את ' ClassCastException ' ב-Java, המתכנת חייב להבטיח תאימות סוגים נאותים, שימוש ב-' גנריות ' וה ' מופע של ' מפעיל. כדי לפתור את החריגה, על המתכנת לבדוק ולתקן את פעולת הליהוק על ידי הבטחת תאימות סוגים נאותים. יתר על כן, זה ' ClassCastException ניתן להימנע על ידי שימוש ב- גנריות ' ועם שימוש ב' מופע של ' מפעיל. מדריך זה הדגים את השיטה לפתרון ה-ClassCastException ב-Java.