Top 21 Java-interviewvragen

"Demonteren" public static void main(String args[]).

Een van de populaire java-interviewvragen voor eerstejaars, en heel gemakkelijk.

• publicis een toegangsmodificator. We gebruiken het om de toegang tot deze methode te specificeren. Hier is de modifier "openbaar", dus elke klasse heeft toegang tot deze methode.

• static. Dit Java-sleutelwoord betekent dat we deze methode gebruiken zonder een nieuw object van een klasse te maken.

• Voidis het retourtype van de methode. Het betekent dat de methode geen waarde retourneert.

• mainis de naam van de methode. JVM "kent" het als toegangspunt tot een applicatie (het zou een bepaalde handtekening moeten hebben). Mainis een methode waarbij de hoofduitvoering plaatsvindt.

• String args[]. Dit is de parameter die wordt doorgegeven aan de hoofdmethode. Hier hebben we de argumenten van het type String die uw Java-toepassing accepteert wanneer u deze uitvoert. U kunt ze op de terminal typen.

Wat is het verschil tussen equals()en ==?

Ten eerste is " ==" een operator terwijl equals()het een methode is. We gebruiken ==operator voor referentievergelijking (of adresvergelijking) en equals()methode voor inhoudsvergelijking. Het betekent dat ==wordt gecontroleerd of beide objecten naar dezelfde geheugenlocatie wijzen, terwijl equals()de waarden in de objecten worden vergeleken.

Kunnen we een programma zonder main()methode uitvoeren?

Veel Java-basisinterviewvragen zijn heel eenvoudig. Zoals deze. Het korte antwoord is dus: ja, dat kunnen we. We kunnen het bijvoorbeeld doen met een statisch blok.

U kunt een statisch blok gebruiken om het statische gegevenslid te initialiseren. Het wordt vóór de methode uitgevoerd main, op het moment dat de klasse wordt geladen.

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

De uitvoer is:

static block is invoked
Now main method

Wat is immutablevoorwerp? Kun je immutableeen object maken?

U kunt objecten van een klasse niet wijzigen immutablenadat ze zijn gemaakt. Dus als je ze eenmaal hebt gemaakt, kun je ze niet meer wijzigen. Als u een object probeert te wijzigen, Immutablekrijgt u een nieuw object (kloon) en wijzigt u deze kloon tijdens het maken.

Een goed voorbeeld is String, het is immutablein Java. Dat betekent dat je het object zelf niet kunt veranderen, maar wel de verwijzing naar het object.

Hoeveel objecten worden gemaakt in de volgende code?

Een van de Java technische interviewvragen die #4 vervangt.

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

Het antwoord is "slechts één" omdat Java een String Pool heeft. Wanneer we een String-object maken met de nieuwe()-operator, wordt er een nieuw object in het heap-geheugen gemaakt. Als we letterlijke String-syntaxis gebruiken, zoals in ons voorbeeld, kan het een bestaand object uit de String-pool retourneren, als het al bestaat.

Hoeveel objecten worden gemaakt in de volgende code?

String s = new String("Hello");

Er zijn 2 objecten. De ene bevindt zich in de stringconstante pool (indien nog niet aanwezig) en de andere bevindt zich in de heap.

Wat is het verschil tussen en Stringklassen in Java?StringBuilderStringBuffer

Er is een van de leiders in de beste java-interviewvragen.

Allereerst Stringis er een onveranderlijke klasse. Dat betekent dat u de inhoud ervan niet meer kunt wijzigen nadat deze is gemaakt. While StringBufferen StringBuilderzijn veranderlijke klassen, dus je kunt ze later wijzigen. Als we de inhoud van Stringhet object wijzigen, wordt er een nieuwe string gemaakt en wordt de oorspronkelijke string daarom niet gewijzigd. Daarom StringBufferzijn de prestaties met beter dan met String.

Het belangrijkste verschil tussen StringBufferen StringBuilderdat StringBufferde methoden zijn gesynchroniseerd, terwijl StringBuilderdat niet het geval is.

Is er een verschil Stringdat is gemaakt met letterlijk en met new()operator?

Er bestaat. Als we een string maken met de new()operator, verschijnt deze in de heap en in de stringpool (indien nog niet aanwezig). Als u Stringeen letterlijke waarde maakt, wordt deze gemaakt in de stringpool (indien nog niet aanwezig). Een stringpool is een opslaggebied binnen de heap, waarin letterlijke tekenreeksen worden opgeslagen.

Kun je privatede staticmethode in Java overschrijven?

Een van de lastige sollicitatievragen van java voor beginners. Je kunt echt niet overschrijven privateof staticmethode in Java.

U kunt de methoden niet overschrijven privateomdat het bereik van de privétoegangsspecificatie alleen binnen de klasse ligt. Als je iets gaat overschrijven, moeten we ouder- en kindles hebben. Als de methode van de superklasse is private, kan de onderliggende klasse deze niet gebruiken en worden de methoden in de onderliggende klasse behandeld als nieuwe methoden (niet overschreven).

Staticmethoden kunnen ook niet worden overschreven, omdat staticmethoden deel uitmaken van de klasse zelf en geen deel uitmaken van een object van de klasse. Natuurlijk kun je dezelfde methode declareren staticmet dezelfde handtekening in onderliggende klassen, maar nogmaals, ze worden behandeld als nieuwe methoden.

Verschil tussen Abstract ClassenInterface

Een van de populaire interviewvragen voor java-ontwikkelaars die betrekking heeft op OOP-principes. Allereerst interfacedefinieert Java een gedrag en abstract classcreëert het een hiërarchie.

staticKunnen we variabelen en methoden in een klasse declareren abstract?

Ja, het is mogelijk om staticvariabelen en methoden in abstractmethode te declareren. Er is geen vereiste om een ​​object te maken om toegang te krijgen tot de statische context. We hebben dus toegang tot de statische context die binnen de abstractklasse is gedeclareerd door de naam van de abstractklasse te gebruiken.

Welke soorten geheugengebieden worden toegewezen door JVM?

Class Area slaat structuren per klasse op, bijvoorbeeld runtime constant pool, velden, methodegegevens en alle code voor methoden.

Heap is een runtime-gegevensgebied waar geheugen wordt toegewezen aan de objecten.

Stapel slaat frames op. Het bevat lokale variabelen en gedeeltelijke resultaten, en neemt deel aan het aanroepen en retourneren van methoden. Elke thread heeft een eigen JVM-stack, die tegelijkertijd met de thread wordt gemaakt. Elke keer dat een methode wordt aangeroepen, wordt er een nieuw frame gemaakt. Een frame wordt vernietigd wanneer de aanroeping van de methode is voltooid.

Program Counter Register bevat een adres van de instructie van de virtuele Java-machine die momenteel wordt uitgevoerd.

Native Method Stack bevat alle native methoden die in de toepassing worden gebruikt.

Waarom is meervoudige overerving niet toegestaan ​​in Java?

Het zou echt ingewikkeld zijn. Stel je drie klassen voor A, B, en Cen Cerft Aen B. Nu, Aen Bklassen hebben dezelfde methode en je roept het aan vanuit een kindklasse-object ... Welke? A's of B's? Hier hebben we onduidelijkheid.

als u twee klassen probeert te erven, geeft Java een compileertijdfout.

Kunnen we de main()methode overbelasten?

Natuurlijk mogen we veel mainmethoden in een Java-programma hebben door methode-overbelasting te gebruiken. Probeer het!

Kunnen we een constructor declareren als final?

Nee. Een constructor kan niet worden gedeclareerd als a finalomdat deze niet kan worden geërfd. Het is dus zinloos om constructors te declareren als final. Als u het echter probeert, geeft de Java-compiler een foutmelding.

Kunnen we een interface declareren als final?

Nee, dit kunnen we niet doen. Een interface kan dat niet zijn final, omdat de interface door een bepaalde klasse moet worden geïmplementeerd volgens de definitie ervan. Daarom heeft het geen zin om een ​​interface te maken final. Als u dit echter probeert, geeft de compiler een foutmelding.

Wat is het verschil tussen static bindingen dynamic binding?

Wat bindingtijdens het compileren door de compiler kan worden opgelost, wordt staticearly binding genoemd. Bindingvan alle static, privateen finalmethoden gebeurt tijdens het compileren.

In Dynamic bindingcompiler kan geen methode kiezen om aan te roepen. Overschrijven is daar een perfect voorbeeld van dynamic binding. Bij het overschrijven hebben zowel ouder- als kindklassen dezelfde methode.

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();  
 }  
}

Hoe maak je een alleen-lezen klasse in Java?

U kunt dit doen door alle velden van de klasse privé te maken. De alleen-lezen klasse heeft alleen getter-methoden die de privé-eigenschap van de klasse teruggeven aan de mainmethode. U kunt deze eigenschap niet wijzigen, de reden hiervoor is het ontbreken van een settermethode.

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

Hoe maak je een alleen-schrijven-klasse in Java?

Nogmaals, je moet alle velden van de klasse maken private. Nu zou uw alleen-schrijven-klasse alleen setter-methoden moeten hebben en geen getters. Daarom kunnen we de eigenschappen van de klasse niet lezen.

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

Elk tryblok moet gevolgd worden door een catchblok, nietwaar?

Nee. Het is geen noodzaak. Elk tryblok kan zonder catchblok zijn. Het kan worden gevolgd door een catchblock of een final block of zelfs helemaal zonder.

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...");  
        }  
     }  
}

Uitgang:

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");
            }
        }
    }

Uitgang:

test

Wat is het verschil tussen throwen throwszoekwoorden?

Throwswordt gebruikt om een ​​uitzondering te declareren, dus het werkt vergelijkbaar met het try-catchblok. Throwtrefwoord wordt gebruikt om expliciet een uitzondering op te werpen vanuit een methode of een ander codeblok.

Throwwordt gevolgd door een instantie van Exceptionklasse en worpen wordt gevolgd door namen van uitzonderingsklassen.

Throwwordt gebruikt in de methode body om een ​​exception te genereren. Throwswordt gebruikt in een methodehandtekening om de uitzonderingen te declareren die kunnen voorkomen in de instructies die in de methode aanwezig zijn.

Het is toegestaan ​​om één uitzondering per keer te genereren, maar u kunt meerdere uitzonderingen afhandelen door ze te declareren met behulp van throween trefwoord. U kunt meerdere uitzonderingen declareren, bijvoorbeeld public void method()throws IOException, SQLException.