Il principio handle or declare si basa sulla consapevolezza diffusa che una probabile eccezione non deve mai essere ignorata e quindi passare inosservata.
Esso stabilisce pertanto che, qualunque funzione utilizzi un metodo che potenzialmente può sollevare una eccezione checked, debba gestirla, utilizzando il blocco try-catch, o, in alternativa dichiararlo utilizzando la parola chiave throws, nella sua definizione.

Tutto ciò, con l'obiettivo di scrivere codice robusto che permetta di individuare possibili fonti di malfunzionamento a tempo di compilazione (compile-time) anzichè a tempo di esecuzione (run-time).

In linguaggio Java questo principio si applica in due casististiche:

• la prima è stata già trattata parlando delle nuove eccezioni e del loro utilizzo. In questo caso, non essendoci la volontà di gestire l'eccezione, in quanto la si sta volutamente sollevando per segnalare una situazione anomala, il programmatore deve necessariamente dichiararlo nella definizione della funzione attraverso la clausola throws. Per comodità e ripasso, di seguito riporto nuovamente l'esempio
• la seconda ricorre ogni volta che si utilizza un metodo o una funzione che dichiara di sollevare una eccezione checked. Il principio handle or declare impone al programmatore di gestire l'eccezione, utilizzando il blocco try-catch, oppure in alternativa, di dichiararlo a sua volta utilizzando la parola chiave throws, demandando, in tal caso, la gestione dell'eccezione alla funzione chiamante

Primo caso di applicazione del principio, quando si solleva esplicitamente una eccezione:

// riprendiamo la funzione per il calcolo
// del quoziente intero della divisione

// In questo caso è la funzione stessa a 
// sollevare una eccezione appositamente definita
// per comunicare che non è possibile dividere per zero

// Trattandosi di una eccezione checked, perché deriva
// da Exception, la funzione deve dichiararlo, nella sua 
// definizione, utilizzando la parola chiave throws

public static int quoziente(int dividendo, int divisore) throws DivisoreNulloException {
    if (divisore == 0) {
        throw new DivisoreNulloException(dividendo);
    }
    return dividendo / divisore;
}

Secondo caso di applicazione del principio, quando si utilizza un metodo che dichiara di sollevare una eccezione e si decide di gestirla, come mostrato nel codice seguente

// supponiamo di utilizzare la funzione dell'esempio precedente 
// per implementare una nuova funzione
// che calcola il quoziente della divisione 
// di due numeri ricevuti come parametri 
// e restituisce una frase con l'esito della divisione
// o con il messaggio di errore
public static String messaggioQuoziente(int dividendo, int divisore) {
    String msg = "";
    try {
        int quoziente = quoziente(dividendo, divisore);
        msg = "Il quoziente della divisione tra " + dividendo + " e " + divisore + " è " + quoziente;
    } catch (DivisoreNulloException ex) {
        msg = "Impossibile calcolare il quoziente della divisione tra " + dividendo + " e " + divisore + ", " + ex.getMessage();
    }
    return msg;
}

oppure di dichiararlo, come mostrato nel codice che segue:

// questa volta la stessa funzione 
// non si occupa di gestire l'eventuale eccezione,
// ma dichiara nella sua definizione, utilizzando 
// la parola chiave throws, che, potenzialmente,
// potrebbe sollevare una eccezione di tipo
// DivisoreNulloException.
// In tal caso la gestione dell'eccezione verrebbe 
// demandata al chiamante di questa funzione
// che potrebbe gestirla o dichiararlo a sua volta
public static String messaggioQuoziente(int dividendo, int divisore) throws DivisoreNulloException {
    int quoziente = quoziente(dividendo, divisore);
    return "Il quoziente della divisione tra " + dividendo + " e " + divisore + " è " + quoziente;
}