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

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

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

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

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

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

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

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Pet the cat: " + cat.getName());
   }

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

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

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

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

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

Cat cat = new Cat(7, "Bobby");
cat.meow();

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

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

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

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

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

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

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

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

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

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

public static void petTheCat(Cat cat) {
   System.out.println("Pet the cat: " + cat.getName());
}

כאן אנו רואים שבשיטה הסטטית petTheCat() קוראת getName , שיטה לא סטטית רגילה של אובייקט Cat .

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

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

public interface Animal {
    void speak();
}

דוגמה ליישום ממשק על ידי מחלקה

class Cat implements Animal {
 
   @Override
   public void speak() {
       System.out.println("Meow! Meow! Meow!");
   }
}

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

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

2. מחלקה יכולה ליישם ממשקים רבים (כפי שאמרתי, ממשקים הם חלופה להורשה מרובה). שמות הממשק מופרדים בפסיקים בכותרת השיטה: class Lion מיישמת Animal, Wild .

3. ממשקים נוצרים באמצעות מילת המפתח ממשק .

4. כאשר כיתה מיישמת ממשק, אנו משתמשים במילת המפתח implements .

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

6. המטרה העיקרית של שימוש בממשקים היא ליישם פולימורפיזם (כדי לתת לאובייקט את היכולת ללבוש צורות רבות).

7. ככלל, משנה גישה לשיטות אינם מצוינים בממשקים: הם ציבוריים כברירת מחדל, ולא ניתן לציין משנה פרט ל- public . החל מ-Java 9, אתה יכול להשתמש בשינויים פרטיים בשיטות.

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

9. לא ניתן ליצור מופע של ממשק.

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

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

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

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

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

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

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

אם ברצוננו להשתמש במחלקה אנונימית כדי ליצור ממשק נתון:

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

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

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

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

49. מהו שיעור עטיפה?

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

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

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

50. מהי מחלקה מקוננת? איפה משתמשים בו?

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

public class Zoo {
   class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

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

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.eat("apple");

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

public class Zoo {
   static class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

הוא נוצר במקצת שונה מהקודם:

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.eat("apple");

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

public class Zoo {
   public void feed(String animal, String food) {
       switch(animal) {
           case "zebra":
               class Zebra {
                   public void eat(String food) {
                       System.out.println("Zebra eats " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.eat(food);
               ...

הנה דוגמה:

Zoo zoo = new Zoo();
zoo.feed("zebra", "apple");

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

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

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

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

כאן נסיים להיום. נתראה בקרוב!