Esplorare domande e risposte da un colloquio di lavoro per una posizione di sviluppatore Java. Parte 1

CIAO! CodeGym ha riunito un gruppo eterogeneo di persone. Alcuni di noi non vogliono altro che diventare sviluppatori Java e stiamo investendo molto tempo e impegno nello sviluppo. Altri sono già sviluppatori Java. In entrambi i casi, devi essere pronto per essere testato in colloqui tecnici. Questi non sono facili. Richiedono una preparazione sia emotiva che tecnica. Di recente mi sono imbattuto in alcuni ampi elenchi di domande di interviste per posizioni di sviluppatore Java. Le domande sono suddivise in diversi livelli: junior, medio e senior. Non allarmarti: non tutte le domande sono facili, ma quelle con l'asterisco raramente vengono poste. Le domande sono buone e vorrei provare a rispondere alla maggior parte di esse. Chiaramente, questo non starà tutto in un singolo articolo. Dopotutto, ci sono molte domande lì. Ciò significa che ci sarà un'intera serie di articoli con le risposte a queste domande dell'intervista. Consentitemi di sottolineare subito alcuni punti: le risposte saranno brevi, perché le risposte scritte in modo molto dettagliato potrebbero essere raccolte in un articolo separato. Inoltre, ai colloqui non sono richieste risposte super dettagliate e voluminose, perché il tuo intervistatore ha solo un'ora per intervistarti su argomenti essenziali (e,

Domande e risposte per una posizione di sviluppatore junior

Domande generali

1. Quali modelli di design conosci? Parlaci di due design pattern che hai utilizzato nel tuo lavoro.

Ci sono una grande varietà di modelli. Per quelli di voi che vogliono familiarizzare a fondo con i design pattern, consiglio di leggere il libro "Head First. Design Patterns". Ti aiuterà ad apprendere facilmente i dettagli dei modelli di progettazione più basilari. In termini di modelli di progettazione che potresti menzionare in un colloquio di lavoro, mi vengono in mente i seguenti:

• Builder : un modello utilizzato di frequente, un'alternativa al classico approccio alla creazione di oggetti;
• Strategia : un modello che rappresenta essenzialmente il polimorfismo. Cioè, abbiamo un'interfaccia, ma il comportamento del programma cambia a seconda della specifica implementazione dell'interfaccia passata alla funzione (il modello di strategia è ora utilizzato praticamente ovunque nelle applicazioni Java).

Se questo non ti basta, presta attenzione a Spring (se lo conosci già), perché è un'intera piattaforma di framework, che, a loro volta, sono permeati di schemi dall'inizio alla fine. Ecco un paio di esempi di ciò di cui sto parlando:

• Factory : questo modello può essere trovato in ApplicationContext (o in BeanFactory);
• Singleton : tutti i bean sono singleton per impostazione predefinita;
• Proxy : in pratica, tutto in Spring utilizza questo modello in un modo o nell'altro, ad esempio AOP;
• Catena di responsabilità : un modello alla base di Spring Security;
• Modello : utilizzato in Spring JDBC.

Nucleo Java

2. Quali tipi di dati ci sono in Java?

Java ha i seguenti tipi di dati primitivi:

• byte — numeri interi compresi tra -128 e 127, occupa 1 byte;
• short — numeri interi compresi tra -32768 e 32767, occupa 2 byte;
• int — numeri interi compresi tra -2147483648 e 2147483647, occupa 4 byte;
• long — numeri interi compresi tra 9223372036854775808 e 9223372036854775807, occupa 8 byte;
• float — numeri in virgola mobile compresi tra -3.4E+38 e 3.4E+38, occupano 4 byte;
• double — numeri in virgola mobile compresi tra -1.7E+308 e 1.7E+308, occupano 8 byte;
• char — caratteri singoli in UTF-16, occupa 2 byte;
• valori booleani vero/falso, occupa 1 byte.

E ci sono tipi di dati di riferimento che puntano a oggetti nell'heap.

3. In che modo un oggetto differisce dai tipi di dati primitivi?

La prima differenza è la quantità di memoria occupata: le primitive occupano pochissimo perché contengono solo il proprio valore, ma gli oggetti possono contenere molti valori diversi, sia primitive che riferimenti ad altri oggetti. Una seconda differenza è questa: Java è un linguaggio orientato agli oggetti, quindi tutto ciò che funziona in Java è un'interazione tra oggetti. I primitivi non si adattano molto bene qui. In effetti, ecco perché Java non è un linguaggio orientato agli oggetti al 100%. La terza differenza, che segue dalla seconda, è che poiché Java è incentrato sulle interazioni tra oggetti, esistono molti meccanismi diversi per la gestione degli oggetti. Ad esempio, costruttori, metodi, eccezioni (che funzionano principalmente con oggetti), ecc. E per consentire alle primitive di funzionare in qualche modo in questo ambiente orientato agli oggetti, i creatori di Java hanno escogitatowrapper per i tipi primitivi ( Integer , Character , Double , Boolean ...)

4. Qual è la differenza tra passare argomenti per riferimento e per valore?

I campi primitivi memorizzano il loro valore: per esempio, se impostiamo int i = 9; , allora il campo i memorizza il valore 9. Quando abbiamo un riferimento a un oggetto, significa che abbiamo un campo con un riferimento all'oggetto. In altre parole, abbiamo un campo che memorizza l'indirizzo dell'oggetto in memoria.

Cat cat = new Cat();

Ciò significa che anche i campi con un riferimento a un oggetto memorizzano valori . I loro valori sono indirizzi di memoria. Cioè, cat memorizza l'indirizzo di memoria del nuovo oggetto Cat() . Quando passiamo un argomento a un metodo, il suo valore viene copiato. Nel caso di una primitiva, viene copiato il valore della primitiva. Di conseguenza, il metodo funziona con la copia. Quando la copia viene modificata, l'originale non ne risente. Nel caso di un tipo di riferimento, viene copiato il valore dell'indirizzo di memoria. Di conseguenza, entrambe le variabili di riferimento memorizzeranno gli indirizzi che puntano allo stesso oggetto. E se usiamo questo nuovo riferimento per cambiare l'oggetto, allora scopriremo che è cambiato anche per il vecchio riferimento. Dopotutto, entrambi puntano allo stesso oggetto.

5. Che cos'è JVM, JDK e JRE?

JVM è l'acronimo di Java Virtual Machine , che esegue il bytecode Java pre-generato dal compilatore. JRE sta per Java Runtime Environment . Fondamentalmente, è un ambiente per l'esecuzione di applicazioni Java. Include JVM, librerie standard e altri componenti per l'esecuzione di applet e applicazioni scritte nel linguaggio di programmazione Java. In altre parole, JRE è un pacchetto di tutto il necessario per eseguire un programma Java compilato, ma non include strumenti e utilità come compilatori o debugger per lo sviluppo di applicazioni. JDK è l'acronimo di Java Development Kit , che è un'estensione di JRE. Cioè, è un ambiente non solo per eseguire applicazioni Java, ma anche per svilupparle. Il JDK contiene tutto nel JRE, oltre a vari strumenti aggiuntivi - compilatori e debugger - necessari per creare applicazioni Java (inclusi i documenti Java).

6. Perché utilizzare la JVM?

Come affermato sopra, la Java Virtual Machine è una macchina virtuale che esegue il bytecode Java che è stato pre-generato dal compilatore. Ciò significa che la JVM non comprende il codice sorgente Java. Quindi, per prima cosa, compiliamo i file .java . I file compilati hanno l' estensione .classestensione e sono ora sotto forma di bytecode, che la JVM comprende. La JVM è diversa per ogni sistema operativo. Quando la JVM esegue i file bytecode, li adatta al sistema operativo su cui è in esecuzione. Infatti, poiché esistono diverse JVM, anche il JDK (o JRE) differisce per i diversi sistemi operativi (ogni versione necessita della propria JVM). Ricordiamo come funziona lo sviluppo in altri linguaggi di programmazione. Scrivi un programma, quindi il suo codice viene compilato in codice macchina per un sistema operativo specifico e quindi puoi eseguirlo. In altre parole, devi scrivere diverse versioni del programma per ogni piattaforma. Ma la doppia elaborazione del codice da parte di Java (compilazione del codice sorgente in bytecode e quindi elaborazione del bytecode da parte della JVM) ti consente di godere dei vantaggi di una soluzione multipiattaforma. Creiamo il codice una volta e lo compiliamo in bytecode. Quindi possiamo portarlo su qualsiasi sistema operativo e la JVM nativa è in grado di eseguirlo. E questo è proprio il leggendario di Javafunzione scrivi una volta, esegui ovunque .

7. Cos'è il bytecode?

Come ho detto sopra, il compilatore converte il codice Java in bytecode intermedio (passiamo da file con estensione .java a file con estensione .class). In molti modi, il bytecode è simile al codice macchina, tranne per il fatto che il suo set di istruzioni non è per un processore reale, ma virtuale. Detto questo, può includere sezioni progettate per un compilatore JIT, che ottimizza l'esecuzione dei comandi per il processore effettivo su cui è in esecuzione il programma. La compilazione JIT, chiamata anche compilazione al volo, è una tecnologia che aumenta le prestazioni di un programma bytecode compilando il bytecode in codice macchina o in un altro formato mentre il programma è in esecuzione. Come avrai intuito, la JVM utilizza il compilatore JIT quando esegue il bytecode. Diamo un'occhiata ad alcuni bytecode di esempio: Non troppo leggibile, eh? La buona notizia è che questa istruzione non è destinata a noi. È per la JVM.

8. Quali sono le caratteristiche di un JavaBean?

Un JavaBean è una classe Java che segue determinate regole. Ecco alcune delle regole per scrivere un JavaBean :

1. La classe deve contenere un costruttore vuoto (senza argomenti) con il modificatore di accesso pubblico . Questo costruttore rende possibile creare un oggetto della classe senza inutili problemi (in modo che non ci sia inutile armeggiare con gli argomenti).

2. I campi interni sono accessibili tramite i metodi di istanza get e set , che dovrebbero avere l'implementazione standard. Ad esempio, se abbiamo un campo nome , dovremmo avere getName e setName , ecc. Ciò consente a vari strumenti (framework) di ottenere e impostare automaticamente il contenuto dei bean senza alcuna difficoltà.

3. La classe deve sovrascrivere i metodi equals() , hashCode() e toString() .

4. La classe deve essere serializzabile. Cioè, deve avere l'interfaccia del marcatore Serializable o implementare l' interfaccia Externalizable . In questo modo lo stato del bean può essere salvato, archiviato e ripristinato in modo affidabile.

9. Cos'è un OutOfMemoryError?

OutOfMemoryError è un errore di runtime critico correlato alla Java Virtual Machine (JVM). Questo errore si verifica quando la JVM non può allocare un oggetto perché non c'è memoria sufficiente per esso e il Garbage Collector non può allocare più memoria. Alcuni tipi di OutOfMemoryError :

• OutOfMemoryError: spazio heap Java : l'oggetto non può essere allocato sull'heap Java a causa di memoria insufficiente. Questo errore può essere causato da una perdita di memoria o da una dimensione dell'heap predefinita troppo piccola per l'applicazione corrente.

• OutOfMemoryError: limite di sovraccarico GC superato : poiché i dati dell'applicazione si adattano a malapena all'heap, il Garbage Collector viene eseguito continuamente, causando un'esecuzione molto lenta del programma Java. Di conseguenza, il limite di overhead del Garbage Collector viene superato e l'applicazione si arresta in modo anomalo con questo errore.

• OutOfMemoryError: la dimensione dell'array richiesta supera il limite della VM : indica che l'applicazione ha tentato di allocare memoria per un array che supera la dimensione dell'heap. Ancora una volta, ciò potrebbe significare che per impostazione predefinita è stata allocata memoria insufficiente.

• OutOfMemoryError: Metaspace : l'heap ha esaurito lo spazio allocato per i metadati (i metadati sono istruzioni per classi e metodi).

• OutOfMemoryError: richiesta dimensione byte per motivo. Spazio di scambio esaurito : si è verificato un errore durante il tentativo di allocare memoria dall'heap e, di conseguenza, l'heap non dispone di spazio sufficiente.

10. Che cos'è una traccia dello stack? Come lo ottengo?

Una traccia dello stack è un elenco delle classi e dei metodi che sono stati richiamati fino a questo punto nell'esecuzione di un'applicazione. È possibile ottenere la traccia dello stack in un punto specifico dell'applicazione in questo modo:

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

Questo ci dà un array di StackTraceElements disposti in ordine LIFO (Last In First Out) . In Java, quando si parla di traccia dello stack, di solito si intende una traccia dello stack visualizzata sulla console quando si verifica un errore (o un'eccezione). Puoi ottenere la traccia dello stack da eccezioni come questa:

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

E se vogliamo visualizzare la traccia dello stack di un'eccezione sulla console:

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

Inoltre, se si verifica un errore, un'eccezione non controllata o un'eccezione controllata non gestita , otteniamo automaticamente l'analisi dello stack dell'eccezione sulla console quando l'applicazione si arresta in modo anomalo. Ecco un piccolo esempio di una traccia dello stack sulla console: E su questa nota, concluderemo oggi la nostra discussione su questo argomento.