Gli errori di runtime Java più comuni

Feb 27 2023

Gli errori di runtime si verificano quando un programma non contiene errori di sintassi ma chiede al computer di fare qualcosa che il computer non è in grado di fare in modo affidabile. Durante la compilazione, il compilatore non dispone di alcuna tecnica per rilevare questo tipo di errori.

Gli errori di runtime si verificano quando un programma non contiene errori di sintassi ma chiede al computer di fare qualcosa che il computer non è in grado di fare in modo affidabile . Durante la compilazione, il compilatore non dispone di alcuna tecnica per rilevare questo tipo di errori. È la JVM (Java Virtual Machine) che lo rileva mentre il programma è in esecuzione.

· Eccezione StackOverflowError
· Eccezione OutOfMemoryError
· NegativeArraySizeException
· ArithmeticException
· ArrayIndexOutOfBoundsException
· ArrayStoreException
· UnsupportedOperationException
· NoSuchElementException
· ClassCastException
· DateTimeException
· ConcurrentModificationException
· InputMismatchException
· IllegalFormatConversionException
· NumberFormatException
· InvalidParameterException
· NullPointerException

Eccezione StackOverflowError

StackOverflowError è un errore che Java non consente di rilevare, ad esempio, stack che esaurisce lo spazio, poiché è uno degli errori di runtime più comuni che si possono incontrare.

La causa principale di StackOverflowError è che non abbiamo fornito la condizione di terminazione corretta alla nostra funzione o modello ricorsivo , il che significa che si trasformerà in un loop infinito . Quindi questo errore viene generato quando Java esaurisce la sua memoria disponibile.

// Java program to demonstrate
// infinite recursion error
public class StackOverflowErrorClass {
 static int i = 0;
 // Method to print numbers
 public static int printNumber(int x)
 {
  i = i + 2;
  System.out.println(i);
  return i + printNumber(i + 2);
 }
 public static void main(String[] args)
 {
  // Recursive call without any
  // terminating condition
  StackOverflowErrorClass.printNumber(i);
 }
}

RunTime Error in java code :- Exception in thread “main” java.lang.StackOverflowError
at java.io.PrintStream.write(PrintStream.java:526)
at java.io.PrintStream.print(PrintStream.java:597)
at java.io.PrintStream.println(PrintStream.java:736)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:13)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
at StackOverflowErrorClass.printNumber(StackOverflowErrorClass.java:14)
.
.
.

Eccezione OutOfMemoryError

Errore di spazio/memoria insufficiente (java.lang.OutOfMemoryError) nei thread

Un java.lang.OutOfMemoryError è un errore di runtime in Java che si verifica quando la Java Virtual Machine ( JVM ) non è in grado di allocare un oggetto a causa di spazio insufficiente nell'heap Java. Il Java Garbage Collector ( GC ) non può liberare lo spazio richiesto per un nuovo oggetto, il che causa un java.lang.OutOfMemoryError . Questo errore può essere generato anche quando la memoria nativa non è sufficiente per supportare il caricamento di una classe Java.

Ecco un esempio di generazione generata a causa di spazio heap Java insufficiente:

public class OutOfMemoryErrorExample {
    public static void main(String[] args) {
        Integer[] myArray = new Integer[1000 * 1000 * 1000];
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at OutOfMemoryErrorExample.main(OutOfMemoryErrorExample.java:8)

NegativeArraySizeException

NegativeArraySizeException è un'eccezione di runtime in Java che si verifica quando un'applicazione tenta di creare un array con una dimensione negativa . Poiché NegativeArraySizeException è un'eccezione non verificata (estende RuntimeException ), non è necessario dichiararla nella clausola throws di un metodo o di un costruttore.

Gli sviluppatori devono impostare la dimensione dell'array su un numero intero positivo. Se un segno meno scivola nella dichiarazione della dimensione dell'array, questo genera l'eccezione NegativeArraySizeException.

class JavaError {
public static void main(String[] args) {
    int[] arr = new int[-5]; // Negative size of the array
    arr[8] = 89;
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.NegativeArraySizeException: -5
at JavaError.main(JavaError.java:4)

Eccezione aritmetica

ex. dividere per zero errori

La manipolazione dei dati è una funzione primaria della maggior parte delle applicazioni Java. Quando la manipolazione dei dati include la divisione, gli sviluppatori devono fare attenzione alla divisione per zero . Se zero diventa mai il denominatore in un calcolo, Java genera un'eccezione ArithmeticException. Quindi non possiamo dividere nulla da zero, quindi quando proviamo a farlo otteniamo un'eccezione aritmetica in fase di esecuzione.

class JavaError {
public static void main(String[] args) {
    int a = 23;
    int b = 0;
    System.out.println(a / b);
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArithmeticException: / by zeroat JavaError.main(JavaError.java:7)

Indice della Matrice Fuori Dai Limiti d'Eccezione

quando si accede a un elemento inesistente in un array

Un array in Java richiede una dimensione impostata. Se si tenta di aggiungere più elementi di quelli che l'array può contenere, ciò comporterà l' eccezione ArrayIndexOutOfBoundsException . Il codice seguente tenta di aggiungere un elemento all'indice otto di un array creato per contenere solo cinque elementi:

Accesso all'indice dell'array che non esiste:

class JavaError {
public static void main(String[] args) {
    String[] arr = new String[5];
    arr[6] = "Hi"; // Accessing array index that does not exsist
    System.out.println("Something went wrong!");
  }
}

java -cp /tmp/UDRgGsLLQ6 JavaError
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 6 out of bounds for length 5
at JavaError.main(JavaError.java:6)

Java applica il conteggio in base zero agli elementi in un array, quindi l'indice 6 di un array farebbe riferimento al settimo elemento. Anche il codice seguente attiverebbe un'eccezione ArrayIndexOutOfBoundsException in Java, poiché l'indice 4 è un riferimento al quinto elemento di un array:

String[] arr = new String[5];
arr[5] = "Hi"; // Accessing array index that does not exsist

ArrayStoreException

ArrayStoreException condivide somiglianze con ClassCastException. Questa eccezione di runtime Java si verifica quando il tipo errato di oggetto viene inserito in un array.

Nell'esempio seguente, viene creato un array BigInteger, seguito da un tentativo di aggiungere un Double. Double non condivide una relazione con BigInteger, quindi questo attiva un'eccezione ArrayStoreException in fase di esecuzione.

Number[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345);

BigInteger[] bigInt = new BigInteger[5];
bigInt[0] = Double.valueOf(12345); // Java compile error

Eccezione operazione non supportata

I programmatori Java usano spesso la classe Arrays per trasformare un array Java in un elenco più intuitivo. Tuttavia, l'elenco restituito da Java è di sola lettura. Gli sviluppatori che non sono a conoscenza di questo fatto e tentano di aggiungere nuovi elementi si imbattono nell'eccezione UnsupportedOperationException. Questo esempio mostra come ciò accade:

Integer[] data = {1,2,3,5,8,13,21};
List<Integer> list = Arrays.asList(data);
list.add(new Integer(0));

NoSuchElementException

Non è possibile scorrere un iteratore vuoto. Il codice seguente, che tenta di ottenere l'elemento successivo in un HashSet vuoto, genera un'eccezione NoSuchElementException.

Set set = new HashSet();
set.iterator().next(); // Java runtime exception thrown

if (!set.isEmpty()) {
  set.iterator().next();
}

per errori di conversione del tipo di dati

Java è un linguaggio fortemente tipizzato. Applica rigorosamente le gerarchie di tipo e non eseguirà il cast di un oggetto su un altro a meno che non condividano una relazione polimorfica. Quindi ClassCastException si verifica quando si tenta di trasmettere erroneamente un oggetto a una particolare classe. Ciò significa che il tuo oggetto non è un'istanza o una sottoclasse di questa classe.

Nel codice seguente, il tentativo di eseguire il cast dell'oggetto Date in un Timestamp genera un errore ClassCastException in fase di esecuzione.

Date today = new Date();Timestamp time = (Timestamp)today;

long seconds = System.currentTimeMillis();
Timestamp time = new Timestamp(seconds);
Date today = (Date)time; // this cast works

DateTimeException

La manipolazione dei dati è uno sforzo complicato. Fuso orario, linee di data e formati di data incoerenti possono far sì che Java lanci varie DateTimeException in fase di esecuzione.

Ad esempio, il codice seguente viene compilato, ma il campo HourOfDay della classe LocalDate farà fallire il tentativo di formattare la data.

LocalDate now = LocalDate.now();
DateTimeFormatter.RFC_1123_DATE_TIME.format(now);

LocalDate now = LocalDate.now();
DateTimeFormatter.ISO_DATE.format(now);

per calcoli paralleli implementati in modo errato

Il metodo asList della classe Arrays non è l'unico caso in cui una raccolta richiede il trattamento di sola lettura.

Quando si esegue l'iterazione su un elenco, la raccolta sottostante deve essere corretta e non aggiornata. Pertanto, il metodo add all'interno del seguente frammento di codice genera un'eccezione ConcurrentModificationException.

List servers = new ArrayList();
servers.add("Tomcat");
                   
Iterator<String> iterator = servers.iterator();
while (iterator.hasNext()) {
  String server = iterator.next();
  servers.add("Jetty");  // throws a Runtime Exception
}

InputMismatchException

l' InputMismatchException generalmente si verifica quando si lavora con programmi Java che richiedono agli utenti un input utilizzando la classe Scanner . Questa eccezione è generalmente causata durante l'input dell'utente quando si prevede un certo tipo di input e l'utente immette un diverso tipo di input. In altre parole, questa eccezione può verificarsi quando l'input non è valido per il tipo previsto. L'input non corrisponde al modello per il tipo previsto o non è compreso nell'intervallo.

Come passare dati non validi, ad esempio passare un valore numerico al campo non numerico. Ad esempio, se un programma prevede un valore Integer per un input ma l'utente immette invece un valore String , viene generata un'eccezione InputMismatchException .

Soluzione : avvolgere il codice che richiede l'input dell'utente in un ciclo while che richiederà continuamente all'utente l'input corretto.

IllegalFormatConversionException

Spiegazione : Questo è associato a printf() e String.format() . Significa che c'è un segnaposto non associato (troppi segnaposto, argomenti insufficienti) o è il segnaposto sbagliato per il tipo negli argomenti. Ad esempio, %s è un segnaposto per un numero intero genererà questo errore.

Soluzione : assicurati che il numero di segnaposto corrisponda al numero di argomenti e che i segnaposto siano del tipo corretto.

NumberFormatException

Tentativo di convertire una stringa non valida in un numero

L' eccezione NumberFormatException si verifica quando si tenta di convertire una stringa con un formato non corretto in un valore numerico. Ciò significa che quando non è possibile convertire una stringa in qualsiasi tipo numerico (float, int, ecc.), viene generata questa eccezione. È un'eccezione di runtime (eccezione non controllata) in Java. È una sottoclasse della classe IllegalArgumentException .

Eccezione di parametro non valida

Passaggio di parametri/argomenti non validi a un metodo

Questa eccezione, una sottoclasse di IllegalArgumentException progettata per essere utilizzata dalle classi del motore JCA/JCE, viene generata quando un parametro non valido viene passato a un metodo .

NullPointerException

La NullPointerException è una RuntimeException molto comune riscontrata dalle applicazioni Java. questa eccezione viene generata quando Java incontra un riferimento null quando non se ne aspetta uno. e uno sviluppatore java scrive codice che richiama un metodo su questo riferimento (oggetto non inizializzato).

String data = null;
System.out.println( data.length() ); // throws NullPointerException

Per evitare questa RuntimeException nei tuoi programmi Java, inizializza ogni oggetto che crei prima di usarlo ed esegui un controllo nullo su qualsiasi oggetto che una libreria esterna passa nei tuoi programmi.