שאלות ראיון ותשובות ל- Java SE 8 (חלק 2)

מדריכים
Java

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

שאלות ראיון Java SE 8

  1. מהו האיטרציה הפנימית ב-Java SE 8?
  2. מה ההבדלים בין איטרציה חיצונית ואיטרציה פנימית?
  3. מהם החסרונות העיקריים של איטרציה חיצונית?
  4. מהם היתרונות העיקריים של איטרציה פנימית מעל איטרציה חיצונית?
  5. מה החסרון העיקרי של איטרציה פנימית מעל איטרציה חיצונית?
  6. מה היתרון העיקרי של איטרציה חיצונית מעל איטרציה פנימית?
  7. מתי צריך להשתמש באיטרציה פנימית? מתי צריך להשתמש באיטרציה חיצונית?
  8. מהם ההבדלים בין פעולות אמצעיות ופעולות סופיות של API הזרמים של Java 8?
  9. האם אפשר לספק מימושי שיטות בממשקי Java? אם כן, איך אנחנו עושים זאת?
  10. מהו שיטת ברירת מחדל? למה אנחנו צריכים שיטות ברירת מחדל בממשקי Java 8?
  11. מהו שיטת סטטי? למה אנחנו צריכים שיטות סטטיות בממשקי Java 8?
  12. שוני בין תכנות פונקציונלי לבין תכנות מונחה עצמים?
  13. הסבר על בעיות ב-Old Java Date API? מהם היתרונות של Date and Time API של Java 8 בהשוואה ל-Old Date API ול-Joda Time API?
  14. למה נזקקים ל-API חדש של תאריכים ושעות ב-Java SE 8? הסבר כיצד Java SE 8 Data and Time API פותר את בעיותיהן של Old Java Date API?
  15. מהם ההבדלים בין OLD Java Date API של Java לבין Date and Time API של Java 8?
  16. מהו ירושה מרובה? איך Java 8 תומך בירושה מרובה?
  17. מהו בעיה היהלומים (Diamond Problem) בממשקים עקביים כתוצאה משיטות ברירת המחדל? איך פותרת Java 8 את הבעיה הזו?

שאלות ותשובות ראיונות Java SE 8

מהו האיטרציה הפנימית ב-Java SE 8?

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

ההבחנה בין תרחום חיצוני לבין תרחום פנימי?

S.No. External Iteration Internal Iteration
1. Available before Java 8 too. It is introduced in Java SE 8
2. Iterating an Aggregated Object elements externally. Iterating an Aggregated Object elements internally (background).
3. Iterate elements by using for-each loop and Iterators like Enumeration, Iterator, ListIterator. Iterate elements by using Java API like “forEach” method.
4. Iterating elements in Sequential and In-Order only. Not required to iterate elements in Sequential order.
5. It follows OOP approach that is Imperative Style. It follows Functional Programming approach that is Declarative Style.
6. It does NOT separate responsibilities properly that is, it defines both “What is to be done” and “How it is to be done”. It defines only “What is to be done”. No need to worry about “How it is to be done”. Java API takes care about “How to do”.
7. Less Readable Code. More Readable code.

מהם החסרונות המרכזיים של תרחום חיצוני?

תרחום חיצוני כולל את החסרונות הבאים:

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

מהם היתרונות המרכזיים של האיטרציה הפנימית מעל האיטרציה החיצונית?

בהשוואה לאיטרציה חיצונית, האיטרציה הפנימית יש לה את היתרונות הבאים:

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

מהו החסרון המרכזי של האיטרציה הפנימית מעל האיטרציה החיצונית?

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

  • באיטרציה פנימית, בעוד שממשק ה- API של Java טופל על איטרציה של האלמנטים פנימית, אין לנו שליטה על האיטרציה.

מהו היתרון המרכזי של האיטרציה החיצונית מעל האיטרציה הפנימית?

בהשוואה לאיטרציה פנימית, יש לאיטרציה חיצונית יתרון מרכזי אחד:

  • באיטרציה חיצונית, מפונטת ל- API של Java טופל על איטרציה של האלמנטים, ולכן יש לנו שליטה רבה יותר על האיטרציה.

מתי יש להשתמש באיטרציה פנימית? מתי יש להשתמש באיטרציה חיצונית?

יש להבין את המצבים בהם יש להשתמש באיטרציה פנימית או חיצונית.

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

השוני בין פעולות הביניים לבין פעולות הסוף של ממשק ה-Stream API של Java 8?

S.No. Stream Intermediate Operations Stream Terminal Operations
1. Stream Intermediate operations are not evaluated until we chain it with Stream Terminal Operation. Stream Terminal Operations are evaluated on it’s own. No need other operations help.
2. The output of Intermediate Operations is another Stream. The output of Intermediate Operations is Not a Stream. Something else other than a Stream.
3. Intermediate Operations are evaluated Lazily. Terminal Operations are evaluated Eagerly.
4. We can chain any number of Stream Intermediate Operations. We can NOT chain Stream Terminal Operations.
5. We can use any number of Stream Intermediate Operations per Statement. We can use only one Stream Terminal Operation per Statement.

האם אפשר לספק מימושים של שיטות בממשקי Java? אם כן, איך נספק אותם?

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

  • שיטות ברירת מחדל
  • שיטות סטטיות

מהו שיטת ברירת המחדל? למה אנו זקוקים לשיטות ברירת מחדל בממשקי Java 8?

A Default Method is a method which is implemented in an interface with “default” keyword. It’s new featured introduced in Java SE 8. We need Default Methods because of the following reasons:

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

מהו שיטת סטטית? למה אנו זקוקים לשיטות סטטיות בממשקים של ג'אווה 8?

A Static Method is an Utility method or Helper method, which is associated to a class (or interface). It is not associated to any object. We need Static Methods because of the following reasons:

  • ניתן לשמור על שיטות עזר או יוטיליטי הקשורות לממשק באותו ממשק במקום במחלקת יוטיליטי נפרדת.
  • אין צורך במחלקות יוטיליטי נפרדות כמו Collections, Arrays וכדומה.
  • הפרדה ברורה של אחריות – אין צורך במחלקת יוטיליטי אחת לשמירה של כל השיטות הטובות של אפי קולקשן כמו Collections וכו'.
  • קלות בהרחבת ה- API.
  • נוחות בתחזוקת ה- API.

הבדלים בין תכנות פונקציונלי לבין תכנות מונחה עצמים?

Functional Programming OOP
Does not exist State Exists State
Uses Immutable data Uses Mutable data
It follows Declarative Programming Model It follows Imperative Programming Model
Stateless Programming Model Stateful Programming Model
Main Fcous on: “What you are doing” Main focus on “How you are doing”
Good for Parallel (Concurrency) Programming Poor for Parallel (Concurrency) Programming
Good for BigData processing and analysis NOT Good for BigData processing and analysis
Supports pure Encapsulation It breaks Encapsulation concept
Functions with No-Side Effects Methods with Side Effects
Functions are first-class citizens Objects are first-class citizens
Primary Manipulation Unit is “Function” Primary Manipulation Unit is Objects(Instances of Classes)
Flow Controls: Function calls, Function Calls with Recursion Flow Controls: Loops, Conditional Statements
It uses “Recursion” concept to iterate Collection Data. It uses “Loop” concept to iterate Collection Data. For example:-For-each loop in Java
Order of execution is less importance. Order of execution is must and very important.
Supports both “Abstraction over Data” and “Abstraction over Behavior”. Supports only “Abstraction over Data”.
We use FP when we have few Things with more operations. We use OOP when we have few Operations with more Things. For example: Things are classes and Operations are Methods in Java.

הערה: למידע נוסף על השוואת FP, IP ו-OOP, נא לעיין בפוסט הקודם שלי בכתובת: "השוואת FP, OOP(IP)"

למה לקוחים ב-API הישן של Java? מהם יתרונות ה-API של Java 8 ביחס ל-API הישן ול-API של Joda Time?

ה-API הישן של Java מתייחס ל-API הקיים לפני Java SE 8, כלומר Date, Calendar, SimpleDateFormat וכדומה. ל-API הישן של Java יש בעיות או חסרונות השווים ל-API של Java 8 ול-Joda Time API.

  • רוב ה-API הוא מוסר.
  • קריאות פחותה.
  • java.util.Date היא משתנה ולא יציב באשר לפעולות תפריט.
  • java.text.SimpleDateFormat אינו יציב באשר לפעולות תפריט.
  • ביצועים נמוכים יותר.

ה-API לתאריך ולשעה של Java SE 8 כולל את היתרונות הבאים ביחס ל-API הישן של Java.

  • פשוט מאוד לשימוש.
  • תחביר שניתן לקריאה הינו קריא יותר.
  • כל ה-API הינם יציבים לפעולה רצינית.
  • ביצועים טובים יותר.

למה אנחנו זקוקים ל-API חדש לתאריך ושעה ב-Java SE 8? הסבר כיצד API החדש של Java SE 8 פותר את בעיות ה-API הישן של Java Date?

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

אילו הבדלים בין ה-API הישן של Java Date לבין ה-API לתאריך ושעה של Java 8?

ההבדלים בין ה-API הישן של Java Date לבין ה-API לתאריך ושעה של Java 8:

S.No. Java’s OLD Java Date API Java 8’s Date and Time API
1. Available before Java 8 too. It is introduced in Java SE 8
2. Not Thread Safe. Thread Safe.
3. Mutable API. Immutable API.
4. Less Performance. Better Performance.
5. Less Readability. More Readability.
6. It’s not recommended to use as its deprecated. It’s always recommended to use.
7. Not Extendable. Easy to Extend.
8. It defines months values from 0 to 11, that is January = 0. It defines months values from 1 to 12, that is January = 1.
9. It’s an old API. It’s a new API.

מהו יירוש רבתי? כיצד Java 8 תומכת בירוש רבתי?

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

מהו בעיה של יהלומים בממשקים בשל שיטות ברירת מחדל? כיצד Java 8 פותרת את הבעיה הזו?

Java 8 שיטות ברירת המחדל יכולות להביא לבעיה היהלומית כאשר מחלקה מממשת מספר רב של ממשקים. הבעיה מתרחשת כאשר מחלקה מרחיבה יותר מדי ממשקים עם אותם מימושים של שיטות ברירת המחדל (). קטע קוד לדוגמה ב-Java SE 8 מראה את בעיה היהלומה עם שיטות ברירת המחדל של ממשק (

interface A {
	default void display() {
		System.out.println("A");
	}
}

interface B extends A {
	default void display() {
		System.out.println("B");
	}
}

interface C extends A {
	default void display() {
		System.out.println("C");
	}
}

class D implements B, C {
}

).

בקטע הקוד למעלה, המחלקה D יוצאת עם שגיאה בזמן קומפילציה "Duplicate default methods named display with the parameters () and () are inherited from the types C and B". זה בגלל שמהדר ה-Java יתבלבל לגבי איזו display() להשתמש במחלקה D. המחלקה D מורישה את מתודת display() משני הממשקים B ו-C. כדי לפתור את הבעיה הזו, Java 8 סיפקה פתרון הבא: 

class D implements B, C {

	@Override
	public void display() {
		B.super.display();
	}
	
}

\[
\text{{B.super.display();}}
\]

זה יפתור את בעיה היהלומה הזו. אם ברצונך להשתמש בשיטה ברירת המחדל של ממשק C, אז ניתן להשתמש ב-C.super.display();. זהו הכל בנוגע לשאלות ראיון ב-Java 8. נדבר עוד על כמה שאלות נוספות בנושא בפוסטים הבאים שלי. אני מזמין אותך להשאיר תגובה אם אהבת את הפוסט או יש לך שאלות/הצעות.

Source:
https://www.digitalocean.com/community/tutorials/javase8-interview-questions-part2