top 50 core java interview questions
Domande e risposte ai colloqui di Java più frequenti con esempi:
In questo tutorial, abbiamo coperto quasi 50+ importanti domande di intervista su Java per matricole e candidati esperti.
Questo post su JAVA Interview Questions è preparato per aiutarti a comprendere i concetti di base della programmazione Java a scopo di intervista. Tutti i concetti importanti di JAVA sono spiegati qui con esempi per una facile comprensione.
Questo tutorial copre argomenti JAVA come definizioni Java di base, concetti OOP, specificatori di accesso, raccolte, eccezioni, thread, serializzazione, ecc., Con esempi per prepararti perfettamente per affrontare con sicurezza qualsiasi intervista JAVA.
Domande e risposte alle interviste su Java più popolari
Di seguito è riportato un elenco completo delle domande di intervista di programmazione Java di base e avanzate più importanti e più frequenti con risposte dettagliate.
D # 1) Cos'è JAVA?
Risposta: Java è un linguaggio di programmazione di alto livello ed è indipendente dalla piattaforma.
Java è una raccolta di oggetti. È stato sviluppato da Sun Microsystems. Esistono molte applicazioni, siti Web e giochi sviluppati utilizzando Java.
D # 2) Quali sono le caratteristiche di JAVA?
Risposta: le caratteristiche di Java sono le seguenti:
- Concetti OOP
- Orientato agli oggetti
- Eredità
- Incapsulamento
- Polimorfismo
- Astrazione
- Piattaforma indipendente: Un unico programma funziona su diverse piattaforme senza alcuna modifica.
- Alte prestazioni: JIT (Just In Time compilatore) consente alte prestazioni in Java. JIT converte il bytecode in linguaggio macchina e quindi JVM avvia l'esecuzione.
- Multifilo: Un flusso di esecuzione è noto come Thread. JVM crea un thread che viene chiamato thread principale. L'utente può creare più thread estendendo la classe thread o implementando l'interfaccia Runnable.
D # 3) In che modo Java consente prestazioni elevate?
Risposta: Java utilizza il compilatore Just In Time per abilitare prestazioni elevate. Viene utilizzato per convertire le istruzioni in bytecode.
D # 4) Assegnare un nome agli IDE Java?
Risposta: Eclipse e NetBeans sono gli IDE di JAVA.
D # 5) Cosa intendi per Constructor?
Risposta: Il costruttore può essere spiegato in dettaglio con i punti arruolati:
- Quando un nuovo oggetto viene creato in un programma, viene richiamato un costruttore corrispondente alla classe.
- Il costruttore è un metodo che ha lo stesso nome del nome della classe.
- Se un utente non crea un costruttore in modo implicito, verrà creato un costruttore predefinito.
- Il costruttore può essere sovraccaricato.
- Se l'utente ha creato un costruttore con un parametro, dovrebbe creare un altro costruttore esplicitamente senza un parametro.
Q # 6) Cosa si intende per variabile locale e variabile istanza?
Risposta:
Variabili locali sono definiti nel metodo e nell'ambito delle variabili che esistono all'interno del metodo stesso.
Variabile di istanza è definito all'interno della classe e all'esterno del metodo e l'ambito delle variabili esiste in tutta la classe.
Q # 7) Cos'è una classe?
Risposta: Tutti i codici Java sono definiti in una classe. Ha variabili e metodi.
Variabili sono attributi che definiscono lo stato di una classe.
Metodi sono il luogo in cui deve essere eseguita la logica aziendale esatta. Contiene una serie di istruzioni (o) istruzioni per soddisfare il particolare requisito.
Esempio:
public class Addition{ //Class name declaration int a = 5; //Variable declaration int b= 5; public void add(){ //Method declaration int c = a+b; } }
D # 8) Cos'è un oggetto?
Risposta: Un'istanza di una classe è chiamata oggetto. L'oggetto ha stato e comportamento.
Ogni volta che la JVM legge la parola chiave 'new ()', creerà un'istanza di quella classe.
Esempio:
public class Addition{ public static void main(String[] args){ Addion add = new Addition();//Object creation } }
Il codice precedente crea l'oggetto per la classe Addition.
D # 9) Quali sono i concetti OOPs?
Risposta: i concetti degli OOP includono:
- Eredità
- Incapsulamento
- Polimorfismo
- Astrazione
- Interfaccia
Lettura suggerita = >> Domande di intervista sulle principali OOP
Q # 10) Che cos'è l'ereditarietà?
Risposta: Ereditarietà significa che una classe può estendersi a un'altra classe. In modo che i codici possano essere riutilizzati da una classe all'altra. La classe esistente è conosciuta come la classe Super mentre la classe derivata è nota come sottoclasse.
Esempio:
Super class: public class Manupulation(){ } Sub class: public class Addition extends Manipulation(){ }
L'ereditarietà è applicabile solo ai membri pubblici e protetti. I membri privati non possono essere ereditati.
D # 11) Che cos'è l'incapsulamento?
Risposta: Scopo dell'incapsulamento:
- Protegge il codice da altri.
- Manutenibilità del codice.
Esempio:
Stiamo dichiarando 'a' come variabile intera e non dovrebbe essere negativa.
public class Addition(){ int a=5; }
Se qualcuno modifica la variabile esatta come ' a = -5 ' allora è male.
Per superare il problema dobbiamo seguire i passaggi seguenti:
- Possiamo rendere la variabile privata o protetta.
- Usa metodi di accesso pubblico come set e get.
In modo che il codice sopra possa essere modificato come:
public class Addition(){ private int a = 5; //Here the variable is marked as private }
Il codice seguente mostra il getter e il setter.
Le condizioni possono essere fornite durante l'impostazione della variabile.
get A(){ } set A(int a){ if(a>0){// Here condition is applied ......... } }
Per l'incapsulamento, dobbiamo rendere private tutte le variabili di istanza e creare setter e getter per quelle variabili. Il che a sua volta costringerà gli altri a chiamare i setter piuttosto che ad accedere direttamente ai dati.
D # 12) Cos'è il polimorfismo?
Risposta: Il polimorfismo significa molte forme.
Un singolo oggetto può fare riferimento alla superclasse o sottoclasse a seconda del tipo di riferimento che viene chiamato polimorfismo.
Esempio:
Public class Manipulation(){ //Super class public void add(){ } } public class Addition extends Manipulation(){ // Sub class public void add(){ } public static void main(String args[]){ Manipulation addition = new Addition();//Manipulation is reference type and Addition is reference type addition.add(); } }
Usando il tipo di riferimento Manipulation possiamo chiamare il metodo 'add ()' della classe Addition. Questa capacità è nota come polimorfismo. Il polimorfismo è applicabile per prevalente e non per sovraccarico .
D # 13) Cosa si intende per Override del metodo?
Risposta: l'override del metodo si verifica se il metodo della sottoclasse soddisfa le condizioni seguenti con il metodo Superclasse:
- Il nome del metodo dovrebbe essere lo stesso
- L'argomento dovrebbe essere lo stesso
- Anche il tipo restituito dovrebbe essere lo stesso
Il vantaggio principale dell'override è che la sottoclasse può fornire alcune informazioni specifiche su quel tipo di sottoclasse rispetto alla superclasse.
Esempio:
public class Manipulation{ //Super class public void add(){ ……………… } } Public class Addition extends Manipulation(){ Public void add(){ ……….. } Public static void main(String args[]){ Manipulation addition = new Addition(); //Polimorphism is applied addition.add(); // It calls the Sub class add() method } }
addition.add () metodo chiama il metodo add () nella sottoclasse e non nella classe genitore. Quindi sovrascrive il metodo Super-class ed è noto come Method Overriding.
D # 14) Cosa si intende per sovraccarico?
Risposta: Il sovraccarico del metodo si verifica per classi diverse o all'interno della stessa classe.
Per il sovraccarico del metodo, il metodo della sottoclasse deve soddisfare le condizioni seguenti con i metodi del metodo Super-classe (o) nella stessa classe stessa:
- Stesso nome del metodo
- Diversi tipi di argomenti
- Potrebbero esserci diversi tipi di reso
Esempio:
public class Manipulation{ //Super class public void add(String name){ //String parameter ……………… } } Public class Addition extends Manipulation(){ Public void add(){//No Parameter ……….. } Public void add(int a){ //integer parameter } Public static void main(String args[]){ Addition addition = new Addition(); addition.add(); } }
Qui il metodo add () ha parametri diversi nella classe Addition viene sovraccaricato nella stessa classe della superclasse.
Nota: Il polimorfismo non è applicabile per il sovraccarico del metodo.
Q # 15) Cosa si intende per interfaccia?
Risposta: Non è possibile ottenere eredità multiple in java. Per ovviare a questo problema viene introdotto il concetto di interfaccia.
Un'interfaccia è un modello che ha solo dichiarazioni di metodo e non l'implementazione del metodo.
Esempio:
Public abstract interface IManupulation{ //Interface declaration Public abstract void add();//method declaration public abstract void subtract(); }
- Tutti i metodi nell'interfaccia sono interni vuoto astratto pubblico .
- Tutte le variabili nell'interfaccia sono interne finale statico pubblico cioè costanti.
- Le classi possono implementare l'interfaccia e non si estende.
- La classe che implementa l'interfaccia dovrebbe fornire un'implementazione per tutti i metodi dichiarati nell'interfaccia.
public class Manupulation implements IManupulation{ //Manupulation class uses the interface Public void add(){ …………… } Public void subtract(){ ……………. } }
Q # 16) Cosa si intende per classe Abstract?
come aggiungere Maven in Eclipse
Risposta: Possiamo creare la classe Abstract utilizzando la parola chiave “Abstract” prima del nome della classe. Una classe astratta può avere sia metodi 'astratti' che metodi 'non astratti' che sono una classe concreta.
Metodo astratto:
Il metodo che ha solo la dichiarazione e non l'implementazione è chiamato metodo astratto e ha la parola chiave 'abstract'. Le dichiarazioni terminano con un punto e virgola.
Esempio:
public abstract class Manupulation{ public abstract void add();//Abstract method declaration Public void subtract(){ } }
- Una classe astratta può avere anche un metodo non astratto.
- La sottoclasse concreta che estende la classe Abstract dovrebbe fornire l'implementazione per i metodi astratti.
D # 17) Differenza tra array e elenco di array.
Risposta: La differenza tra array e elenco di array può essere compresa dalla tabella seguente:
Vettore | Lista di array |
---|---|
La dimensione deve essere fornita al momento della dichiarazione dell'array. Stringa [] nome = nuova stringa [2] | Le dimensioni potrebbero non essere richieste. Cambia la dimensione in modo dinamico. ArrayList name = nuovo ArrayList |
Per mettere un oggetto in un array dobbiamo specificare l'indice. nome [1] = 'libro' | Nessun indice richiesto. name.add ('libro') |
L'array non è di tipo parametrizzato | ArrayList in java 5.0 sono parametrizzati. Ad esempio: questa parentesi angolare è un parametro di tipo che significa un elenco di stringhe. |
D # 18) Differenza tra String, String Builder e String Buffer.
Risposta:
Corda: Le variabili stringa vengono memorizzate in un 'pool di stringhe costante'. Una volta che il riferimento alla stringa cambia il vecchio valore che esiste nel 'pool di stringhe costanti', non può essere cancellato.
Esempio:
Nome stringa = 'libro';
Pool di stringhe costante
.
Se il valore del nome è cambiato da 'libro' a 'penna'.
Pool di stringhe costante
Quindi il valore più vecchio rimane nel pool di stringhe costanti.
Buffer di stringa:
- Qui i valori di stringa vengono memorizzati in uno stack. Se i valori vengono modificati, il nuovo valore sostituisce il valore precedente.
- Il buffer delle stringhe è sincronizzato, il che è thread-safe.
- Le prestazioni sono più lente rispetto a String Builder.
Esempio:
String Buffer name = 'book';
Una volta che il valore del nome è stato modificato in 'penna', il 'libro' viene cancellato dalla pila.
Generatore di stringhe:
È lo stesso di String Buffer ad eccezione di String Builder che non è threaded in modo sicuro che non è sincronizzato. Quindi ovviamente la performance è veloce.
D # 19) Spiegare gli specificatori di accesso pubblico e privato.
Risposta: I metodi e le variabili di istanza sono noti come membri.
Pubblico:
I membri pubblici sono visibili nello stesso pacchetto così come nel pacchetto esterno che è per altri pacchetti.
I membri pubblici della Classe A sono visibili alla Classe B (stesso pacchetto) e alla Classe C (pacchetti diversi).
Privato:
I membri privati sono visibili solo nella stessa classe e non per le altre classi nello stesso pacchetto così come per le classi nei pacchetti esterni.
I membri privati della classe A sono visibili solo in quella classe. È invisibile per la classe B e per la classe C.
D # 20) Differenza tra gli specificatori di accesso predefinito e protetto.
Risposta:
Predefinito: I metodi e le variabili dichiarati in una classe senza specificatori di accesso sono chiamati predefiniti.
I membri predefiniti nella Classe A sono visibili alle altre classi che si trovano all'interno del pacchetto e invisibili alle classi che sono all'esterno del pacchetto.
Quindi i membri di Classe A sono visibili alla Classe B e invisibili alla Classe C.
Protetto:
.
Protected è uguale a Default, ma se una classe si estende, è visibile anche se è esterna al pacchetto.
I membri della classe A sono visibili alla classe B perché si trova all'interno del pacchetto. Per la Classe C è invisibile, ma se la Classe C estende la Classe A, i membri sono visibili alla Classe C anche se è al di fuori del pacchetto.
D # 21) Differenza tra HashMap e HashTable.
Risposta: La differenza tra HashMap e HashTable può essere vista di seguito:
HashMap | HashTable |
---|---|
I metodi non sono sincronizzati | I metodi chiave sono sincronizzati |
Non thread safety | Sicurezza del filo |
L'iteratore viene utilizzato per iterare i valori | L'enumeratore viene utilizzato per iterare i valori |
Consente una chiave null e più valori null | Non consente nulla che sia nullo |
Le prestazioni sono elevate rispetto a HashTable | Le prestazioni sono lente |
D # 22) Differenza tra HashSet e TreeSet.
Risposta: La differenza tra HashSet e TreeSet può essere vista di seguito:
HashSet | TreeSet |
---|---|
Gli elementi inseriti sono in ordine casuale | Mantiene gli elementi nell'ordine ordinato |
Può in grado di memorizzare oggetti nulli | Impossibile memorizzare oggetti nulli |
Le prestazioni sono veloci | Le prestazioni sono lente |
D # 23) Differenza tra classe astratta e interfaccia.
Risposta: Le differenze tra Abstract Class e Interface sono le seguenti:
Classe astratta:
- Le classi astratte hanno un costruttore predefinito e viene chiamato ogni volta che viene istanziata la sottoclasse concreta.
- Contiene metodi astratti e metodi non astratti.
- La classe che estende la classe Abstract non dovrebbe richiedere l'implementazione di tutti i metodi, solo i metodi Abstract devono essere implementati nella sottoclasse concrete.
- La classe astratta contiene variabili di istanza.
Interfaccia:
- Non ha alcun costruttore e non può essere istanziato.
- Il solo metodo astratto dovrebbe essere dichiarato.
- Le classi che implementano l'interfaccia dovrebbero fornire l'implementazione per tutti i metodi.
- L'interfaccia contiene solo costanti.
Q # 24) Qual è il significato delle collezioni in Java?
Risposta: Collection è un framework progettato per memorizzare gli oggetti e manipolare il design per memorizzare gli oggetti.
Le raccolte vengono utilizzate per eseguire le operazioni seguenti:
- Ricerca
- Ordinamento
- Manipolazione
- Inserimento
- Cancellazione
Un gruppo di oggetti è noto come raccolte. Tutte le classi e le interfacce per la raccolta sono disponibili nel pacchetto Java util.
D # 25) Quali sono tutte le classi e le interfacce disponibili nelle collezioni?
Risposta: Di seguito sono riportate le classi e le interfacce disponibili nelle raccolte:
Interfacce:
- Collezione
- Elenco
- Impostato
- Carta geografica
- Set ordinato
- Mappa ordinata
- Coda
Classi:
- Liste:
- Lista di array
- Vettore
- Lista collegata
Imposta:
- Set di hash
- Set di hash collegati
- Set di alberi
Mappe:
- Mappa hash
- Tabella hash
- TreeMap
- Mappa hash collegata
Coda:
- Coda prioritaria
D # 26) Cosa si intende per raccolte ordinate e ordinate?
Risposta:
Ordinato: Significa che i valori archiviati in una raccolta si basano sui valori aggiunti alla raccolta. Quindi possiamo iterare i valori dalla raccolta in un ordine specifico.
Smistato: I meccanismi di ordinamento possono essere applicati internamente o esternamente in modo che il gruppo di oggetti ordinati in una particolare raccolta si basi sulle proprietà degli oggetti.
D # 27) Spiega i diversi elenchi disponibili nella raccolta.
Risposta: I valori aggiunti all'elenco si basano sulla posizione dell'indice ed è ordinato in base alla posizione dell'indice. Sono consentiti i duplicati.
I tipi di elenchi sono:
a) Elenco array:
- Iterazione veloce e accesso casuale veloce.
- È una raccolta ordinata (per indice) e non ordinata.
- Implementa l'interfaccia di accesso casuale.
Esempio:
public class Fruits{ public static void main (String [ ] args){ ArrayList names=new ArrayList (); names.add (“apple”); names.add (“cherry”); names.add (“kiwi”); names.add (“banana”); names.add (“cherry”); System.out.println (names); } }
Produzione:
[Mela, ciliegia, kiwi, banana, ciliegia]
Dall'output, Array List mantiene l'ordine di inserimento e accetta i duplicati. Ma non è risolto.
b) Vettore:
È lo stesso di Array List.
- I metodi vettoriali sono sincronizzati.
- Sicurezza del filo.
- Implementa anche l'accesso casuale.
- La sicurezza dei thread in genere causa un calo delle prestazioni.
Esempio:
public class Fruit { public static void main (String [ ] args){ Vector names = new Vector ( ); names.add (“cherry”); names.add (“apple”); names.add (“banana”); names.add (“kiwi”); names.add (“apple”); System.out.println (“names”); } }
Produzione:
[ciliegia, mela, banana, kiwi, mela]
Vector mantiene anche l'ordine di inserimento e accetta i duplicati.
c) Elenco collegato:
- Gli elementi sono doppiamente legati l'uno all'altro.
- Le prestazioni sono più lente rispetto all'elenco Array.
- Buona scelta per l'inserimento e la cancellazione.
- In Java 5.0 supporta i metodi di coda comuni peek (), Pool (), Offer () ecc.
Esempio:
public class Fruit { public static void main (String [ ] args){ Linkedlist names = new linkedlist ( ) ; names.add(“banana”); names.add(“cherry”); names.add(“apple”); names.add(“kiwi”); names.add(“banana”); System.out.println (names); } }
Produzione:
[banana, ciliegia, mela, kiwi, banana]
Mantiene l'ordine di inserzione e accetta i duplicati.
D # 28) Spiega Set e i loro tipi in una raccolta.
Risposta: Set ha a cuore l'unicità. Non consente duplicazioni. Qui il metodo 'equals ()' viene utilizzato per determinare se due oggetti sono identici o meno.
a) Hash Set:
- Non ordinato e non ordinato.
- Utilizza il codice hash dell'oggetto per inserire i valori.
- Usalo quando il requisito è 'nessun duplicato e non importa l'ordine'.
Esempio:
public class Fruit { public static void main (String[ ] args){ HashSet names = new HashSet ( ) ; names.add(“banana”); names.add(“cherry”); names.add(“apple”); names.add(“kiwi”); names.add(“banana”); System.out.println (names); } }
Produzione:
[banana, ciliegia, kiwi, mela]
Non segue alcun ordine di inserzione. Non sono consentiti duplicati.
b) Set di hash collegati:
- Una versione ordinata del set di hash è nota come set di hash collegati.
- Mantiene un elenco a doppio collegamento di tutti gli elementi.
- Usalo quando è richiesto un ordine di iterazione.
Esempio:
public class Fruit { public static void main (String[ ] args){ LinkedHashSet; names = new LinkedHashSet ( ) ; names.add(“banana”); names.add(“cherry”); names.add(“apple”); names.add(“kiwi”); names.add(“banana”); System.out.println (names); } }
Produzione:
[banana, ciliegia, mela, kiwi]
Mantiene l'ordine di inserimento in cui sono stati aggiunti al Set. Non sono consentiti duplicati.
c) Set di alberi:
- È una delle due raccolte ordinate.
- Utilizza la struttura ad albero 'Read-Black' e garantisce che gli elementi saranno in ordine crescente.
- Possiamo costruire un insieme di alberi con il costruttore usando un comparable (or) comparator.
Esempio:
public class Fruits{ public static void main (String[ ]args) { Treeset names= new TreeSet( ) ; names.add(“cherry”); names.add(“banana”); names.add(“apple”); names.add(“kiwi”); names.add(“cherry”); System.out.println(names); } }
Produzione:
[mela, banana, ciliegia, kiwi]
TreeSet ordina gli elementi in ordine crescente. E i duplicati non sono ammessi.
D # 29) Spiega la mappa e i suoi tipi.
Risposta: mappa si preoccupa dell'identificatore univoco. Possiamo mappare una chiave univoca a un valore specifico. È una coppia chiave / valore. Possiamo cercare un valore, in base alla chiave. Come il set, anche la mappa utilizza il metodo 'equals ()' per determinare se due chiavi sono uguali o diverse.
La mappa è dei seguenti tipi:
a) Hash Map:
- Mappa non ordinata e non ordinata.
- Hashmap è una buona scelta quando non ci interessa l'ordine.
- Consente una chiave null e più valori null.
Esempio:
Public class Fruit{ Public static void main(String[ ] args){ HashMap names =new HashMap( ); names.put(“key1”,“cherry”); names.put (“key2”,“banana”); names.put (“key3”,“apple”); names.put (“key4”,“kiwi”); names.put (“key1”,“cherry”); System.out.println(names); } }
Produzione:
{key2 = banana, key1 = cherry, key4 = kiwi, key3 = apple}
Le chiavi duplicate non sono consentite in Map.
Non mantiene alcun ordine di inserzione e non è ordinato.
b) Tabella hash:
- Come la chiave vettoriale, i metodi della classe sono sincronizzati.
- Thread safety e quindi rallenta le prestazioni.
- Non consente nulla che sia nullo.
Esempio:
public class Fruit{ public static void main(String[ ]args){ Hashtable names =new Hashtable( ); names.put(“key1”,“cherry”); names.put(“key2”,“apple”); names.put(“key3”,“banana”); names.put(“key4”,“kiwi”); names.put(“key2”,“orange”); System.out.println(names); } }
Produzione:
{key2 = apple, key1 = cherry, key4 = kiwi, key3 = banana}
Non sono consentite chiavi duplicate.
c) Mappa hash collegata:
- Mantiene l'ordine di inserzione.
- Più lento della mappa hash.
- Posso aspettarmi un'iterazione più veloce.
Esempio:
public class Fruit{ public static void main(String[ ] args){ LinkedHashMap names =new LinkedHashMap( ); names.put(“key1”,“cherry”); names.put(“key2”,“apple”); names.put(“key3”,“banana”); names.put(“key4”,“kiwi”); names.put(“key2”,“orange”); System.out.println(names); } }
Produzione:
{key2 = apple, key1 = cherry, key4 = kiwi, key3 = banana}
Non sono consentite chiavi duplicate.
d) TreeMap:
- Mappa ordinata.
- Come Tree set, possiamo costruire un ordinamento con il costruttore.
Esempio:
public class Fruit{ public static void main(String[ ]args){ TreeMap names =new TreeMap( ); names.put(“key1”,“cherry”); names.put(“key2”,“banana”); names.put(“key3”,“apple”); names.put(“key4”,“kiwi”); names.put(“key2”,“orange”); System.out.println(names); } }
Produzione:
{key1 = ciliegia, key2 = banana, key3 = mela, key4 = kiwi}
Viene ordinato in ordine crescente in base alla chiave. Non sono consentite chiavi duplicate.
D # 30) Spiega la coda prioritaria.
Risposta: Queue Interface
Coda prioritaria: La classe dell'elenco collegato è stata migliorata per implementare l'interfaccia della coda. Le code possono essere gestite con un elenco collegato. Lo scopo di una coda è 'Priority-in, Priority-out'.
Quindi gli elementi sono ordinati naturalmente o secondo il comparatore. L'ordinamento degli elementi rappresenta la loro priorità relativa.
D # 31) Cosa si intende per eccezione?
Risposta: Un'eccezione è un problema che può verificarsi durante il normale flusso di esecuzione. Un metodo può generare un'eccezione quando qualcosa si lamenta in fase di esecuzione. Se tale eccezione non può essere gestita, l'esecuzione viene interrotta prima che completi l'attività.
Se abbiamo gestito l'eccezione, il flusso normale viene continuato. Le eccezioni sono una sottoclasse di java.lang.Exception.
Esempio per la gestione delle eccezioni:
try{ //Risky codes are surrounded by this block }catch(Exception e){ //Exceptions are caught in catch block }
Q # 32) Quali sono i tipi di eccezioni?
Risposta: Esistono due tipi di eccezioni. Sono spiegati di seguito in dettaglio.
a) Eccezione verificata:
Queste eccezioni vengono verificate dal compilatore al momento della compilazione. Le classi che estendono la classe Throwable tranne l'eccezione di runtime e l'errore sono chiamate eccezioni controllate.
Le eccezioni selezionate devono dichiarare l'eccezione utilizzando la parola chiave throws (o) circondata da try / catch appropriati.
Per esempio, Eccezione ClassNotFound
b) Eccezione non selezionata:
Queste eccezioni non vengono verificate durante la fase di compilazione dal compilatore. Il compilatore non forza a gestire queste eccezioni. Include:
- Eccezione aritmetica
- Indice della Matrice Fuori Dai Limiti d'Eccezione
D # 33) Quali sono i diversi modi per gestire le eccezioni?
Risposta: Di seguito vengono spiegati due modi diversi per gestire le eccezioni:
a) Utilizzando try / catch:
Il codice rischioso è circondato dal blocco try. Se si verifica un'eccezione, viene rilevata dal blocco catch seguito dal blocco try.
Esempio:
class Manipulation{ public static void main(String[] args){ add(); } Public void add(){ try{ addition(); }catch(Exception e){ e.printStacktrace(); } } }
b) Dichiarando la parola chiave throws:
Alla fine del metodo, possiamo dichiarare l'eccezione usando la parola chiave throws.
Esempio:
class Manipulation{ public static void main(String[] args){ add(); } public void add() throws Exception{ addition(); } }
D # 34) Quali sono i vantaggi della gestione delle eccezioni?
Risposta: i vantaggi sono i seguenti:
- Il normale flusso di esecuzione non verrà interrotto se viene gestita un'eccezione
- Possiamo identificare il problema utilizzando la dichiarazione di cattura
D # 35) Quali sono le parole chiave per la gestione delle eccezioni in Java?
Risposta: Di seguito sono elencate le due parole chiave per la gestione delle eccezioni:
un tentativo:
Quando un codice rischioso è circondato da un blocco try. Un'eccezione che si verifica nel blocco try viene rilevata da un blocco catch. Try può essere seguito da catch (o) finalmente (o) entrambi. Ma uno qualsiasi dei blocchi è obbligatorio.
b) cattura:
Questo è seguito da un blocco di prova. Le eccezioni vengono catturate qui.
c) infine:
Questo è seguito da try block (o) catch block. Questo blocco viene eseguito indipendentemente da un'eccezione. Quindi generalmente i codici di pulizia vengono forniti qui.
D # 36) Spiegare sulla propagazione delle eccezioni.
Risposta: L'eccezione viene generata per la prima volta dal metodo che si trova in cima allo stack. Se non rileva, visualizza il metodo e passa al metodo precedente e così via finché non vengono ottenuti.
Questa è chiamata propagazione delle eccezioni.
Esempio:
public class Manipulation{ public static void main(String[] args){ add(); } public void add(){ addition(); }
Dall'esempio sopra, lo stack appare come mostrato di seguito:
Se si verifica un'eccezione nel file aggiunta () metodo non viene catturato, quindi passa al metodo Inserisci() . Quindi viene spostato nel file principale() metodo e quindi interromperà il flusso di esecuzione. Si chiama Propagazione delle eccezioni.
Q # 37) Qual è la parola chiave finale in Java?
Risposta:
Fine variabile: Una volta che una variabile è stata dichiarata come finale, il valore della variabile non può essere modificato. È come una costante.
Esempio:
int finale = 12;
Metodo finale: Una parola chiave finale in un metodo non può essere sostituita. Se un metodo è contrassegnato come finale, non può essere sovrascritto dalla sottoclasse.
Classe finale: Se una classe viene dichiarata come finale, non è possibile suddividere la classe in una sottoclasse. Nessuna classe può estendere la classe finale.
D # 38) Cos'è un thread?
Risposta: In Java, il flusso di esecuzione si chiama Thread. Ogni programma java ha almeno un thread chiamato thread principale, il thread principale è creato da JVM. L'utente può definire i propri thread estendendo la classe Thread (o) implementando l'interfaccia Runnable. I thread vengono eseguiti contemporaneamente.
Esempio:
public static void main(String[] args){//main thread starts here }
D # 39) Come si crea un thread in Java?
Risposta: Ci sono due modi disponibili per creare un thread.
a) Estendi la classe Thread: Estensione di una classe Thread e sovrascrittura del metodo run. Il thread è disponibile in java.lang.thread.
Esempio:
Public class Addition extends Thread { public void run () { } }
Lo svantaggio dell'utilizzo di una classe thread è che non possiamo estendere altre classi perché abbiamo già esteso la classe thread. Possiamo sovraccaricare il metodo run () nella nostra classe.
b) Implementare l'interfaccia eseguibile: Un altro modo è implementare l'interfaccia eseguibile. Per questo, dovremmo fornire l'implementazione per il metodo run () definito nell'interfaccia.
Esempio:
Public class Addition implements Runnable { public void run () { } }
Q # 40) Spiega il metodo join ().
Risposta: Il metodo Join () viene utilizzato per unire un thread con la fine del thread attualmente in esecuzione.
Esempio:
public static void main (String[] args){ Thread t = new Thread (); t.start (); t.join (); }
In base al codice precedente, il thread principale ha avviato l'esecuzione. Quando raggiunge il codice t.start () quindi 'thread t' avvia il proprio stack per l'esecuzione. JVM passa dal thread principale al 'thread t'.
Una volta raggiunto il codice t.join () quindi solo il 'thread t' viene eseguito e completa il suo compito, quindi solo il thread principale avvia l'esecuzione.
È un metodo non statico. Il metodo Join () ha una versione sovraccarica. Quindi possiamo menzionare la durata del tempo nel metodo join () anche '.s'.
D # 41) Cosa fa il metodo di rendimento della classe Thread?
Risposta: Un metodo yield () sposta il thread attualmente in esecuzione in uno stato eseguibile e consente l'esecuzione degli altri thread. In modo che i thread con priorità uguale abbiano la possibilità di essere eseguiti. È un metodo statico. Non rilascia alcun blocco.
Il metodo Yield () riporta il thread solo nello stato Runnable e non il thread in blocco sleep (), wait () (o).
Esempio:
public static void main (String[] args){ Thread t = new Thread (); t.start (); } public void run(){ Thread.yield(); } }
Q # 42) Spiega il metodo wait ().
Risposta: aspetta () viene utilizzato per far aspettare il thread nel pool di attesa. Quando il metodo wait () viene eseguito durante l'esecuzione di un thread, il thread rinuncia immediatamente al blocco sull'oggetto e va al pool di attesa. Il metodo Wait () dice al thread di attendere per un determinato periodo di tempo.
Quindi il thread si riattiverà dopo che il metodo notify () (o) notify all () viene chiamato.
Wait () e gli altri metodi sopra menzionati non danno immediatamente il blocco sull'oggetto fino a quando il thread attualmente in esecuzione non completa il codice sincronizzato. Viene utilizzato principalmente nella sincronizzazione.
Esempio:
public static void main (String[] args){ Thread t = new Thread (); t.start (); Synchronized (t) { Wait(); } }
D # 43) Differenza tra il metodo notify () e il metodo notifyAll () in Java.
Risposta: Le differenze tra il metodo notify () e il metodo notifyAll () sono elencate di seguito:
notificare() | notifyAll () |
---|---|
Questo metodo viene utilizzato per inviare un segnale per riattivare un singolo thread nel pool di attesa. | Questo metodo invia il segnale per riattivare tutti i thread in uno spool in attesa. |
Q # 44) Come fermare un thread in java? Spiega il metodo sleep () in un thread?
Risposta: Possiamo fermare un thread usando i seguenti metodi di thread:
- Dormire
- In attesa
- Bloccato
Dormire: Il metodo Sleep () viene utilizzato per sospendere il thread attualmente in esecuzione per un determinato periodo di tempo. Una volta che il thread è stato riattivato, può passare allo stato eseguibile. Quindi il metodo sleep () viene utilizzato per ritardare l'esecuzione per un certo periodo.
È un metodo statico.
Esempio:
Filo. Sonno (2000)
Quindi ritarda il thread a dormire 2 millisecondi. Il metodo Sleep () genera un'eccezione ininterrotta, quindi è necessario circondare il blocco con try / catch.
public class ExampleThread implements Runnable{ public static void main (String[] args){ Thread t = new Thread (); t.start (); } public void run(){ try{ Thread.sleep(2000); }catch(InterruptedException e){ } }
Q # 45) Quando utilizzare l'interfaccia Runnable Vs Thread class in Java?
Risposta: Se abbiamo bisogno che la nostra classe estenda alcune altre classi oltre al thread, allora possiamo usare l'interfaccia eseguibile perché in java possiamo estendere solo una classe.
Se non estenderemo nessuna classe, possiamo estendere la classe thread.
D # 46) Differenza tra il metodo start () e run () della classe thread.
Risposta: Il metodo Start () crea un nuovo thread e il codice all'interno del metodo run () viene eseguito nel nuovo thread. Se chiamiamo direttamente il metodo run (), non viene creato un nuovo thread e il thread attualmente in esecuzione continuerà a eseguire il metodo run ().
D # 47) Cos'è il multi-threading?
Risposta: Più thread vengono eseguiti contemporaneamente. Ogni thread avvia il proprio stack in base alla priorità del flusso (o) dei thread.
Programma di esempio:
public class MultipleThreads implements Runnable { public static void main (String[] args){//Main thread starts here Runnable r = new runnable (); Thread t=new thread (); t.start ();//User thread starts here Addition add=new addition (); } public void run(){ go(); }//User thread ends here }
Sulla prima riga di esecuzione, JVM chiama il metodo principale e lo stack del thread principale appare come mostrato di seguito.
Una volta che l'esecuzione raggiunge, t.start () riga quindi viene creato un nuovo thread e viene creato anche il nuovo stack per il thread. Ora JVM passa al nuovo thread e il thread principale torna allo stato eseguibile.
I due stack appaiono come mostrato di seguito.
Ora, il thread dell'utente ha eseguito il codice all'interno del metodo run ().
Una volta completato il metodo run (), la JVM torna al thread principale e il thread utente ha completato l'attività e lo stack è scomparso.
JVM passa da un thread all'altro fino al completamento di entrambi i thread. Questo si chiama Multi-threading.
D # 48) Spiega il ciclo di vita del thread in Java.
Risposta: Il thread ha i seguenti stati:
- Nuovo
- Runnable
- In esecuzione
- Non eseguibile (bloccato)
- Terminato
- Nuovo: Nello stato Nuovo, è stata creata un'istanza di Thread ma il metodo start () non è ancora stato richiamato. Ora il filo non è considerato vivo.
- Runnable : Il Thread è nello stato eseguibile dopo l'invocazione del metodo start (), ma prima che venga richiamato il metodo run (). Ma un thread può anche tornare allo stato eseguibile dall'attesa / sospensione. In questo stato, il thread è considerato vivo.
- In esecuzione : Il thread è in uno stato di esecuzione dopo aver chiamato il metodo run (). Ora il thread inizia l'esecuzione.
- Non eseguibile (Bloccato): il thread è attivo ma non può essere eseguito. Non è nello stato eseguibile ma tornerà allo stato eseguibile dopo un po 'di tempo. Esempio: aspetta, dormi, blocca.
- Terminato : Una volta completato il metodo di esecuzione, viene terminato. Ora il filo non è vivo.
Q # 49) Cos'è la sincronizzazione?
Risposta: La sincronizzazione consente a un solo thread di accedere a un blocco di codice alla volta. Se più thread accedono al blocco di codice, è possibile che alla fine si ottengano risultati imprecisi. Per evitare questo problema, possiamo fornire la sincronizzazione per il blocco sensibile di codici.
La parola chiave sincronizzata significa che un thread necessita di una chiave per accedere al codice sincronizzato.
Le serrature sono per oggetti. Ogni oggetto Java ha un blocco. Una serratura ha una sola chiave. Un thread può accedere a un metodo sincronizzato solo se il thread può ottenere la chiave degli oggetti da bloccare.
Per questo, usiamo la parola chiave 'Synchronized'.
Esempio:
public class ExampleThread implements Runnable{ public static void main (String[] args){ Thread t = new Thread (); t.start (); } public void run(){ synchronized(object){ { } }
D # 50) Qual è lo svantaggio della sincronizzazione?
Anni: La sincronizzazione non è consigliata per implementare tutti i metodi. Perché se un thread accede al codice sincronizzato, il thread successivo dovrebbe attendere. Quindi fa una prestazione lenta dall'altra parte.
D # 51) Cosa si intende per serializzazione?
Risposta: La conversione di un file in un flusso di byte è nota come serializzazione. Gli oggetti nel file vengono convertiti in byte per motivi di sicurezza. Per questo, dobbiamo implementare un'interfaccia java.io.Serializable. Non ha metodo da definire.
Le variabili contrassegnate come transitorie non faranno parte della serializzazione. Quindi possiamo saltare la serializzazione per le variabili nel file usando una parola chiave transitoria.
Ulteriori informazioni = >> Serializzabile e clonabile
Q # 52) Qual è lo scopo di una variabile transitoria?
Risposta: Le variabili transitorie non fanno parte del processo di serializzazione. Durante la deserializzazione, i valori delle variabili transitorie vengono impostati sul valore predefinito. Non viene utilizzato con variabili statiche.
Esempio:
numeri int transitori;
D # 53) Quali metodi vengono utilizzati durante il processo di serializzazione e deserializzazione?
Risposta: Le classi ObjectOutputStream e ObjectInputStream sono java.io di livello superiore. pacchetto. Li useremo con classi di livello inferiore FileOutputStream e FileInputStream.
ObjectOutputStream.writeObject —-> Serializzare l'oggetto e scrivere l'oggetto serializzato in un file.
ObjectInputStream.readObject -> Legge il file e deserializza l'oggetto.
Per essere serializzato, un oggetto deve implementare l'interfaccia serializzabile. Se la superclasse implementa Serializable, la sottoclasse sarà automaticamente serializzabile.
Q # 54) Qual è lo scopo di una variabile volatile?
Risposta: I valori delle variabili volatili vengono sempre letti dalla memoria principale e non dalla memoria cache del thread. Viene utilizzato principalmente durante la sincronizzazione. È applicabile solo per le variabili.
Esempio:
numero int volatile;
D # 55) Differenza tra serializzazione e deserializzazione in Java.
Risposta: Queste sono le differenze tra serializzazione e deserializzazione in java:
Serializzazione | Deserializzazione |
---|---|
La serializzazione è il processo utilizzato per convertire gli oggetti in flusso di byte | La deserializzazione è il processo opposto della serializzazione in cui possiamo recuperare gli oggetti dal flusso di byte. |
Un oggetto viene serializzato scrivendolo come ObjectOutputStream. | Un oggetto viene deserializzato leggendolo da un ObjectInputStream. |
D # 56) Che cos'è SerialVersionUID?
Risposta: Ogni volta che un oggetto viene serializzato, l'oggetto viene contrassegnato con un numero ID di versione per la classe dell'oggetto. Questo ID è chiamato SerialVersionUID. Viene utilizzato durante la deserializzazione per verificare che il mittente e il destinatario siano compatibili con la serializzazione.
Conclusione
Queste sono alcune delle domande chiave dell'intervista JAVA che coprono sia i concetti Java di base che avanzati per la programmazione, nonché l'intervista agli sviluppatori, e queste sono quelle a cui hanno risposto i nostri esperti JAVA.
Spero che questo tutorial ti fornisca una panoramica approfondita dei concetti fondamentali di codifica JAVA in dettaglio. Le spiegazioni fornite sopra arricchiranno davvero le tue conoscenze e aumenteranno la tua comprensione della programmazione JAVA.
Preparati a risolvere con sicurezza un'intervista JAVA.