Scopri come creare un AlertDialog Android in Android Studio: guida passo passo con codice Java per mostrare finestre di dialogo con pulsanti, liste di scelta, RadioButton e CheckBox nelle tue app Android. Usi gli AlertDialog ogni volta che devi chiedere all’utente di confermare un’azione importante, come ad esempio l’eliminazione definitiva di un elemento o il logout. Questi componenti AlertDialog Android Studio sono inoltre ideali per richiedere un consenso esplicito, guidare una scelta tra più opzioni o informare l’utente su conseguenze potenzialmente critiche prima di procedere. Un caso d’uso molto frequente è la conferma di operazioni distruttive (cancellazioni, reset, pagamenti), in cui è fondamentale che l’utente sia pienamente consapevole di ciò che sta per accadere. Altre situazioni tipiche sono la richiesta di permessi sensibili, la scelta di una modalità operativa o la segnalazione di errori bloccanti che impediscono di proseguire nel flusso principale dell’app.

Cos’è un AlertDialog Android?

Una finestra di dialogo è una piccola finestra che richiede all’utente di prendere una decisione e si usa normalmente per eseguire un’azione prima di poter procedere. AlertDialog Android è una finestra di dialogo che può mostrare un titolo, fino a tre pulsanti, o un elenco di elementi selezionabili sia con CheckBox che con RadioButton. Rispetto ad altri tipi di dialog specializzati, come ProgressDialog (per mostrare operazioni in corso) o DatePickerDialog/TimePickerDialog (per consentire la scelta di data e ora), AlertDialog è più generico e flessibile, perché ti permette di combinare liberamente testo, pulsanti e liste. Mentre i dialog di tipo picker sono pensati per input strutturati ben definiti, AlertDialog si concentra sulla conferma di azioni e sulla presentazione di informazioni critiche, lasciando a te la responsabilità di progettare il contenuto in modo chiaro e coerente con il resto dell’interfaccia, rendendo AlertDialog Android uno degli strumenti più versatili per la UI.

Per costruire un AlertDialog Android, la classe AlertDialog.Builder implementa il pattern builder: ti permette di configurare passo passo il contenuto e il comportamento della finestra di dialogo (titolo, messaggio, pulsanti, liste) tramite una serie di metodi concatenabili. In questo modo la logica di configurazione è separata dal momento in cui il builder crea e mostra effettivamente il dialog a schermo. Puoi utilizzare il builder sia all’interno di un’Activity, passando il relativo contesto, sia da un Fragment, sfruttando ad esempio requireContext() o requireActivity() per ottenere il riferimento corretto.

Esempio – AlertDialog con lista di scelta singola

Ecco un esempio completo di AlertDialog con setSingleChoiceItems() per consentire all’utente di selezionare una sola opzione da una lista:

package com.exsample.alertDialog.activities;

import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import android.view.View.*;
import android.widget.*;
import android.view.*;
import android.widget.Button;
import com.exsample.alertDialog.R;
import android.content.*;
import androidx.appcompat.app.*;
import android.content.DialogInterface.*;

public class MainActivity extends AppCompatActivity {

    String option;

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

        final String[] options = {"Data e ora", "Accessibilita'", "Account"};

        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("Fai la tua scelta");

        builder.setSingleChoiceItems(options, 2, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                option = options[which];

                if (options[which].equals(options[0])) {
                    Intent intent = new Intent(android.provider.Settings.ACTION_DATE_SETTINGS);
                    startActivityForResult(intent, 0);
                }
                if (options[which].equals(options[1])) {
                    Intent intent = new Intent(android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS);
                    startActivityForResult(intent, 1);
                }
                if (options[which].equals(options[2])) {
                    Intent intent = new Intent(android.provider.Settings.ACTION_ADD_ACCOUNT);
                    startActivityForResult(intent, 2);
                }
            }
        });

        builder.setNegativeButton("annulla", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        });

        AlertDialog alert = builder.create();
        alert.show();
    }
}

Nel codice precedente, il metodo setSingleChoiceItems() configura una lista a scelta singola, impostando come pre-selezionata la terza voce grazie all’indice 2 passato come parametro. Questo esempio di AlertDialog Android mostra come configurare in modo pratico una lista a scelta singola collegata a diverse azioni di sistema. All’interno del listener, il parametro which rappresenta l’indice dell’elemento selezionato e viene usato per recuperare la stringa corrispondente dall’array options. In base all’opzione scelta, il codice crea e avvia diversi Intent espliciti che aprono le schermate di impostazioni di sistema appropriate, come data e ora, accessibilità o gestione degli account.

Metodi principali per creare un AlertDialog in Android

La classe AlertDialog Android mette a disposizione una serie di metodi che puoi concatenare tramite AlertDialog.Builder per configurare ogni aspetto della finestra di dialogo.

Metodo	Descrizione
setTitle()	Imposta il titolo della finestra di dialogo
setMessage()	Imposta il messaggio testuale principale
setSingleChoiceItems()	Aggiunge una lista con selezione singola (RadioButton)
setMultiChoiceItems()	Aggiunge una lista con selezione multipla (CheckBox)
setView()	Imposta un layout personalizzato all’interno del dialog
setPositiveButton()	Aggiunge il pulsante di conferma (azione principale)
setNegativeButton()	Aggiunge il pulsante di annullamento/chiusura
setNeutralButton()	Aggiunge un pulsante neutro (azione alternativa)
setCancelable()	Imposta se il dialog può essere chiuso toccando fuori o con il tasto Back
create()	Crea l’oggetto AlertDialog
show()	Visualizza la finestra di dialogo

AlertDialog con lista di scelta multipla (setMultiChoiceItems)

Quando devi permettere all’utente di selezionare più elementi contemporaneamente, puoi usare il metodo setMultiChoiceItems(), che mostra una lista con CheckBox. È utile, ad esempio, per scegliere più categorie, più tag o più impostazioni da attivare/disattivare in blocco.

String[] items = {"Notifiche email", "Notifiche SMS", "Notifiche push"};
boolean[] checkedItems = {true, false, true}; // Stato iniziale dei CheckBox

AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
builder.setTitle("Seleziona i canali di notifica");

builder.setMultiChoiceItems(items, checkedItems, new DialogInterface.OnMultiChoiceClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which, boolean isChecked) {
        // Aggiorna l'array di stato quando l'utente seleziona/deseleziona un elemento
        checkedItems[which] = isChecked;
    }
});

builder.setPositiveButton("Conferma", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // Costruisci una stringa con le scelte selezionate
        StringBuilder result = new StringBuilder("Hai scelto: ");
        for (int i = 0; i < items.length; i++) {
            if (checkedItems[i]) {
                result.append("\n- ").append(items[i]);
            }
        }
        Toast.makeText(MainActivity.this, result.toString(), Toast.LENGTH_LONG).show();
    }
});

builder.setNegativeButton("Annulla", null);

AlertDialog dialog = builder.create();
dialog.show();

Questo AlertDialog Android con selezione multipla usa l’array checkedItems per tenere traccia dello stato di ogni CheckBox. Nel listener di setMultiChoiceItems() aggiorni questo array quando l’utente interagisce con la lista, mentre nel pulsante positivo leggi i valori per sapere quali opzioni sono state selezionate e reagire di conseguenza (ad esempio salvando le preferenze o inviando i dati a un server).

AlertDialog con layout personalizzato (setView e LayoutInflater)

Se i metodi standard (titolo, messaggio, liste) non bastano, puoi inserire nel dialog un layout personalizzato con campi di input complessi (EditText, Switch, Spinner, ecc.). In questo caso usi un LayoutInflater per “gonfiare” un file XML e lo passi a setView().

// layout_personalizzato_dialog.xml (res/layout)
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/editTextNome"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Inserisci il tuo nome" />

    <CheckBox
        android:id="@+id/checkBoxNewsletter"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Iscrivimi alla newsletter" />

</LinearLayout>

// In MainActivity.java
LayoutInflater inflater = getLayoutInflater();
View dialogView = inflater.inflate(R.layout.layout_personalizzato_dialog, null);

EditText editTextNome = dialogView.findViewById(R.id.editTextNome);
CheckBox checkBoxNewsletter = dialogView.findViewById(R.id.checkBoxNewsletter);

AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
builder.setTitle("Profilo utente");

// Imposta il layout personalizzato nel dialog
builder.setView(dialogView);

builder.setPositiveButton("Salva", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String nome = editTextNome.getText().toString();
        boolean isIscritto = checkBoxNewsletter.isChecked();
        // Usa i dati raccolti (validazione, salvataggio su DB, chiamata API...)
    }
});

builder.setNegativeButton("Annulla", null);

AlertDialog dialog = builder.create();
dialog.show();

Ricorda che tutti i riferimenti alle view (come editTextNome e checkBoxNewsletter) vanno ottenuti dalla dialogView gonfiata, non dal layout dell’Activity, altrimenti otterrai null o eccezioni a runtime.

Dialog non cancellabile con setCancelable(false)

Per alcune azioni critiche (ad esempio conferma termini legali, step obbligatori di configurazione, operazioni irreversibili) può essere necessario che l’utente non possa chiudere il dialog toccando fuori o premendo il tasto Back. In questo caso puoi usare setCancelable(false).

AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);

builder.setTitle("Attenzione");
builder.setMessage("Questa operazione non può essere annullata. Vuoi procedere?");

builder.setPositiveButton("Procedi", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // Esegui l'operazione critica (es. cancellazione dati)
    }
});

builder.setNegativeButton("Annulla", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        dialog.dismiss();
    }
});

AlertDialog dialog = builder.create();

// Impedisce la chiusura con Back o tocco fuori dall'area del dialog
dialog.setCancelable(false);
dialog.setCanceledOnTouchOutside(false);

dialog.show();

Usa dialog non cancellabili solo quando strettamente necessario, perché interrompono in modo forte il flusso dell’utente. Fornisci sempre un pulsante chiaro per annullare o uscire dall’operazione.

MaterialAlertDialogBuilder per Material Design 3

Se utilizzi la libreria Material Components, puoi creare dialog in stile Material Design 3 usando MaterialAlertDialogBuilder anziché AlertDialog.Builder. In questo modo il dialog eredita automaticamente colori, typography e shape del tuo tema Material.

import com.google.android.material.dialog.MaterialAlertDialogBuilder;

// ...

new MaterialAlertDialogBuilder(MainActivity.this)
        .setTitle("Elimina elemento")
        .setMessage("Sei sicuro di voler eliminare definitivamente questo elemento?")
        .setPositiveButton("Elimina", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                // Azione di eliminazione
            }
        })
        .setNegativeButton("Annulla", null)
        .show();

Per usare MaterialAlertDialogBuilder assicurati di aver aggiunto la dipendenza com.google.android.material:material nel file build.gradle del modulo e di aver impostato un tema basato su Theme.Material3 o Theme.MaterialComponents.

Gestione dei click su pulsanti positivo, negativo e neutro

Un AlertDialog può avere fino a tre pulsanti: positivo, negativo e neutro. È buona pratica assegnare a ciascuno un ruolo chiaro: il pulsante positivo conferma l’azione principale, il negativo annulla/chiude, il neutro offre un’alternativa (ad esempio “Più tardi” o “Aiuto”).

AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);

builder.setTitle("Aggiornamento disponibile");

builder.setMessage("È disponibile una nuova versione dell'app. Vuoi aggiornarla ora?");

builder.setPositiveButton("Aggiorna", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // Avvia aggiornamento (es. apri Play Store)
    }
});

builder.setNegativeButton("Annulla", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // Chiudi il dialog senza fare nulla
        dialog.dismiss();
    }
});

builder.setNeutralButton("Ricordamelo dopo", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        // Salva una preferenza per riproporre il messaggio più tardi
    }
});

AlertDialog dialog = builder.create();
dialog.show();

Ricorda che tutti i listener dei pulsanti vengono eseguiti prima che il dialog venga chiuso automaticamente. Se vuoi mantenere aperto il dialog dopo un click (ad esempio per mostrare errori di validazione) devi sovrascrivere il comportamento di default, ottenendo il pulsante tramite dialog.getButton(AlertDialog.BUTTON_POSITIVE) dopo la chiamata a show() e impostando un listener personalizzato.

FAQ su AlertDialog Android in Java

• 1. Meglio usare AlertDialog o DialogFragment?
  Per dialog semplici (messaggi, conferme rapide) un AlertDialog Android creato con AlertDialog.Builder è spesso sufficiente. Per casi più complessi, che richiedono gestione del ciclo di vita (es. rotazioni schermo, ripristino dopo cambio configurazione) e riutilizzo, è consigliabile usare un DialogFragment, che incapsula il dialog e si integra con il FragmentManager.
• 2. Come evito Memory Leak usando AlertDialog in un’Activity?
  Evita di mantenere riferimenti statici all’Activity o al dialog. Crea il dialog all’interno dell’Activity stessa (o del Fragment) e, se necessario, conserva solo un riferimento debole. In onDestroy() o onStop() verifica se il dialog è ancora visibile e chiamane dismiss() per evitare leak della finestra.
• 3. Posso aggiornare il contenuto di un AlertDialog dopo averlo mostrato?
  Sì. Una volta ottenuto l’oggetto AlertDialog tramite create() e show(), puoi chiamare metodi come setTitle(), setMessage() o aggiornare le view del layout personalizzato (ad esempio un TextView o una ProgressBar). Assicurati solo di mantenere una reference al dialog e alle sue view.
• 4. Come gestisco il click fuori dal dialog o il tasto Back?
  Per impostazione predefinita, toccare fuori dal dialog o premere Back lo chiude, se il dialog è cancellabile. Puoi controllare questo comportamento con setCancelable() sul builder o con setCanceledOnTouchOutside() sull’oggetto AlertDialog. Per intercettare specificamente il tasto Back, puoi usare un OnKeyListener sul dialog.
• 5. È possibile riutilizzare lo stesso AlertDialog più volte?
  Di solito è meglio ricreare il dialog ogni volta che serve, specialmente se il contenuto dipende dallo stato corrente dell’app. Puoi però riusare la stessa configurazione (titolo, messaggio, pulsanti) incapsulando la creazione del dialog in un metodo helper o in una classe utility che restituisce un nuovo AlertDialog configurato in modo coerente.

Conclusione: quando usare un AlertDialog Android

In questa guida abbiamo imparato a creare un AlertDialog Android con lista di scelta e pulsanti. AlertDialog è uno strumento fondamentale per gestire le interazioni con l’utente. Varianti avanzate come setMultiChoiceItems() e setView() permettono di creare dialog con selezioni multiple e form personalizzati. Tuttavia, usali con moderazione: interrompi il flusso dell’utente solo quando necessario. Mantieni testi brevi e pulsanti con etichette chiare (ad esempio “Elimina” invece di “Ok”), così che le conseguenze di ogni azione siano immediatamente comprensibili. Evita dialog annidati o sequenze lunghe, che confondono l’utente e riducono l’efficacia delle richieste importanti.