21 שאלות הראיונות המובילות ב-Java

"לפרק" public static void main(String args[]).

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

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

• static. מילת מפתח זו של Java פירושה שאנו משתמשים בשיטה זו מבלי ליצור אובייקט חדש של מחלקה.

• Voidהוא סוג ההחזרה של השיטה. זה אומר שהשיטה לא מחזירה שום ערך.

• mainזה שם השיטה. JVM "מכיר" אותו כנקודת כניסה לאפליקציה (צריכה להיות לה חתימה מסוימת). Mainהיא שיטה שבה מתרחשת הביצוע העיקרי.

• String args[]. זה הפרמטר המועבר לשיטה הראשית. כאן יש לנו את הטיעונים מסוג String שאפליקציית Java שלך מקבלת כשאתה מפעיל אותה. אתה יכול להקליד אותם בטרמינל.

מה ההבדל בין equals()לבין ==?

ראשית, " ==" הוא אופרטור ואילו equals()הוא שיטה. אנו משתמשים ==באופרטור להשוואת הפניות (או השוואת כתובות) ושיטה equals()להשוואת תוכן. זה אומר ==שבודק אם שני האובייקטים מצביעים על אותו מיקום זיכרון תוך equals()השוואת ערכים באובייקטים.

האם נוכל להפעיל תוכנית ללא main()שיטה?

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

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

class Example{
 Static{
System.out.println("static block is invoked");
}
  public static void main(String args[]){
   System.out.println("Now main method");
  }
}

הפלט הוא:

static block is invoked
Now main method

מהו immutableחפץ? האם אתה יכול ליצור immutableאובייקט?

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

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

כמה אובייקטים נוצרים בקוד הבא?

אחת משאלות הראיונות הטכניות ב-Java שמחליפה את מספר 4.

String s1="Hello";
String s2="Hello";
String s3="Hello";

התשובה היא "רק אחת" כי לג'אווה יש מאגר מחרוזות. כאשר אנו יוצרים אובייקט String באמצעות האופרטור new() הוא יוצר אובייקט חדש בזיכרון הערימה. אם נשתמש בתחביר מילולי של String, כמו בדוגמה שלנו, הוא עשוי להחזיר אובייקט קיים ממאגר המחרוזות, אם הוא כבר קיים.

כמה אובייקטים נוצרים בקוד הבא?

String s = new String("Hello");

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

מה ההבדל בין Stringשיעורים StringBuilderב- StringBufferJava?

יש אחד מהמובילים בשאלות הראיונות המובילות בג'אווה.

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

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

האם יש הבדל בכך Stringשנוצר באמצעות מילולית ועם new()אופרטור?

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

האם אתה יכול לעקוף privateאו staticשיטה ב-Java?

אחת משאלות הראיונות המסובכות של ג'אווה עבור טירונים. אתה באמת לא יכול לעקוף privateאו staticשיטה ב-Java.

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

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

ההבדל בין Abstract ClassלביןInterface

אחת משאלות הראיונות הפופולריות למפתחי ג'אווה הנוגעת לעקרונות OOP. קודם כל, בג'אווה interfaceמגדיר התנהגות ויוצר abstract classהיררכיה.

האם נוכל להכריז על staticמשתנים ושיטות במחלקה abstract?

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

אילו סוגי אזורי זיכרון מוקצים על ידי JVM?

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

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

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

Program Counter Register מכיל כתובת של הוראת המכונה הוירטואלית של Java שמתבצעת כעת.

Native Method Stack מכיל את כל השיטות המקוריות המשמשות באפליקציה.

מדוע אסורה ירושה מרובה ב-Java?

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

אם תנסה לרשת שתי מחלקות, Java יוצר שגיאת זמן קומפילציה.

האם נוכל להעמיס על main()השיטה?

בטח, מותר לנו להחזיק mainשיטות רבות בתוכנת Java על ידי שימוש בעומס יתר של שיטות. נסה את זה!

האם נוכל להכריז על בנאי בתור final?

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

האם אנחנו יכולים להכריז על ממשק בתור final?

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

מה ההבדל בין static bindingלבין dynamic binding?

מה bindingשניתן לפתור בזמן הקומפילציה על ידי מהדר נקרא staticאו כריכה מוקדמת. Bindingמכל השיטות staticוהשיטות privateמתבצעת finalבזמן הידור.

במהדר Dynamic bindingלא ניתן לבחור שיטה להיקרא. דריסה היא דוגמה מושלמת של dynamic binding. בהחלפת שני כיתות הורה וילד יש אותה שיטה.

Static Binding
class Cat{
 private void talk()
{System.out.println("cat is mewing...");
}

 public static void main(String args[]){
  Cat cat=new Cat();
  cat.talk();
 }
}
Dynamic Binding
class Animal{
 void talk(){
System.out.println("animal is talking...");
}
}

class Cat extends Animal{
 void talk(){
System.out.println("cat is talking...");
}
 public static void main(String args[]){
  Animal animal=new Cat();
  animal.talk();
 }
}

כיצד ליצור מחלקה לקריאה בלבד ב-Java?

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

public class HockeyPlayer{
private String team ="Maple leaf";
public String getTeam(){
return team;
}
}

כיצד ליצור מחלקה לכתיבה בלבד ב-Java?

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

public class HockeyPlayer{
private String team;
public void setTeam(String college){
this.team = team;
}
}

כל tryבלוק חייב להיות אחריו בלוק catch, לא?

לא. זה לא הכרח. כל tryבלוק יכול להיות ללא catchבלוק. זה יכול להיות אחריו בלוק קאץ' או בלוק סופית או אפילו בלעדיהם בכלל.

public class Main{
     public static void main(String []args){
        try{
            int variable = 1;
            System.out.println(variable/0);
        }
        finally
        {
            System.out.println("the other part of the program...");
        }
     }
}

תְפוּקָה:

Exception in thread main java.lang.ArithmeticException:/ by zero
the other part of the program...

class Main {
        public static void main(String[] args) throws IOException {
            try(InputStreamReader inputStreamReader = new InputStreamReader(System.in);
                BufferedReader reader = new BufferedReader(inputStreamReader)){
                System.out.println("test");
            }
        }
    }

תְפוּקָה:

test

מה ההבדל בין throwמילות throwsמפתח?

Throwsמשמש להכרזה על חריג, כך שהוא פועל בדומה לבלוק try-catch. Throwמילת המפתח משמשת כדי לזרוק חריג במפורש משיטה או מכל בלוק קוד אחר.

Throwאחריו מופיע מופע של Exceptionמחלקה ואחריו Throws מופיעים שמות מחלקות חריגות.

Throwמשמש בגוף השיטה כדי לזרוק חריג. Throwsמשמש בחתימת שיטה כדי להכריז על החריגים שעלולים להתרחש בהצהרות הקיימות בשיטה.

מותר לזרוק חריג אחד בכל פעם, אבל אתה יכול לטפל במספר חריגים על ידי הכרזה עליהם באמצעות throwמילת מפתח. אתה יכול להכריז על מספר חריגים, למשל, public void method()throws IOException, SQLException.