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

שלום לכולם! היום אני ממשיך בסקירה שלי על שאלות ראיונות למפתחי Java.

29. האם ניתן להשתמש בהחזר בקונסטרוקטור?

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

public Cat(int age, String name, boolean isHomeless) {
   if (isHomeless){
       this.isHomeless = isHomeless;
       return;
   }
   this.isHomeless = isHomeless;
   this.age = age;
   this.name = name;
}

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

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

30. האם ניתן לזרוק חריג מבנאי?

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

public Cat() throws IOException {
   BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
   this.name = reader.readLine();
   this.age = Integer.parseInt(reader.readLine());
}

מכיוון ש- reader.readLine() זורק IOException, אנו כותבים אותו בכותרת כחריג אפשרי.

31. מהם המרכיבים של כותרת מחלקה? כתבו דוגמה

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

• רכיבי חובה מופיעים בסוגריים <>
• אלמנטים אופציונליים נמצאים ב-{}

{access modifier}{static}{final}{abstract}<class name>{הורשת של Parent class}{implementation of interfaces} אז, מה שיש לנו: { access modifier} — רק משנות הגישה הציבוריות וברירת המחדל זמינות עבור מעמד. {static} - השינוי הסטטי מציין שהמחלקה הזו סטטית; זה חל רק על מחלקות פנימיות (מחלקות בתוך מחלקות אחרות). {final} - זהו השינוי הסופי , כמובן, שהופך את המחלקה לבלתי ניתנת בירושה (דוגמה מחוץ לקופסה היא String ). {abstract} - המשנה המופשט , המציין שלמחלקה עשויות להיות שיטות לא מיושמות. השינוי הזה מתנגש עם השינוי הסופי . לכותרת המחלקה יכולה להיות רק אחת מהן, מכיוון שהמשנה המופשט פירושו שהמחלקה תעבור בירושה והאלמנטים המופשטים שלה ייושמו. אבל final מציין שזו הגרסה הסופית של המחלקה, ושלא ניתן להוריש אותה. למעשה, שימוש בו זמנית בשני המשתנים יהיה אבסורד. המהדר לא יאפשר לנו לעשות זאת. <class> היא מילת מפתח חובה שמציינת הצהרת מחלקה. <שם מחלקה> הוא שם מחלקה פשוט שהופך למזהה של מחלקת Java ספציפית. שם הכיתה המלא מורכב משם החבילה המותאמת בתוספת '.' בתוספת שם הכיתה הפשוט. {ירושה של מחלקת האב} הוא אינדיקציה למחלקת האב (אם בכלל) באמצעות מילת המפתח extends . לדוגמה, ... מרחיב את ParentClass . {יישום ממשקים} - רשימה של הממשקים שמחלקה זו מיישמת (אם יש), באמצעות מילת המפתח implements . לדוגמה: ... מיישם את FirstInterface, SecondInterface ... כדוגמה, שקול את כותרת המחלקה של המחלקה Lion , שיורשת את Cat ומיישמת את ממשק WildAnimal :

public final class Lion extends Cat implements WildAnimal

32. מהם המרכיבים של כותרת שיטה? כתבו דוגמה

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

• רכיבי חובה מופיעים בסוגריים <>
• אלמנטים אופציונליים נמצאים ב-{}

{access modifier}{static}{abstract}{final}{synchronized} {native} <return value><method name> <(>{method parameters}<}>{throw exceptions} {access modifier} — כל משנות הגישה הם זמין עבור השיטה — public , protected , default , private . {static} — השינוי הסטטי , המציין שהמתודה היא סטטית ולכן משויכת למחלקה, ולא לאובייקט. {abstract} — השינוי המופשט , המציין ש למתודה אין יישום (גוף). כדי לעבוד נכון, המחלקה שמצהירה על המתודה חייבת להיות בעלת גם את המודיפייר המופשט . כמו בכותרת המחלקה, השינוי הזה מתנגש עם השינוי הסופי , וגם מתנגש עם השינוי הסטטי , כי מתודה אבסטרקטית מרמזת לעקוף את השיטה בצאצא, ולא ניתן לעקוף שיטות סטטיות. {finale} - השינוי הסופי , מה שמציין שלא ניתן לעקוף שיטה זו. {מסונכרן} - השינוי המסונכרן , כלומר השיטה מוגנת מפני גישה בו זמנית אליו משרשורים שונים. אם השיטה אינה סטטית, אז היא סגורה עבור mutex זה של האובייקט. אם השיטה היא סטטית, אז היא סגורה עבור mutex של המחלקה הנוכחית. {native} - השינוי המקורי מציין שהשיטה כתובה בשפת תכנות אחרת. <סוג החזר> - סוג הערך שעל השיטה להחזיר. אם השיטה לא מחזירה כלום, אז בטל . <שם השיטה> - שם שם השיטה, כלומר המזהה שלה במערכת. {method parameters} — הפרמטרים שהשיטה מקבלת: הם נחוצים כדי ליישם את הפונקציונליות שלה. {thrown exceptions} — זורקת <ExceptionType> — רשימה של החריגים המסומנים ששיטה זו יכולה לזרוק. אני אציע את הדברים הבאים כדוגמה לכותרת שיטה:

public static void main(String[] args) throws IOException

33. צור בנאי ברירת מחדל במחלקת ילד אם אחד לא מוגדר כבר במחלקת הבסיס (אבל מוגדר בנאי אחר)

אני לא בטוח שהבנתי לגמרי את השאלה, אבל אולי זה אומר שיש לנו איזה בנאי כזה בכיתה האב:

public Cat(int age, String name) {
   this.age = age;
   this.name = name;
}

במקרה כזה, במחלקת האב, אנחנו בהחלט צריכים להגדיר בנאי שיאתחל את האב (כלומר לקרוא לבנאי האב):

public class Lion extends Cat {

   public Lion(int age, String name) {
       super(age, name);
   }
}

34. מתי משתמשים במילת המפתח הזו?

בג'אווה יש לזה שתי משמעויות שונות. 1. זוהי הפניה לאובייקט הנוכחי, למשל this.age = 9 . כלומר, זה מתייחס לאובייקט שבו הוא משמש ואליו מתייחס הקוד עם זה . המטרה העיקרית היא לשפר את קריאות הקוד ולמנוע עמימות. לדוגמה, אם שדה מופע וארגומנט מתודה בעלי אותו שם:

public void setName(String name) {
   this.name = name;
}

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

public Cat(int age, String name) {
   this(name);
   this.age = age;
}

public Cat(String name) {
   this.name = name;
}

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

1. this() עובד רק בבנאי.
2. הפניה לבנאי אחר חייבת להיות בשורה הראשונה של בלוק הבנאי (גוף). המשמעות היא שבנאי לא יכול לקרוא ליותר מבנאי (אחר) אחד מהמחלקה שלו.

35. מהו אתחול?

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

class Cat {
   private int age = 9;
   private String name = "Tom";

או להגדיר לאחר מעשה דרך הבנאי:

class Cat {
   private int age;
   private String name;

   public Cat(int age, String name) {
       this.age = age;
       this.name = name;
   }

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

class Cat {
   private int age;
   private String name;

   {
       age = 10;
       name = "Tom";
   }

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

class Cat {
   private static int age;
   private static String name;

   static{
       age = 10;
       name = "Tom";
   }

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

36. בהינתן כיתת Child ציבורית שמרחיבה את הורה, כתוב את סדר האתחול של האובייקט

בעת טעינת המחלקה Child , סדר האתחול יהיה כדלקמן:

1. שדות כיתה סטטיים של כיתת הורים .
2. בלוק אתחול סטטי של מחלקת האב .
3. שדות סטטיים של כיתת הילד .
4. בלוק אתחול סטטי של המחלקה Child .
5. שדות לא סטטיים של כיתת הורים .
6. בלוק אתחול לא סטטי של מחלקת האב .
7. בנאי כיתת הורים .
8. שדות לא סטטיים של כיתת Сhild .
9. בלוק אתחול לא סטטי של המחלקה Сhild .
10. הקונסטרוקטור של כיתת הילד .

37. איזה סוג של יחסים בין מחלקות (אובייקטים) אתה מכיר?

ישנם שני סוגים של משתנים ב-Java: טיפוסים פרימיטיביים והתייחסויות לאובייקטים מן המניין.

• יחסי IS-A

עקרון ה-IS-A של OOP מבוסס על הורשת כיתה או יישום של ממשקים. לדוגמה, אם כיתת האריה יורשת את Cat , אז אנו אומרים שהאריה הוא חתול :

Lion IS-A Cat

(אבל לא כל חתול הוא אריה ) אותו מצב קיים עם ממשקים. אם הכיתה Lion מיישמת את ממשק WildAnimal , אז הם קיימים גם בקשר:

Lion IS-A WildAnimal

• יש מערכת יחסים

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

Car HAS-A Passenger

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

Passenger HAS-A Car

38. אילו יחסי אובייקט אסוציאטיביים אתה מכיר?

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

public class Car {
   private List passengers = new ArrayList<>();

 void setPassenger(Passenger passenger) {
     passengers.add(passenger);
 }

   void move() {
       for (Passenger passenger : passengers) {
           System.out.println("Transporting passenger - " + passenger.toString());
       }
       passengers.clear();
   }
}

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

public class Car {
   private Engine engine;

   public Car(Engine engine) {
       this.engine = engine;
   }

   void startMoving() {
       engine.start();
           ...
   }

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