Activity in Android: Guida Completa con Esempi Java

Guida al ciclo di vita delle Activity in Android (Java)

Activity in Android è una componente fondamentale che rappresenta una singola schermata con cui l’utente può interagire, ad esempio una schermata di login o una lista di elementi. Capire il ciclo di vita di questa classe è essenziale per gestire correttamente risorse, dati e comportamento della tua app. Per approfondire, consulta la documentazione ufficiale Android sulle Activity.

Conoscere a fondo il ciclo di vita di una Activity in Android ti permette di capire quando il sistema crea, mostra, mette in pausa e distrugge le tue schermate. Questo è essenziale per evitare crash improvvisi, consumi eccessivi di batteria e comportamenti strani dell’interfaccia (come dati che spariscono dopo una rotazione dello schermo).

Gli errori più comuni dei principianti sono, ad esempio, fare operazioni pesanti in onCreate() (come chiamate di rete o query complesse al database) bloccando la UI, oppure dimenticare di rilasciare risorse in onStop() o onDestroy() (sensori, listener, connessioni) lasciando l’app consumare memoria e batteria anche quando non è visibile.

Immagina un’app che avvia aggiornamenti GPS in onResume(), ma non li ferma correttamente in onPause() o onStop(): l’utente chiude l’app, ma il GPS resta attivo in background, consumando batteria e risorse. Oppure pensa a un form lungo dove non salvi lo stato: basta una rotazione dello schermo e tutti i dati inseriti spariscono. Una buona gestione del ciclo di vita serve proprio a prevenire questi problemi.

Il ciclo di vita di una Activity in Android

Cos’è un’Activity in Android

Questa classe è una componente fondamentale di un’app Android. Ogni schermata di questo tipo:

Ha un layout grafico (XML) che definisce cosa vede l’utente.
Contiene codice Java (o Kotlin) che gestisce la logica.
Passa attraverso diversi stati (creata, visibile, in pausa, distrutta…).

Per creare questa schermata in Java estendi la classe AppCompatActivity (o Activity) e sovrascrivi i metodi principali del ciclo di vita.

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Ciclo di vita di un’Activity in Android

I metodi principali del ciclo di vita di un’Activity sono:

onCreate()
onStart()
onResume()
onPause()
onStop()
onDestroy()

In più, per gestire cambi di configurazione (come la rotazione dello schermo) è importante conoscere anche onSaveInstanceState() e onRestoreInstanceState().

onCreate()

Quando Android chiama il metodo: la prima volta che Android crea l’Activity.

A cosa serve:

Impostare il layout con setContentView().
Inizializzare variabili, viste (findViewById), adapter, listener.
Recuperare dati passati tramite Intent.

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Esempio: inizializzazione di una TextView
    TextView titleTextView = findViewById(R.id.titleTextView);
    titleTextView.setText("Benvenuto!");

    // Esempio: leggere extra da un Intent
    Intent intent = getIntent();
    String username = intent.getStringExtra("USERNAME");
}

onStart()

Quando Android chiama il metodo: subito dopo onCreate(), o quando l’Activity torna visibile ma Android non l’ha ancora messa in primo piano.

A cosa serve:

Preparare l’Activity a diventare visibile all’utente.
Avviare componenti che devono essere attivi quando la schermata è visibile (ma non ancora interattiva al 100%).

@Override
protected void onStart() {
    super.onStart();
    // Esempio: registrare un BroadcastReceiver
    // registerReceiver(myReceiver, myIntentFilter);
}

onResume()

Quando Android chiama il metodo: dopo onStart(), quando l’Activity è in primo piano e l’utente può interagire con essa.

A cosa serve:

Riprendere animazioni, audio, video.
Riprendere aggiornamenti in tempo reale (timer, listener, sensori).
Verificare permessi o stato della sessione prima che l’utente interagisca.

@Override
protected void onResume() {
    super.onResume();
    // Esempio: avviare un timer
    // startTimer();
}

onPause()

Quando Android chiama il metodo: quando l’Activity sta per andare in background, ad esempio perché un’altra Activity sta per aprirsi o compare una finestra di dialogo a schermo intero.

A cosa serve:

Salvare dati temporanei (ad esempio il testo digitato in un campo).
Sospendere animazioni, audio, video.
Rilasciare risorse che non devono continuare a funzionare in background.

@Override
protected void onPause() {
    super.onPause();
    // Esempio: mettere in pausa un video
    // videoView.pause();

    // Esempio: salvare uno stato temporaneo
    // SharedPreferences prefs = getSharedPreferences("app_prefs", MODE_PRIVATE);
    // prefs.edit().putString("draft_text", editText.getText().toString()).apply();
}

onStop()

Quando Android chiama il metodo: quando l’Activity non è più visibile all’utente, ad esempio perché un’altra Activity copre completamente lo schermo o l’app è finita in background.

A cosa serve:

Rilasciare risorse pesanti (connessioni al database, sensori, listener).
Salvare in modo più definitivo i dati (ad esempio sul database o su file).

@Override
protected void onStop() {
    super.onStop();
    // Esempio: annullare richieste di rete o chiudere il database
    // if (db != null) {
    //     db.close();
    // }
}

onDestroy()

Quando Android chiama il metodo: quando Android sta per distruggere in modo definitivo l’Activity. Può succedere perché l’utente ha chiuso l’app o perché il sistema deve liberare memoria.

A cosa serve:

Fare pulizia finale di risorse non ancora rilasciate.
Annullare thread, handler o altre operazioni a lungo termine.

@Override
protected void onDestroy() {
    super.onDestroy();
    // Esempio: annullare un handler
    // handler.removeCallbacksAndMessages(null);
}

Esempio completo di Activity con tutti i metodi

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("CicloDiVita", "onCreate");
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("CicloDiVita", "onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("CicloDiVita", "onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("CicloDiVita", "onPause");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("CicloDiVita", "onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("CicloDiVita", "onDestroy");
    }
}

Scenari pratici per le Activity in Android

Ecco alcuni scenari tipici che puoi incontrare nello sviluppo di un’app Android.

Inizializzare un’Activity in Android con onCreate

Immagina una schermata di login. In onCreate() puoi:

Collegare gli EditText e il pulsante di login.
Impostare i listener per il click sul pulsante.
Caricare eventuali valori salvati (es. “Ricordami”).

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_login);

    EditText usernameEditText = findViewById(R.id.usernameEditText);
    EditText passwordEditText = findViewById(R.id.passwordEditText);
    Button loginButton = findViewById(R.id.loginButton);

    loginButton.setOnClickListener(v -> {
        // Logica di login
    });
}

Riprendere risorse in un’Activity Android con onResume

Per una schermata che mostra la posizione GPS dell’utente, in onResume() puoi riattivare gli aggiornamenti della posizione, mentre in onPause() li sospendi per risparmiare batteria.

@Override
protected void onResume() {
    super.onResume();
    // startLocationUpdates();
}

@Override
protected void onPause() {
    super.onPause();
    // stopLocationUpdates();
}

Salvare dati con onPause in un’Activity Android

In un form lungo, puoi salvare il testo inserito quando l’Activity va in background, così l’utente non perde i dati se l’app viene chiusa.

@Override
protected void onPause() {
    super.onPause();

    EditText noteEditText = findViewById(R.id.noteEditText);
    String noteText = noteEditText.getText().toString();

    SharedPreferences prefs = getSharedPreferences("notes_prefs", MODE_PRIVATE);
    prefs.edit().putString("current_note", noteText).apply();
}

Gestire la rotazione in un’Activity Android

Quando giri lo schermo (da portrait a landscape), Android per impostazione predefinita distrugge e ricrea l’Activity. Questo significa che Android chiama onPause(), onStop() e onDestroy(), poi chiama di nuovo onCreate(), onStart(), onResume().

Se non gestisci questo comportamento, rischi di perdere dati inseriti dall’utente (es. testo in un campo) o lo stato dell’interfaccia. Per evitare problemi, puoi usare onSaveInstanceState() e onRestoreInstanceState() (o leggere dal Bundle in onCreate()).

onSaveInstanceState() e onRestoreInstanceState()

onSaveInstanceState(Bundle outState) Android chiama questo metodo prima di poter distruggere l’Activity (ad esempio per rotazione). Qui salvi lo stato minimo necessario.

onRestoreInstanceState(Bundle savedInstanceState) Android chiama questo metodo dopo onStart(), solo se il sistema ha salvato uno stato precedente. In alternativa puoi leggere dal Bundle in onCreate().

private static final String KEY_COUNTER = "counter";
private int counter = 0;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState != null) {
        counter = savedInstanceState.getInt(KEY_COUNTER, 0);
    }

    TextView counterTextView = findViewById(R.id.counterTextView);
    counterTextView.setText(String.valueOf(counter));
}

@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt(KEY_COUNTER, counter);
}

@Override
protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    counter = savedInstanceState.getInt(KEY_COUNTER, 0);

    TextView counterTextView = findViewById(R.id.counterTextView);
    counterTextView.setText(String.valueOf(counter));
}

Alternative: evitare il restart con configChanges (sconsigliato ai principianti)

Nel file AndroidManifest.xml puoi dire al sistema che non deve distruggere l’Activity in caso di rotazione, gestendo tu manualmente il cambiamento:

<activity
    android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

In questo caso Android chiama onConfigurationChanged() invece di ricreare l’Activity. Tuttavia, in generale sconsigliamo questa soluzione ai principianti perché rischia di complicare la gestione dell’interfaccia e non segue il comportamento standard di Android.

Metodo	Quando viene chiamato	Cosa fare	Cosa NON fare
`onCreate()`	Quando l’Activity viene creata per la prima volta.	Inizializzare layout, viste, variabili e leggere dati da Intent o stato salvato.	Eseguire operazioni pesanti (rete, I/O complesso) direttamente sul thread principale.
`onStart()`	Quando l’Activity sta per diventare visibile.	Preparare componenti che devono essere pronti quando la schermata appare.	Avviare logiche che è meglio gestire in `onResume()` (es. ripresa animazioni interattive).
`onResume()`	Quando l’Activity è in primo piano e l’utente può interagire.	Riprendere animazioni, sensori, listener e aggiornamenti in tempo reale.	Allocare risorse che potrebbero vivere anche quando l’Activity non è in primo piano.
`onPause()`	Quando l’Activity sta per andare in background.	Salvare rapidamente dati leggeri e mettere in pausa risorse attive.	Eseguire salvataggi lenti o chiusure pesanti che rischiano di bloccare la UI.
`onStop()`	Quando l’Activity non è più visibile.	Rilasciare risorse pesanti e completare salvataggi persistenti.	Lasciare aperte connessioni, listener o servizi non più necessari.
`onDestroy()`	Prima che l’Activity venga distrutta definitivamente.	Fare pulizia finale di tutto ciò che non è stato rilasciato prima.	Affidarsi solo a questo metodo per salvare dati importanti.
`onSaveInstanceState()`	Prima che l’Activity possa essere distrutta (es. per rotazione o mancanza di memoria).	Salvare lo stato minimo necessario per ricostruire la UI (testo, selezioni, posizione).	Usarlo come unico meccanismo di persistenza per dati che devono sopravvivere all’app chiusa.
`onRestoreInstanceState()`	Dopo `onStart()`, se esiste uno stato salvato.	Ripristinare lo stato della UI dai dati salvati nel `Bundle`.	Dare per scontato che venga sempre chiamato (controlla sempre `savedInstanceState`).

Riepilogo: metodi del ciclo di vita Activity Android

onCreate(): inizializza layout, viste, dati di base.
onStart(): l’Activity sta diventando visibile.
onResume(): l’Activity è in primo piano; riprendi risorse attive.
onPause(): l’Activity sta per andare in background; salva dati leggeri e ferma ciò che non deve continuare.
onStop(): l’Activity non è più visibile; rilascia risorse pesanti.
onDestroy(): pulizia finale prima che l’Activity venga distrutta.
onSaveInstanceState()/onRestoreInstanceState(): salva e ripristina lo stato in caso di rotazione o altre ricreazioni dell’Activity.

Capire bene quando e come usare questi metodi ti aiuterà a scrivere app più stabili, reattive e facili da mantenere.

Domande frequenti sull’Activity in Android

Qual è la differenza tra onPause e onStop?

Quando usare onSaveInstanceState?

L’Activity viene sempre distrutta quando ruoto lo schermo?

Qual è la differenza tra finish() e onDestroy()?

Activity in Android: Guida Completa con Esempi Java

Guida al ciclo di vita delle Activity in Android (Java)

Cos’è un’Activity in Android

Ciclo di vita di un’Activity in Android

onCreate()

onStart()

onResume()

onPause()

onStop()

onDestroy()

Esempio completo di Activity con tutti i metodi

Scenari pratici per le Activity in Android

Inizializzare un’Activity in Android con onCreate

Riprendere risorse in un’Activity Android con onResume

Salvare dati con onPause in un’Activity Android

Gestire la rotazione in un’Activity Android

onSaveInstanceState() e onRestoreInstanceState()

Alternative: evitare il restart con configChanges (sconsigliato ai principianti)

Riepilogo: metodi del ciclo di vita Activity Android

Domande frequenti sull’Activity in Android

Guide correlate

Condividi:

Mi piace:

Commenti

RispondiAnnulla risposta

Altri articoli

libGDX Android: Game Loop e Rendering con OpenGL ES – Parte 2

libGDX Android con OpenGL ES e Layout XML – Guida Completa in Java

Classi Astratte vs Interfacce in Android Java: Guida Completa con Mini App

Mini App Gestione Prodotti Android: OOP Completa in Java

Scopri di più da App Tutorial