streamalism.org

1. הקדמה

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

2. שאלות שפת Core-Java למתחילים

שאלה 1. האם נתונים מועברים לפי הפניה או לפי ערך ב- Java?

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

1. עוברים לפי ערך - זה אומר שאנחנו עוברים העתק של אובייקט כפרמטר לשיטה.
2. עוברים לפי התייחסות - זה אומר שאנחנו עוברים התייחסות לאובייקט כפרמטר לשיטה.

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

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

אנו יכולים ללמוד עוד על כך באחד המאמרים שלנו: Pass-By-Value as a Parameter Passing Mechanism ב- Java.

שאלה 2. מה ההבדל בין יבוא ויבוא סטטי?

אנו יכולים להשתמש בייבוא ​​רגיל לייבוא ​​מחלקה ספציפית או את כל המחלקות המוגדרות בחבילה אחרת:

ייבא java.util.ArrayList; // ייבוא ​​מחלקה ספציפי java.util. *; // כל השיעורים בחבילת util

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

יבוא com.baeldung.A. *

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

יש גם ייבוא ​​סטטי שמאפשר לנו לייבא חברים סטטיים או מחלקות מקוננות:

ייבא java.util.Collections.EMPTY_LIST סטטי;

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

שאלה 3. אילו משתני גישה קיימים ב- Java ומה מטרתם?

ישנם ארבעה משתני גישה ב ג'אווה:

1. פְּרָטִי
2. בְּרִירַת מֶחדָל (חֲבִילָה)
3. מוּגָן
4. פּוּמְבֵּי

ה פְּרָטִי modifier מבטיח כי חברי הכיתה לא יהיו נגישים מחוץ לכיתה. ניתן ליישם אותו על שיטות, מאפיינים, בונים, כיתות מקוננות, אך לא על כיתות ברמה העליונה.

לא כמו ה פְּרָטִי , אנו יכולים להחיל את בְּרִירַת מֶחדָל משנה לכל סוגי חברי הכיתה ולכיתה עצמה. אנחנו יכולים להגיש בקשה בְּרִירַת מֶחדָל חשיפה על ידי לא להוסיף שום שינוי גישה בכלל. אם נשתמש בְּרִירַת מֶחדָל נראות הכיתה שלנו או חבריה תהיה נגישה רק בתוך החבילה של הכיתה שלנו. עלינו לזכור שלמשנה הגישה המוגדר כברירת מחדל אין שום דבר משותף עם ה- בְּרִירַת מֶחדָל מילת מפתח.

בדומה ל בְּרִירַת מֶחדָל משנה, כל הכיתות בתוך חבילה אחת יכולות לגשת מוּגָן חברים. מה גם שה- מוּגָן modifier מאפשר לקבוצות משנה לגשת לחברים המוגנים של Superclass, גם אם הם לא נמצאים באותה חבילה. איננו יכולים להחיל את שינוי הגישה הזה על כיתות, רק על חברי הכיתה.

ה פּוּמְבֵּי ניתן להשתמש בשינוי יחד עם מילת מפתח בכיתה וכל חברי הכיתה. זה מנגיש את השיעורים ואת חברי הכיתה בכל החבילות ולכל הכיתות.

אנו יכולים ללמוד עוד במאמר Java Access Modifiers.

שאלה 4. אילו משנים אחרים זמינים בג'אווה ומה מטרתם?

ישנם חמישה שינויים נוספים הזמינים ב- Java:

• סטָטִי
• סופי
• תַקצִיר
• מסונכרן
• נָדִיף

אלה אינם שולטים על הנראות.

קודם כל, אנחנו יכולים ליישם את סטָטִי מילת מפתח לשדות ושיטות. שדות או שיטות סטטיים הם חברי כיתה, בעוד שאינם סטטיים הם חברי אובייקט. חברי הכיתה אינם זקוקים למופע כלשהו. הם נקראים עם שם המחלקה במקום שם הפניה לאובייקט. מאמר זה מפרט יותר על ה- סטָטִי מילת מפתח.

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

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

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

מילת המפתח האחרונה בה נדון היא נָדִיף. אנו יכולים להשתמש בו רק יחד עם שדות מופעים. הוא מצהיר כי יש לקרוא את ערך השדה ולכתוב אותו לזיכרון הראשי - תוך עקיפת מטמון המעבד. כל הקריאה והכתיבה של משתנה נדיף הם אטומיים. מילת המפתח הפכפכה מוסברת בפירוט במאמר זה.

ש 5. מה ההבדל בין JDK, JRE ו- JVM?

JDK מייצג ערכת פיתוח ג'אווה, שהוא סט כלים הדרושים למפתחים לכתוב יישומים בג'אווה. ישנם שלושה סוגים של סביבות JDK:

• מהדורה רגילה - ערכת פיתוח ליצירת יישומי שולחן עבודה או שרתים ניידים
• מהדורת Enterprise - הרחבה למהדורה הסטנדרטית עם תמיכה במחשוב מבוזר או שירותי אינטרנט
• מהדורת מיקרו - פלטפורמת פיתוח ליישומים מוטבעים וניידים

ישנם הרבה כלים הכלולים ב- JDK אשר לעזור למתכנתים בכתיבה, ניפוי באגים או תחזוקת יישומים. הפופולריים ביותר הם מהדר (ג'אוואק), מתורגמן (ג'אווה), ארכיב (קַנקַן) ומחולל תיעוד (javadoc).

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

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

למידע נוסף, בואו לבדוק את המאמר ההבדל בין JVM, JRE ו- JDK.

שאלה 6. מה ההבדל בין ערימה לערימה?

ישנם שני חלקי זיכרון בהם כל המשתנים והאובייקטים מאוחסנים על ידי ה- JVM. הראשון הוא ה לַעֲרוֹם והשני הוא ה ערימה.

ה לַעֲרוֹם הוא מקום בו ה- JVM שומר חסימות למשתנים מקומיים ונתונים נוספים. הערימה היא LIFO (האחרון בכניסה הראשונה). המשמעות היא שבכל פעם שמתקשרת לשיטה, שמור בלוק חדש למשתנים מקומיים ולהפניות אובייקט. כל הפעלת שיטה חדשה שומרת על החסימה הבאה. כאשר השיטות מסיימות את הביצוע שלהן, משוחררים חסימות באופן שהופעל.

לכל פתיל חדש יש ערימה משלו.

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

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

אנו יכולים למצוא פרטים נוספים במאמר Stack Memory ו- Heap Space ב- Java.

ש 7. מה ההבדל בין ניתן להשוות ו משווה ממשקים?

לפעמים כשאנחנו כותבים כיתה חדשה, נרצה להיות מסוגלים להשוות בין אובייקטים מאותה כיתה. זה מועיל במיוחד כאשר אנו רוצים להשתמש באוספים ממוינים. ישנן שתי דרכים בהן אנו יכולים לעשות זאת: באמצעות ניתן להשוות ממשק או עם משווה מִמְשָׁק.

ראשית, בואו נסתכל על ה- ניתן להשוות מִמְשָׁק:

ממשק ציבורי השווה {int CompareTo (T var1); }

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

יש לו את בהשוואה ל() שיטה ומחזירה מספר שלם. הוא יכול להחזיר שלושה ערכים: -1, 0 ו- 1, מה שאומר שהאובייקט הזה הוא פחות או יותר מהאובייקט שהושווה.

ראוי להזכיר כי העוקף CompareT0 () השיטה צריכה להיות עקבית עם שווים() שיטה.

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

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

כמו בהשוואה ל() השיטה, המעוקפת לְהַשְׁווֹת() השיטות צריכות להיות עקביות עם שווים() שיטה, אך הם עשויים לאפשר השוואה עם אפסים.

בואו לבקר במאמר השווה והשוואה ב- Java למידע נוסף.

ש 8. מה ה בָּטֵל סוג ומתי אנו משתמשים בו?

בכל פעם שאנחנו כותבים שיטה בג'אווה, עליה להיות בעלת סוג החזרה. אם אנו רוצים שהשיטה לא תחזיר שום ערך, נוכל להשתמש ב- בָּטֵל מילת מפתח.

עלינו גם לדעת שיש בָּטֵל מעמד. זהו מעמד של מציין מיקום שעשוי לשמש, למשל, בעבודה עם גנריות. ה בָּטֵל לא ניתן לייצר או להרחיב את הכיתה.

שאלה 9. מהן השיטות של מעמד האובייקטים ומה הן עושות?

חשוב לדעת באילו שיטות לְהִתְנַגֵד הכיתה מכילה ואיך הם עובדים. זה גם מועיל מאוד כאשר אנו רוצים לבטל את השיטות האלה:

• שיבוט () - מחזיר עותק של אובייקט זה
• שווים() - החזרות נָכוֹן כאשר אובייקט זה שווה לאובייקט שהועבר כפרמטר
• לְסַכֵּם() - אספן האשפה קורא לשיטה זו בזמן שהיא מנקה את הזיכרון
• getClass () - מחזיר את מחלקת זמן הריצה של אובייקט זה
• hashCode () - מחזיר קוד hash של האובייקט הזה. עלינו להיות מודעים לכך שהיא צריכה להיות עקבית עם שווים() שיטה
• לְהוֹדִיעַ() - שולח התראה לשרשור יחיד שמחכה לצג האובייקט
• notifyAll () - שולח הודעה לכל הנושאים שמחכים לצג האובייקט
• toString () - מחזיר ייצוג מחרוזות של אובייקט זה
• לַחֲכוֹת() - יש שלוש גרסאות עמוסות של שיטה זו. זה מכריח את השרשור הנוכחי להמתין למשך הזמן שצוין עד לשרשור אחר לְהוֹדִיעַ() אוֹ notifyAll () על האובייקט הזה.

ש 10. מהו אנום ואיך נוכל להשתמש בו?

Enum הוא סוג של מחלקה המאפשרת למפתחים לציין קבוצה של ערכי קבוע מוגדרים מראש. כדי ליצור מעמד כזה עלינו להשתמש ב- enum מילת מפתח. בואו נדמיין אנום של ימי השבוע:

יום האומה הציבורי {יום ראשון, יום שני, יום שלישי, יום רביעי, יום חמישי, יום שישי, יום שבת}

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

למרות שזה סוג מיוחד של כיתות, אנחנו לא יכולים לסווג אותו משנה. אולם, אולם יכול ליישם ממשק.

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

אנו יכולים למצוא מידע נוסף על Enums באחד המדריכים שלנו.

שאלה 11. מה זה א קַנקַן?

קַנקַן הוא קיצור דרך עבור ארכיון Java. זהו קובץ ארכיון הארוז בתבנית קובץ ZIP. אנו יכולים להשתמש בו כדי לכלול את קבצי המחלקה ומשאבי העזר הדרושים ליישומים. יש לו תכונות רבות:

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

שאלה 12. מה זה אNullPointerException?

ה NullPointerException הוא כנראה החריג הנפוץ ביותר בעולם ג'אווה. זה חריג לא מסומן וכך הוא מתרחב חריגת זמן ריצה. אנחנו לא צריכים לנסות להתמודד עם זה.

חריג זה נזרק כאשר אנו מנסים לגשת למשתנה או לקרוא לשיטה של ​​התייחסות null, כמו מתי:

• הפעלת שיטה של ​​התייחסות אפסית
• הגדרה או קבלת שדה של הפניה אפסית
• בדיקת אורך הפניה למערך אפס
• הגדרת או קבלת פריט של הפניה למערך null
• זְרִיקָה ריק

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

אנו יכולים להבחין בשני סוגי הליהוק בג'אווה. אנו יכולים לעשות upcasting שהוא יציקת אובייקט לסוג-על או downcasting אשר מטיל אובייקט לתת-סוג.

מעלים מאוד פשוט, כמו שאנחנו תמיד יכולים לעשות את זה. לדוגמא, אנו יכולים להפיל את א חוּט למשל ל לְהִתְנַגֵד סוּג:

אובייקט str = "מחרוזת";

לחלופין, אנחנו יכולים שָׁחוּחַ משתנה. זה לא בטוח כמו הלהקה כפי שהוא כרוך בבדיקת סוג. אם אנו מטילים לא נכון אובייקט, ה- JVM יזרוק א ClassCastExcpetion בזמן ריצה. למרבה המזל, אנו יכולים להשתמש ב- מופע של מילת מפתח למניעת ליהוק לא חוקי:

אובייקט o = "מחרוזת"; String str = (String) o; // זה בסדר אובייקט o2 = אובייקט חדש (); מחרוזת str2 = (מחרוזת) o2; // ClassCastException יושלך אם (o2 מופע של מחרוזת) {// מחזיר שקר מחרוזת str3 = (מחרוזת) o2; }

אנו יכולים ללמוד עוד על יציקת סוג במאמר זה.

3. שאלות שפת Core-Java עבור מתכנתים מתקדמים

שאלה 1. מדוע מחרוזת היא מעמד שאינו משתנה?

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

1. הם מאוחסנים ב בריכת מיתרים שהוא חלק מיוחד בזיכרון הערימה. זה אחראי לחיסכון רב במקום.
2. חוסר השינוי של חוּט class מבטיח שקוד ה- hash שלו לא ישתנה. בשל עובדה זו, מיתרים יכול לשמש ביעילות כמפתחות באוספי hashing. אנו יכולים להיות בטוחים שלא נעקום נתונים בגלל שינוי בקודי hash.
3. ניתן להשתמש בהם בבטחה על פני מספר נושאים. שום שרשור לא יכול לשנות את הערך של חוּט אובייקט, כך שאנו מקבלים בטיחות חוטים בחינם.
4. אי אפשר לשנות את המיתרים כדי למנוע בעיות ביטחוניות חמורות. ניתן לשנות נתונים רגישים כגון סיסמאות על ידי מקור לא אמין או שרשור אחר.

אנו יכולים ללמוד עוד על אי-השתנות של מיתרים במאמר זה.

שאלה 2. מה ההבדל בין כריכה דינמית לכריכה סטטית?

כריכה בג'אווה היא תהליך של שיוך קריאת שיטה לגוף השיטה המתאימה. אנו יכולים להבחין בין שני סוגי כריכה בג'אווה: סטטי ודינמי.

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

כריכה סטטית משתמש במידע כיתתי לצורך כריכה. היא אחראית לפתור חברי כיתה שכן פְּרָטִי אוֹ סטָטִי ו סופי שיטות ומשתנים. כמו כן, קשירה סטטית מחייבת שיטות עמוסות.

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

שאלה 3. מה זה JIT?

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

זה שונה מהמהדר Java הרגיל שמרכז את הקוד הרבה לפני תחילת היישום. JIT יכולה להאיץ את היישום בדרכים שונות.

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

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

שאלה 4. מהי השתקפות בג'אווה?

השתקפות היא מנגנון חזק מאוד בג'אווה. השתקפות היא מנגנון של שפת Java המאפשר למתכנתים לבחון או לשנות את המצב הפנימי של התוכנית (מאפיינים, שיטות, מחלקות וכו ') בזמן הריצה. חבילת java.lang.reflect מספקת את כל הרכיבים הנדרשים לשימוש בבבואה.

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

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

כשעובדים עם מודולים מאז Java 9, עלינו לדעת שכברירת מחדל, איננו יכולים להשתמש בהשתקפות על שיעורים המיובאים ממודול אחר. כדי לאפשר לשיעורים אחרים להשתמש בהשתקפות כדי לגשת לחברים הפרטיים בחבילה עלינו להעניק את ההרשאה "השתקפות".

מאמר זה מעמיק יותר בנושא השתקפות Java.

ש 5. מה זה א מטען כיתות?

ה מטען כיתות הוא אחד המרכיבים החשובים ביותר בג'אווה. זה חלק מה- JRE.

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

• Bootstrap classloader - הוא טוען את שיעורי הליבה של Java. הם ממוקמים ב / jre / lib מַדרִיך
• מטען כיתות הרחבה - הוא טוען שיעורים הממוקמים ב / jre / lib / ext או בנתיב שהוגדר על ידי java.ext.dirs תכונה
• מעמיס מחלקות מערכת - הוא טוען שיעורים על מסלול הכיתה של היישום שלנו

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

יש מידע נוסף על עומסי כיתות במאמר Class Loaders ב- Java.

שאלה 6. מה ההבדל בין טעינת כיתה סטטית לדינמית?

טעינת כיתות סטטית מתבצעת כשיש לנו שיעורי מקור זמינים בזמן הקומפילציה. אנו יכולים לעשות בו שימוש על ידי יצירת מופעי אובייקט באמצעות ה- חָדָשׁ מילת מפתח.

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

Class.forName ("oracle.jdbc.driver.OracleDriver") 

ש 7. מה מטרת ה - ניתן לבצע סדרתי מִמְשָׁק?

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

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

• ליישם את ניתן לבצע סדרתי מִמְשָׁק
• להבטיח כי בונה אין ויכוח נמצא במעמד העל

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

ש 8. האם יש ג'אווה הורס בג'אווה?

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

במקרה שהאובייקטים מחזיקים שקעים פתוחים, קבצים פתוחים או חיבורי בסיס נתונים, אספן האשפה אינו מסוגל להשיב את המשאבים הללו. אנחנו יכולים לשחרר את המשאבים ב- סגור שיטה ושימוש נסה סוף סוף תחביר להתקשר לשיטה לאחר מכן לפני Java 7, כגון שיעורי הקלט / פלט FileInputStreamו FileOutputStream. נכון ל- Java 7, אנו יכולים ליישם ממשק ניתן לסגירה אוטומטית ולהשתמש נסה עם משאבים הצהרה לכתוב קוד קצר ונקי יותר. אך יתכן שמשתמשי ה- API שוכחים להתקשר אל סגור שיטה, כך לְסַכֵּם שיטה ו מְנַקֶה הכיתה מתעוררת כדי לשמש רשת הביטחון. אך אנא שימו לב שהם אינם מקבילים להרס.

זה לא מובטח לשניהם הגמר שיטה ו מְנַקֶה הכיתה תפעל במהירות. הם אפילו לא מקבלים שום סיכוי לרוץ לפני יציאת ה- JVM. למרות שיכולנו להתקשר System.runFinalization להציע ל- JVM להפעיל את לְסַכֵּם שיטות של אובייקטים כלשהם הממתינים לסיום, זה עדיין לא דטרמיניסטי.

יתר על כן, ה לְסַכֵּם השיטה עלולה לגרום לבעיות ביצועים, חסימות נעילה וכו '. אנו יכולים למצוא מידע נוסף על ידי עיון באחד המאמרים שלנו: מדריך לשיטת הגמר ב- Java.

נכון ל- Java 9, מְנַקֶה מחלקה מתווספת כדי להחליף את לְסַכֵּם שיטה בגלל החסרונות שיש לו. כתוצאה מכך, יש לנו שליטה טובה יותר על החוט שעושה את פעולות הניקוי.

אך מפרט ה- Java מציין את התנהגותם של חומרי הניקוי במהלך System.exit הוא יישום ספציפי ו- Java אינה מספקת שום אחריות אם פעולות ניקוי יופעלו או לא.