ניתוח שאלות ותשובות מראיונות למפתח Java. חלק 5

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

39. מהם משנה גישה ב-Java? תן להם שם. למה הם משמשים?

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

• public - רכיב עם משנה זה יהיה נגיש לציבור. הָהֵן. שדות ושיטות, מחלקות המוצהרות עם השינוי הציבורי גלויות למחלקות אחרות הן מהחבילה הנוכחית והן מחבילות חיצוניות;
• protected - רכיב עם משנה זה יהיה נגיש מכל מקום במחלקה הנוכחית של החבילה הנוכחית או במחלקות צאצאות, גם אם הן בחבילות אחרות;
• ברירת מחדל , או משנה חסר - משנה זה משמש באופן מרומז כאשר משנה הגישה לא צוין כלל. זה דומה לקודם, אלא שהראות מותרת בכיתות צאצאים שנמצאות בחבילות אחרות;
• private הוא הפרטי ביותר מבין כל המשתנים, המאפשר גישה לרכיב רק בתוך המחלקה הנוכחית.

40. שם את המאפיין העיקרי של שיטות סטטיות ומשתנות

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

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Погладить кота - " + cat.getName());
   }

אנחנו לא צריכים מופע של המחלקה CatService כדי לקרוא לזה :

Cat cat = new Cat(7, "Bobi");
CatService.petTheCat(cat);

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

class Cat {
   public void mew() {
       System.out.println("Meow! Meow! Meow!");
   }

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

Cat cat = new Cat(7, "Bobi");
cat.mew();

41. מהן ההגבלות העיקריות על שיטות סטטיות ו"משתנות"?

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

42. מה המשמעות של מילת המפתח הסטטית? האם ניתן לעקוף שיטה סטטית או להעמיס עליה?

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

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

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

43. האם שיטה יכולה להיות סטטית ומופשטת בו זמנית?

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

44. האם ניתן להשתמש בשיטות סטטיות באמצע רגילות? להיפך? למה?

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

public static void petTheCat(Cat cat) {
   System.out.println("Погладить кота - " + cat.getName());
}

כאן אנו רואים שהשיטה הסטטית petTheCat קוראת למתודה הרגילה והלא סטטית של האובייקט Cat - getName .

45. מהו ממשק? האם יכול להיות ממשק סופי?

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

public interface Animal {
    void voice();
}

דוגמה למימוש ממשק על ידי כיתה:

class Cat implements Animal {

   @Override
   public void voice() {
       System.out.println("Meow! Meow! Meow!");
   }
}

הדבר העיקרי שאתה צריך לדעת על שימוש בממשקים הוא:

1. שיטות ממשק צריכות להכיל רק כותרת, ללא גוף שיטה ספציפי, כלומר. חייב להיות מופשט (אך ללא שימוש במילת המפתח המופשטת ). החריג לכך הוא שיטות סטטיות ושיטות ברירת מחדל, הדורשות גוף שיטה.
2. מחלקה יכולה ליישם ממשקים רבים (כפי שאמרתי, זוהי חלופה להורשה מרובה), שנכתבים מופרדים בפסיקים: class Lion מיישמת Animal, Wild .
3. ממשקים נוצרים באמצעות ממשק מילת המפתח .
4. בעת הטמעת ממשק על ידי מחלקה, מילת המפתח היא implements .
5. מחלקה המיישמת ממשק מסוים חייבת ליישם את כל השיטות המופשטות שלה, או שהיא חייבת להכריז על עצמה כמופשטת.
6. המטרה העיקרית של שימוש בממשקים היא ליישם פולימורפיזם (היכולת של אובייקטים ללבוש צורות רבות).
7. ככלל, משנה גישה לשיטות לא נכתבים בממשק: הם ציבוריים כברירת מחדל, ולא ניתן לציין מתקנים אחרים מלבד ציבוריים . מאז Java 9, אתה יכול להשתמש בשינויים פרטיים עבור שיטות.
8. משתני ממשק הם סטטיים סופיים כברירת מחדל , במילים אחרות, קבועים: תמיד צריך לאתחל אותם ישירות בממשק.
9. לא ניתן ליצור אובייקט ממשק.

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

46. ​​היכן אוכל לאתחל שדות סטטיים?

ניתן לאתחל שדות סטטיים:

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

47. מהם שיעורים אנונימיים?

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

public final interface Animal {
   public void voice();
}

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

Animal cat = new Animal() {
   @Override
   public void voice() {
       System.out.println("Meow! Meow! Meow!");
   }
};

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

48. מהם כיתות פרימיטיביות?

מבחינתי, זו שאלה מאוד מוזרה ואולי זו שאלת מלכודת, כי בג'אווה אין דבר כזה מחלקות פרימיטיביות: חוץ אולי מהמושג טיפוסים פרימיטיביים, שכבר שקלנו קודם לכן. כזכור, ישנם 8 סוגים פרימיטיביים ב-Java - byte , short , int , long , float , double , char , boolean .

49. מהי מעמד ה"עטיפה"?

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

• byte -> Byte.class
• קצר -> מחלקה קצרה
• int -> Integer.class
• long -> Long.class
• float -> Float.class
• double -> Double.class
• char -> Character.class
• boolean -> Boolean.class

זהו ייצוג של טיפוסים פשוטים, אבל בצורה של שיעורים מן המניין עם חבורה של שיטות מגוונות ופונקציונליות. לשימוש נוח בשיעורים אלו, הוצגו המושגים של אוטובוקסינג ו-unboxing. Autoboxing - המרה אוטומטית מסוג פרימיטיבי למחלקה אנלוגית במידת הצורך (לדוגמה, int למספר שלם ). Unboxing הוא התהליך ההפוך מהקודם: המרה אוטומטית של מחלקה פרימיטיבית לסוג פרימיטיבי (לדוגמה, Integer ל- int ). הודות להכנסת שיעורי עטיפה פרימיטיביים ותהליכי ה-autoboxing ו- unboxing , טיפוסים פרימיטיביים הצליחו להפוך לחברים מן המניין בשפת OOP - Java. כדי ללמוד עוד על נושא זה, אני ממליץ בחום לקרוא מאמר זה .

50. מה זה כיתת Nested? מתי משתמשים בו?

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

public class Zoo {
   class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

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

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.toFeed("яблоко");

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

public class Zoo {
   static class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

שיטת היצירה שונה מעט מהקודמת:

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.toFeed("яблоко");

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

public class Zoo {
   public void toFeed(String animal, String food) {
       switch(animal){
           case "зебра":
               class Zebra {
                   void toFeedZebra(String food) {
                       System.out.println("Дать зебре - " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.toFeedZebra(food);
               ...

דוגמה לשימוש:

Zoo zoo = new Zoo();
zoo.toFeed("зебра", "яблоко");

בלי לראות את הקוד של שיטת toFeed , אפילו לא היית חושד בקיומה של מחלקה מקומית, נכון? מחלקה מקומית אינה יכולה להיות סטטית או חולפת , אך ניתן לסמן אותה כמופשטת או סופית ( רק OR, מכיוון ששימוש בשני המשתנים הללו יגרום להתנגשות). 4. כיתות אנונימיות כבר דיברנו למעלה על כיתות אנונימיות וכזכור ניתן ליצור אותן משני מקורות – ממשקים ומחלקות. הסיבות לשימוש במחלקות פנימיות סטטיות ולא סטטיות משמשות כי לפעמים עדיף להטמיע מחלקות קטנות בתוך מחלקות גדולות יותר ולשמור אותן יחד: כך תהיה להן לכידות גבוהה יותר ומטרה משותפת. למעשה, השימוש במחלקות מקוננות מגביר את כינוס הקוד. הסיבה לבחירת מחלקות מקומיות עשויה להיות שמחלקה נתונה משמשת אך ורק בשיטה אחת. במקרה זה, האם יש צורך להפיץ את הקוד בכל האפליקציה? לא. אך יחד עם זאת אוסיף כי בתרגול שלי מעולם לא ראיתי שימוש בשיעורים מקומיים, כי הצורך בהם שנוי מאוד במחלוקת. ובכן, הסיבה לשימוש במחלקות אנונימיות עשויה להיות שיישום ספציפי של ממשק או מחלקה אבסטרקטית יהיה צורך רק פעם אחת, כך שאין צורך ליצור מחלקה נפרדת ומלאה עם מימוש לכך. במקום זאת, בצורה פשוטה, הטמענו את השיטה/ים שהיינו צריכים דרך מחלקה אנונימית, השתמשנו באובייקט הזה ושכחנו ממנו (טוב, אספן הזבל זכר את זה). זה ומאמר זה יסייעו לך ללמוד שיעורים פנימיים ביתר פירוט .

51. אילו מגני גישה יכולים להיות למחלקה?

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

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

כאן נעצור היום. נתראה בקרוב!