Utforska frågor och svar från en anställningsintervju för en Java-utvecklareposition. Del 1

Hej! CodeGym har samlat en mångfaldig grupp människor. Vissa av oss vill inget hellre än att bli Java-utvecklare, och vi investerar mycket tid och kraft i utvecklingen. Andra är redan Java-utvecklare. I båda fallen måste du vara redo att testas i tekniska intervjuer. Dessa är inte lätta. De kräver både emotionell och teknisk förberedelse. Jag stötte nyligen på några stora listor med intervjufrågor för Java-utvecklare. Frågorna är indelade i olika nivåer: junior, mellannivå och senior. Var inte orolig: alla frågor är inte lätta, men de med en asterisk ställs sällan. Frågorna är bra, och jag skulle vilja försöka besvara de flesta av dem. Det är klart att allt detta inte får plats i en enda artikel. Det finns trots allt många frågor där. Det betyder att det kommer att finnas en hel serie artiklar med svar på dessa intervjufrågor. Låt mig genast betona några punkter: svaren kommer att vara korta, eftersom svar som är skrivna mycket detaljerat kan dras ut i en separat artikel. Vid intervjuer önskas inte superdetaljerade och omfattande svar, eftersom din intervjuare bara har en timme på sig att intervjua dig om viktiga ämnen (och,

Frågor och svar för en junior utvecklarposition

Generella frågor

1. Vilka designmönster känner du till? Berätta om två designmönster som du har använt i ditt arbete.

Det finns en stor variation av mönster. För dig som vill bekanta dig ordentligt med designmönster rekommenderar jag att läsa boken "Head First. Design Patterns". Det hjälper dig att enkelt lära dig detaljerna i de mest grundläggande designmönstren. När det gäller designmönster som du kan nämna i en anställningsintervju, kommer följande att tänka på:

• Builder — en ofta använd mall, ett alternativ till den klassiska metoden för att skapa objekt;
• Strategi — ett mönster som i huvudsak representerar polymorfism. Det vill säga vi har ett gränssnitt, men programmets beteende ändras beroende på den specifika gränssnittsimplementeringen som skickas till funktionen (strategimönstret används nu nästan överallt i Java-applikationer).

Om det inte räcker för dig, var uppmärksam på Spring (om du redan är bekant med den), för det är en hel plattform av ramar, som i sin tur genomsyras av mönster från början till slut. Här är ett par exempel på vad jag pratar om:

• Factory — detta mönster kan hittas i ApplicationContext (eller i BeanFactory);
• Singleton — alla bönor är singletons som standard;
• Proxy — i princip, allt i vår använder detta mönster på ett eller annat sätt, till exempel AOP;
• Ansvarskedja — ett mönster som underbygger Spring Security;
• Mall — används i Spring JDBC.

Java Core

2. Vilka datatyper finns det i Java?

Java har följande primitiva datatyper:

• byte — heltal från -128 till 127, tar upp 1 byte;
• kort — heltal från -32768 till 32767, tar upp 2 byte;
• int — heltal från -2147483648 till 2147483647, tar upp 4 byte;
• långa — heltal från 9223372036854775808 till 9223372036854775807, tar upp 8 byte;
• flytande — flyttalstal som sträcker sig från -3,4E+38 till 3,4E+38, tar upp 4 byte;
• dubbel — flyttalstal som sträcker sig från -1,7E+308 till 1,7E+308, tar upp 8 byte;
• char — enstaka tecken i UTF-16, tar upp 2 byte;
• booleska sanna/falska värden, tar upp 1 byte.

Och det finns referensdatatyper som pekar på objekt på högen.

3. Hur skiljer sig ett objekt från primitiva datatyper?

Den första skillnaden är mängden minne som upptas: primitiver tar upp väldigt lite eftersom de bara innehåller sitt eget värde, men objekt kan innehålla många olika värden – både primitiver och referenser till andra objekt. En andra skillnad är denna: Java är ett objektorienterat språk, så allt i Java fungerar är en interaktion mellan objekt. Primitiver passar inte så bra in här. Det är faktiskt därför Java inte är ett 100 % objektorienterat språk. Den tredje skillnaden, som följer av den andra, är att eftersom Java är fokuserat på objektinteraktioner finns det många olika mekanismer för att hantera objekt. Till exempel konstruktörer, metoder, undantag (som främst arbetar med objekt) etc. Och för att tillåta primitiver att på något sätt fungera i denna objektorienterade miljö, kom Javas skapare påomslag för de primitiva typerna ( heltal , tecken , dubbelt , booleskt ...)

4. Vad är skillnaden mellan att skicka argument genom referens och värde?

Primitiva fält lagrar sitt värde: till exempel om vi sätter int i = 9; , då lagrar i -fältet värdet 9. När vi har en referens till ett objekt betyder det att vi har ett fält med en referens till objektet. Med andra ord har vi ett fält som lagrar objektets adress i minnet.

Cat cat = new Cat();

Detta innebär att fält med en referens till ett objekt också lagrar värden . Deras värden är minnesadresser. Det vill säga, cat lagrar minnesadressen för det nya Cat() -objektet. När vi skickar ett argument till en metod kopieras dess värde. I fallet med en primitiv kopieras värdet av primitivet. Följaktligen fungerar metoden med kopian. När kopian ändras påverkas inte originalet. Vid en referenstyp kopieras värdet på minnesadressen. Följaktligen kommer båda referensvariablerna att lagra adresser som pekar på samma objekt. Och om vi använder den här nya referensen för att ändra objektet, kommer vi att upptäcka att den också ändras för den gamla referensen. När allt kommer omkring pekar de båda på samma föremål.

5. Vad är JVM, JDK och JRE?

JVM står för Java Virtual Machine , som kör Java-bytekod som är förgenererad av kompilatorn. JRE står för Java Runtime Environment . I grund och botten är det en miljö för att köra Java-applikationer. Den inkluderar JVM, standardbibliotek och andra komponenter för att köra appletar och applikationer skrivna i programmeringsspråket Java. Med andra ord är JRE ett paket med allt som behövs för att köra ett kompilerat Java-program, men det inkluderar inte verktyg och verktyg som kompilatorer eller felsökare för att utveckla applikationer. JDK står för Java Development Kit , som är en förlängning av JRE. Det vill säga, det är en miljö inte bara för att köra Java-applikationer, utan också för att utveckla dem. JDK innehåller allt i JRE, plus olika ytterligare verktyg — kompilatorer och debuggers — som behövs för att skapa Java-applikationer (inklusive Java-dokument).

6. Varför använda JVM?

Som nämnts ovan är Java Virtual Machine en virtuell maskin som kör Java-bytekod som har förgenererats av kompilatorn. Detta betyder att JVM inte förstår Java-källkoden. Så först kompilerar vi .java- filer. De kompilerade filerna har .classförlängning och är nu i form av bytekod, vilket JVM förstår. JVM är olika för varje OS. När JVM kör bytecode-filer, anpassar den dem för operativsystemet som den körs på. I själva verket, eftersom det finns olika JVM, skiljer sig JDK (eller JRE) också för olika OS (varje version behöver sin egen JVM). Låt oss komma ihåg hur utveckling fungerar i andra programmeringsspråk. Du skriver ett program, sedan kompileras dess kod till maskinkod för ett specifikt operativsystem och sedan kan du köra det. Du behöver med andra ord skriva olika versioner av programmet för varje plattform. Men Javas dubbla bearbetning av koden (kompilering av källkod till bytekod, och sedan bearbetning av bytekod av JVM) låter dig njuta av fördelarna med en plattformsoberoende lösning. Vi skapar koden en gång och kompilerar den till bytecode. Sedan kan vi ta det till vilket operativsystem som helst, och det inbyggda JVM kan köra det. Och detta är just Javas legendariskaskriv en gång, kör var som helst funktion.

7. Vad är bytecode?

Som jag sa ovan konverterar kompilatorn Java-kod till mellanbytekod ( vi går från filer med .java-tillägget till filer med .class-tillägget). På många sätt liknar bytecode maskinkod, förutom att dess instruktionsuppsättning inte är för en riktig processor, utan en virtuell. Som sagt, den kan inkludera sektioner designade för en JIT-kompilator, som optimerar kommandoexekveringen för den faktiska processorn som programmet körs på. JIT-kompilering, även kallad on-the-fly-kompilering, är en teknik som ökar ett bytekodprograms prestanda genom att kompilera bytekoden till maskinkod eller annat format medan programmet körs. Som du kanske har gissat använder JVM JIT-kompilatorn när den kör bytekod. Låt oss ta en titt på några exempelbytekoder: Inte alltför läsvärd, va? Den goda nyheten är att den här instruktionen inte är avsedd för oss. Det är för JVM.

8. Vilka funktioner har en JavaBean?

En JavaBean är en Java-klass som följer vissa regler. Här är några av reglerna för att skriva en JavaBean :

1. Klassen måste innehålla en tom (ingen argument) konstruktor med public access-modifieraren. Denna konstruktor gör det möjligt att skapa ett objekt i klassen utan några onödiga problem (så att det inte blir onödigt fifflande med argument).

2. Interna fält nås via get- och set- instansmetoder, som bör ha standardimplementeringen. Till exempel, om vi har ett namnfält , så bör vi ha getName och setName , etc. Detta gör att olika verktyg (frameworks) automatiskt kan hämta och ställa in innehållet i bönor utan några svårigheter.

3. Klassen måste åsidosätta metoderna equals() , hashCode() och toString() .

4. Klassen måste kunna serialiseras. Det vill säga, den måste ha gränssnittet Serialiserbar markör eller implementera gränssnittet Externalizable . Detta är så att bönans tillstånd på ett tillförlitligt sätt kan sparas, lagras och återställas.

9. Vad är ett OutOfMemoryError?

OutOfMemoryError är ett kritiskt körtidsfel relaterat till Java Virtual Machine (JVM). Det här felet uppstår när JVM inte kan allokera ett objekt eftersom det inte finns tillräckligt med minne för det, och sopsamlaren inte kan allokera mer minne. Några typer av OutOfMemoryError :

• OutOfMemoryError: Java-högutrymme — objektet kan inte allokeras på Java-högen på grund av otillräckligt minne. Det här felet kan orsakas av en minnesläcka eller av en standardhögstorlek som är för liten för den aktuella applikationen.

• OutOfMemoryError: GC Overhead-gränsen har överskridits — eftersom programmets data knappt får plats i högen, körs sopsamlaren hela tiden, vilket gör att Java-programmet körs väldigt långsamt. Som ett resultat överskrids gränsen för sopsamlarens overhead och applikationen kraschar med detta fel.

• OutOfMemoryError: Begärd arraystorlek överskrider VM-gränsen – detta indikerar att applikationen försökte allokera minne för en array som överskrider heapstorleken. Återigen kan detta betyda att otillräckligt minne tilldelades som standard.

• OutOfMemoryError: Metaspace — högen fick slut på utrymme som tilldelats för metadata (metadata är instruktioner för klasser och metoder).

• OutOfMemoryError: begär storleksbyte av anledning. Out of swap space — något fel inträffade när man försökte allokera minne från heapen, och som ett resultat saknar heapen tillräckligt med utrymme.

10. Vad är en stackspårning? Hur får jag det?

En stackspårning är en lista över de klasser och metoder som har anropats fram till denna punkt i exekveringen av en applikation. Du kan få stackspårningen vid en specifik punkt i applikationen genom att göra så här:

StackTraceElement[] stackTraceElements =Thread.currentThread().getStackTrace();

Detta ger oss en mängd StackTraceElements arrangerade i Last In First Out (LIFO) ordning. I Java, när folk talar om en stackspårning, menar de vanligtvis en stackspårning som visas på konsolen när ett fel (eller undantag) inträffar. Du kan få stackspår från undantag som detta:

StackTraceElement[] stackTraceElements;
try{
                ...
} catch (Exception e) {
   stackTraceElements = e.getStackTrace();
}

Och om vi vill visa ett undantags stackspårning på konsolen:

try{
                ...
} catch (Exception e) {
  e.printStackTrace();
}

Dessutom, om ett fel, okontrollerat undantag eller ohanterat markerat undantag inträffar, får vi automatiskt undantagets stackspårning på konsolen när applikationen kraschar. Här är ett litet exempel på en stackspårning på konsolen: Och på den noten avslutar vi vår diskussion om detta ämne idag.