Analisi di domande e risposte da interviste per sviluppatori Java. Parte 1

Ciao! Diverse persone si sono riunite a JavaRush. Alcuni di noi vogliono semplicemente diventare sviluppatori Java, investendo molto tempo e impegno nello sviluppo, mentre altri sono già sviluppatori Java. In un caso o nell'altro, devi essere preparato per i test: colloqui tecnici. Questa prova non è facile e oltre alla preparazione morale è necessaria anche quella tecnica. Recentemente mi sono imbattuto in un ampio elenco di domande di intervista per sviluppatori Java su dou. Queste domande sono divise in diversi livelli: Junior, Middle e Senior. Non allarmatevi: non tutte le domande sono facili, ma quelle con l'asterisco vengono poste raramente. Le domande sono utili, ma mi piacerebbe provare a rispondere alla maggior parte di esse. È chiaro che non entrerò nello scopo di un articolo; dopo tutto, ci sono molte domande lì. Pertanto, questa sarà tutta una serie di articoli che risponderanno a tali domande. Vorrei subito sottolineare alcuni punti:

1. C'è un eccellente articolo con le principali domande e risposte per loro. Alcune domande si sovrappongono all'elenco presentato sopra (250+), quindi queste domande verranno saltate per non duplicare nuovamente le informazioni.

2. Le domande sono presentate in ucraino, ma poiché la maggior parte dei partecipanti a JavaRush parla russo (e in misura maggiore anche io), le risposte saranno in russo.

3. Le risposte saranno brevi, poiché se scrivi in ​​modo molto dettagliato, le risposte ad alcune domande potrebbero richiedere un articolo a parte. E durante le interviste non sono necessarie risposte così dettagliate e voluminose, perché il tuo intervistatore ha solo un'ora per intervistarti sugli argomenti necessari (e, come ricordi, questo è sufficiente). Per coloro a cui piace approfondire, lascerò i collegamenti.

Quindi, cominciamo.

Domande e risposte per il livello junior

Problemi generali

1. Quali modelli di progettazione conosci? Raccontaci dei due modelli che hai utilizzato nel tuo lavoro.

Esistono moltissimi modelli: puoi iniziare a conoscerli da questo e da questo articolo. Bene, per quelli di voi che vogliono familiarizzarsi con loro in dettaglio, consiglio di leggere il libro “Head First. Modelli di progettazione" . Con il suo aiuto, puoi studiare i modelli di progettazione più basilari in dettaglio e in modo semplice. Quando si tratta di modelli di progettazione che è possibile utilizzare come esempi in un'intervista, alcuni che mi vengono in mente sono:

• Builder è un template di uso frequente, alternativo alla classica creazione di oggetti;
• Modello di strategia , che rappresenta intrinsecamente il polimorfismo. Cioè, abbiamo un'interfaccia, ma il comportamento del programma cambierà a seconda di quale specifica implementazione di questa interfaccia è stata trasferita alla funzionalità (ora la strategia è praticamente utilizzata 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 pieni di schemi su e giù. Ecco un paio di esempi di ciò di cui sto parlando:

• Factory - nell'ApplicationContext (o nella BeanFactory);
• Singleton : tutti i bean sono singleton per impostazione predefinita;
• Proxy : essenzialmente tutto in Spring utilizza questo modello in un modo o nell'altro, ad esempio AOP;
• La catena di responsabilità è uno schema basato sul concetto su cui funziona Spring Security;
• Modello : utilizzato in Spring Jdbc.

Nucleo Java

2. Quali tipi di dati sono presenti in Java?

Java ha tipi di dati primitivi:

• byte : numeri interi compresi tra -128 e 127, pesa 1 byte;
• short : numeri interi compresi tra -32768 e 32767, pesa 2 byte;
• int — numeri interi da -2147483648 a 2147483647, pesa 4 byte;
• long : numeri interi nell'intervallo da 9223372036854775808 a 9223372036854775807, pesa 8 byte;
• float — numeri in virgola mobile nell'intervallo da -3,4E+38 a 3,4E+38, pesa 4 byte;
• double : numeri in virgola mobile nell'intervallo da -1,7E+308 a 1,7E+308, pesa 8 byte;
• char : caratteri singoli in UTF-16, pesa 2 byte;
• valori booleani true/false , pesa 1 byte.

E fare riferimento ai tipi di dati , che puntano agli oggetti nell'heap.

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

La prima differenza: la quantità di memoria occupata: le primitive occupano pochissimo, perché contengono solo il proprio valore, mentre gli oggetti possono contenere moltissimi valori diversi: sia primitive che riferimenti ad altri oggetti. La seconda differenza: Java è un linguaggio orientato agli oggetti, quindi tutto funziona attraverso l'interazione tra oggetti, e le primitive non si adattano molto bene (infatti, ecco perché Java non è un linguaggio orientato agli oggetti al 100%). Terzo, conseguente al secondo: poiché Java è focalizzato sull'interazione tra oggetti, questi oggetti hanno molti meccanismi diversi per gestirli. Ad esempio, costruttori, metodi, eccezioni (che operano principalmente su oggetti), ecc. In realtà, affinché i primitivi potessero in qualche modo essere coinvolti (lavorare) in questo ambiente orientato agli oggetti, sono stati inventati dei wrapper per i tipi primitivi ( Integer , Character , Double , Boolean ...)

4. Qual è la differenza tra il passaggio dei parametri per riferimento e per valore?

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

Cat cat = new Cat();

Si scopre che i campi con un riferimento a un oggetto memorizzano anche valori , valori di indirizzi di memoria. Cioè, cat memorizza il valore dell'indirizzo del nuovo oggetto Cat() in memoria. Quando passiamo un parametro a un metodo, il suo valore viene copiato. Nel caso di una primitiva, verrà copiato il valore della primitiva. Di conseguenza, il metodo funzionerà con una copia, la cui modifica non influirà sull'originale. Nel caso di tipo riferimento, verrà copiato il valore dell'indirizzo di memoria, rispettivamente, l'indirizzo sarà lo stesso dell'oggetto a cui punta. E se cambiamo l'oggetto utilizzando questo nuovo collegamento, verrà cambiato per quello vecchio (dopo tutto, entrambi puntano allo stesso oggetto).

5. Cos'è JVM, JDK, JRE?

JVM - Java Virtual Machine è una macchina virtuale che esegue bytecode Java pregenerato dal compilatore. JRE - Java Runtime Environment - è essenzialmente un ambiente per l'esecuzione di applicazioni Java, che contiene 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 contiene strumenti e utilità come compilatori o debugger per lo sviluppo di applicazioni. JDK - Java Development Kit - un set esteso di JRE , ovvero un ambiente non solo per l'avvio, ma anche per lo sviluppo di applicazioni Java. JDK contiene tutto ciò che è presente in JRE, oltre a vari strumenti aggiuntivi: compilatori e debugger necessari per creare applicazioni in Java (contiene anche documenti Java).

6. Perché utilizzare JVM?

Come accennato in precedenza, Java Virtual Machine è una macchina virtuale che esegue bytecode Java pregenerato dal compilatore. Cioè, la JVM non comprende il codice sorgente Java. Pertanto vengono innanzitutto compilati i file .java , che dopo la compilazione hanno già un'estensione .class e che vengono presentati sotto forma dello stesso codice byte comprensibile dalla JVM. Ogni sistema operativo ha la propria JVM, quindi dopo aver ricevuto i file bytecode, la JVM lo esegue, adattandolo al sistema operativo su cui avviene. In realtà, a causa delle diverse JVM, le versioni JDK (o JRE) differiscono per i diversi sistemi operativi (ognuno di essi richiede la propria JVM). Ricordiamo come funziona lo sviluppo in altri linguaggi di programmazione. Si sviluppa un programma, quindi il suo codice viene compilato in codice macchina per un sistema operativo specifico e quindi è possibile eseguirlo. In altre parole, è necessario scrivere diverse versioni del programma per ciascun sistema. In Java, invece, grazie all'elaborazione del doppio codice (compilazione ed elaborazione dei byte di codice JVM), è possibile usufruire dei vantaggi della multipiattaforma. Una volta creato il codice, lo abbiamo ricompilato in bytecode, lo abbiamo trasferito su qualsiasi sistema operativo e la JVM locale esegue il codice. Questa è la proprietà leggendaria di Java: scrivi una volta, esegui ovunque . Maggiori informazioni sull'argomento nell'articolo " Compilazione ed esecuzione di applicazioni Java dietro le quinte ".

7. Cos'è il bytecode?

Come ho detto sopra, il compilatore converte il codice Java in bytecode intermedio (file con estensione .java in file con estensione .class). Il bytecode è per molti versi simile al codice macchina, solo che utilizza una serie di istruzioni non da un processore reale, ma da uno virtuale. Inoltre, può includere sezioni focalizzate sull'uso di un compilatore JIT, che ottimizza l'esecuzione dei comandi per il processore reale su cui è in esecuzione il programma. La compilazione JIT, chiamata anche compilazione al volo, è una tecnologia che aumenta le prestazioni di un programma utilizzando il bytecode compilando il bytecode in una macchina o in un altro formato mentre il programma è in esecuzione. Come avrai intuito, la JVM utilizza un compilatore JIT quando esegue il bytecode. Diamo un'occhiata ad un esempio di bytecode: Non troppo leggibile, vero? Bene, questa non è un'istruzione per noi, ma per la JVM. Ecco un articolo che ti aiuterà a comprendere meglio questo problema.

8. Quali sono le caratteristiche di un JavaBean?

JavaBeans è una classe Java con determinate regole. Ecco alcune regole per scrivere un JavaBean :

1. La classe deve contenere un costruttore di accesso pubblico vuoto (senza parametri) con il modificatore public access . Questo costruttore consente di creare un oggetto di questa classe senza problemi inutili (in modo che non ci siano inutili complicazioni con i parametri).

2. Si accede ai campi interni di una classe tramite i metodi get e set , che dovrebbero essere standard. Ad esempio, se il campo è name , allora getName e setName, ecc. Ciò, a sua volta, consente a vari strumenti (framework) di determinare e aggiornare automaticamente il contenuto dei bean senza complicazioni.

3. La classe deve contenere versioni sovrascritte dei metodi equals() hashCode() e toString() .

4. La classe deve essere serializzabile, ovvero deve avere un'interfaccia marcatore - Serializable o implementare l' interfaccia Externalizable . Ciò è necessario affinché lo stato del bean possa essere salvato, archiviato e ripristinato in modo affidabile.

Puoi leggere informazioni sui tipi di JavaBean in questo materiale .

9. Cos'è l'errore OutOfMemory?

OutOfMemoryError è uno degli errori critici di runtime associati al funzionamento di Java Virtual Machine (JVM). Chiamato quando la JVM non può allocare un oggetto perché non c'è abbastanza memoria disponibile e il Garbage Collector non può allocare più memoria. Alcuni tipi di OutOfMemoryError :

• OutOfMemoryError: spazio heap Java : l'oggetto non può essere allocato nell'heap Java a causa di memoria insufficiente. L'errore potrebbe essere causato da una perdita di memoria o dal fatto che la dimensione heap predefinita non è sufficientemente grande per l'applicazione corrente.

• OutOfMemoryError: limite di sovraccarico GC superato : a causa del fatto che la quantità di dati si adatta a malapena all'heap, il Garbage Collector viene eseguito continuamente e il programma Java viene eseguito molto lentamente e, di conseguenza, il limite di sovraccarico del Garbage Collector viene superato e l'applicazione si blocca 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 più grande della dimensione dell'heap, il che potrebbe essere dovuto ancora una volta a un'allocazione di memoria predefinita insufficiente.

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

• OutOfMemoryError: richiede la dimensione in byte per il motivo. Spazio di swap esaurito : si è verificato un errore durante il tentativo di allocare memoria dall'heap e, di conseguenza, si è verificata una mancanza di memoria nell'heap.

10. Cos'è l'analisi dello stack? Come ottenerlo?

Uno Stack Trace è un elenco di classi e metodi che sono stati richiamati fino a questo punto nell'applicazione. Puoi chiamare una traccia dello stack in un punto specifico dell'applicazione in questo modo:

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

In questo modo otterremo una serie di elementi di traccia dello stack disposti in ordine LIFO: Last In First Out . In Java, di norma, quando si parla di stack trace, si intende lo stack trace che viene visualizzato nella console quando si verifica un errore (o un'eccezione). Puoi ottenere l'analisi dello stack di eccezioni come questa:

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

Bene, se stiamo parlando di emettere l'analisi dello stack delle eccezioni nella console:

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

Inoltre, se abbiamo un errore, un'eccezione non controllata o un'eccezione controllata , che non elaboreremo, ma inoltreremo solo, quando l'applicazione si arresta in modo anomalo riceveremo automaticamente uno stack trace delle eccezioni nella console. Un piccolo esempio di eccezione di Stack Trace nella console: puoi leggere ulteriori informazioni su Stack Trace qui . Oggi ci concentreremo su questo tema...