คำถามสัมภาษณ์ Java 21 อันดับแรก

“ถอดประกอบ” public static void main(String args[]).

หนึ่งในคำถามสัมภาษณ์จาวายอดนิยมสำหรับน้องใหม่ และคำถามง่ายมากๆ

• publicเป็นตัวดัดแปลงการเข้าถึง เราใช้เพื่อระบุการเข้าถึงวิธีนี้ ตัวแก้ไขที่นี่เป็น "สาธารณะ" ดังนั้นคลาสใด ๆ จึงสามารถเข้าถึงวิธีนี้ได้

• static. คีย์เวิร์ด Java นี้หมายความว่าเราใช้วิธีนี้โดยไม่ต้องสร้าง Object ของคลาสใหม่

• Voidเป็นประเภทผลตอบแทนของวิธีการ หมายความว่าเมธอดไม่ส่งคืนค่าใด ๆ

• mainเป็นชื่อของวิธีการ JVM "รู้" ว่าเป็นจุดเข้าสู่แอปพลิเคชัน (ควรมีลายเซ็นเฉพาะ) Mainเป็นวิธีที่เกิดการดำเนินการหลัก

• String args[]. นี่คือพารามิเตอร์ที่ส่งไปยังเมธอดหลัก ที่นี่เรามีอาร์กิวเมนต์ประเภทสตริงที่แอปพลิเคชัน 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วัตถุ คุณจะได้รับวัตถุใหม่ (โคลน) และเปลี่ยนโคลนนี้ในขณะที่สร้าง

ตัวอย่างที่ดีคือStringมันอยู่immutableใน Java ซึ่งหมายความว่าคุณไม่สามารถเปลี่ยนวัตถุได้ แต่คุณสามารถเปลี่ยนการอ้างอิงไปยังวัตถุได้

มีกี่อ็อบเจกต์ที่สร้างขึ้นในโค้ดต่อไปนี้?

หนึ่งในคำถามสัมภาษณ์ทางเทคนิคของจาวาที่ใช้แทน #4

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

คำตอบคือ “อันเดียว” เพราะ Java มี String Pool เมื่อเราสร้างวัตถุสตริงโดยใช้ตัวดำเนินการ new() จะสร้างวัตถุใหม่ในหน่วยความจำฮีป ถ้าเราใช้ไวยากรณ์ตัวอักษรของสตริง เช่นในตัวอย่างของเรา มันอาจส่งคืนวัตถุที่มีอยู่จากพูลสตริง หากมีอยู่แล้ว

มีกี่อ็อบเจกต์ที่สร้างขึ้นในโค้ดต่อไปนี้?

String s = new String("Hello");

มี 2 ​​องค์ อันหนึ่งอยู่ในพูลคงที่ของสตริง (หากยังไม่มี) และอีกอันอยู่ในฮีป

อะไรคือความแตกต่างระหว่างString, StringBuilderและStringBufferคลาสในภาษาจาวา ?

มีหนึ่งในผู้นำในคำถามสัมภาษณ์ Java อันดับต้น ๆ

ประการแรกStringคือคลาสที่ไม่เปลี่ยนรูป ซึ่งหมายความว่าคุณไม่สามารถแก้ไขเนื้อหาได้เมื่อสร้างขึ้นแล้ว ในขณะที่StringBufferเป็นStringBuilderคลาสที่ไม่แน่นอน คุณจึงเปลี่ยนได้ในภายหลัง ถ้าเราเปลี่ยนเนื้อหาของStringอ็อบเจกต์ มันจะสร้างสตริงใหม่ ดังนั้นมันจะไม่แก้ไขสตริงเดิม นั่นเป็นเหตุผลว่าทำไมประสิทธิภาพด้วยStringBufferจึงดีกว่าStringด้วย

ความแตกต่างที่สำคัญระหว่างStringBufferและของเมธอดStringBuilderนั้น จะถูกซิงโครไนซ์ในขณะที่ ไม่ใช่StringBufferStringBuilder

มีความแตกต่างในStringการสร้างโดยใช้ตัวอักษรและnew()ตัวดำเนินการหรือไม่?

มี หากเราสร้างสตริงด้วยnew()ตัวดำเนินการ มันจะปรากฏในฮีปและในกลุ่มสตริง (หากยังไม่มี) หากคุณสร้าง a Stringโดยใช้ตัวอักษร มันจะถูกสร้างขึ้นในกลุ่มสตริง (หากยังไม่มี) สระสตริงเป็นพื้นที่จัดเก็บภายในฮีปซึ่งเก็บตัวอักษรสตริง

คุณสามารถแทนที่privateหรือstaticวิธีการใน Java?

หนึ่งในคำถามสัมภาษณ์จาวาที่ยุ่งยากสำหรับมือใหม่ คุณไม่สามารถแทนที่privateหรือstaticเมธอดใน Java ได้

คุณไม่สามารถแทนที่เมธอดได้privateเนื่องจากขอบเขตของตัวระบุการเข้าถึงส่วนตัวนั้นอยู่ภายในคลาสเท่านั้น เมื่อคุณกำลังจะแทนที่บางสิ่ง เราควรจะมีคลาสหลักและคลาสย่อย หากเมธอดของซูเปอร์คลาสเป็น คลาสprivateลูกจะใช้ไม่ได้ และวิธีการในคลาสย่อยจะถือว่าเป็นเมธอดใหม่ (ไม่ถูกแทนที่)

Staticไม่สามารถแทนที่เมธอดได้ เนื่องจากstaticเมธอดเป็นส่วนหนึ่งของคลาสเอง และไม่ใช่ส่วนหนึ่งของออบเจกต์ใดๆ ของคลาส แน่นอนว่าคุณสามารถประกาศstaticเมธอดเดียวกันด้วยลายเซ็นเดียวกันในคลาสย่อยได้ แต่อีกครั้ง จะถือว่าเป็นเมธอดใหม่

ความแตกต่างระหว่างAbstract ClassและInterface

หนึ่งในคำถามสัมภาษณ์นักพัฒนาจาวาที่ได้รับความนิยมซึ่งมีหลักการ OOP ก่อนอื่น ใน Java interfaceกำหนดลักษณะการทำงานและabstract classสร้างลำดับชั้น

เราสามารถประกาศstaticตัวแปรและเมธอดในabstractคลาสได้หรือไม่?

ใช่ เป็นไปได้ที่จะประกาศstaticตัวแปรและเมธอดในabstractเมธอด ไม่มีข้อกำหนดในการสร้างวัตถุเพื่อเข้าถึงบริบทแบบคงที่ ดังนั้นเราจึงได้รับอนุญาตให้เข้าถึงบริบทคงที่ที่ประกาศภายในabstractคลาสโดยใช้ชื่อของabstractคลาส

JVM จัดสรรพื้นที่หน่วยความจำประเภทใดบ้าง

พื้นที่คลาสจัดเก็บโครงสร้างต่อคลาส เช่น พูลค่าคงที่รันไทม์ ฟิลด์ ข้อมูลเมธอด และโค้ดทั้งหมดสำหรับเมธอด

ฮีปเป็นพื้นที่ข้อมูลรันไทม์ที่จัดสรรหน่วยความจำให้กับวัตถุ

กองเก็บเฟรม ประกอบด้วยตัวแปรโลคัลและผลลัพธ์บางส่วน และมีส่วนร่วมในการเรียกใช้เมธอดและส่งคืน ทุกเธรดมีสแต็ก JVM ส่วนตัว ซึ่งสร้างขึ้นพร้อมกันกับเธรด เฟรมใหม่จะถูกสร้างขึ้นทุกครั้งที่เรียกใช้เมธอด เฟรมจะถูกทำลายเมื่อการเรียกใช้เมธอดเสร็จสิ้น

Program Counter Registerมีที่อยู่ของคำสั่ง Java virtual machine ที่กำลังดำเนินการอยู่

Native Method Stackประกอบด้วย Native Method ทั้งหมดที่ใช้ในแอปพลิเคชัน

เหตุใดจึงไม่อนุญาตการสืบทอดหลายรายการใน java

มันจะซับซ้อนจริงๆ ลองนึกภาพสามคลาสA, BและCและCสืบทอดAและ Bตอนนี้AและBคลาสมีเมธอดเดียวกันและคุณเรียกมันจากออบเจกต์คลาสลูก... อันไหน A's หรือB's? ที่นี่เรามีความคลุมเครือ

หากคุณพยายามสืบทอดสองคลาส Java จะแสดงข้อผิดพลาดในการคอมไพล์

เราสามารถโอเวอร์โหลดmain()เมธอดได้หรือไม่?

แน่นอน เราได้รับอนุญาตให้มีหลายmainวิธีในโปรแกรม Java โดยใช้เมธอดโอเวอร์โหลด ลองดูสิ!

เราสามารถประกาศตัวสร้างเป็นfinal?

ไม่. ไม่สามารถประกาศตัวสร้างเป็น a 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เมธอด คุณไม่สามารถแก้ไขคุณสมบัตินี้ได้ เหตุผลคือการขาด setters method

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

จะสร้างคลาสแบบเขียนอย่างเดียวใน Java ได้อย่างไร

privateคุณ ควรสร้างฟิลด์ของคลาสทั้งหมดอีกครั้ง ตอนนี้คลาสเขียนอย่างเดียวของคุณควรมีเมธอด setter เท่านั้นและไม่มี getter ดังนั้นเราจึงไม่สามารถอ่านคุณสมบัติของคลาสได้

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

แต่ละtryบล็อกต้องตามด้วยcatchบล็อกใช่ไหม

ไม่. ไม่ใช่เรื่องจำเป็น แต่ละtryบล็อกสามารถไม่มีcatchบล็อก อาจตามมาด้วย catchblock หรือบล็อกสุดท้าย หรือแม้แต่ไม่มีเลย

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คลาสและโยนตามด้วยชื่อคลาสข้อยกเว้น

Throwถูกใช้ในเนื้อความของเมธอดเพื่อส่งข้อยกเว้น Throwsใช้ในลายเซ็นเมธอดเพื่อประกาศข้อยกเว้นที่อาจเกิดขึ้นในคำสั่งที่มีอยู่ในเมธอด

อนุญาตให้โยนข้อยกเว้นได้ครั้งละหนึ่งรายการ แต่คุณสามารถจัดการข้อยกเว้นหลายรายการได้โดยการประกาศโดยใช้คำthrowสำคัญ คุณสามารถประกาศข้อยกเว้นได้หลายรายการ เช่นpublic void method()throws IOException,SQLException