Se stai cercando come usare al meglio la Toolbar Android nelle tue app, questa guida passo passo fa per te. Scoprirai cos’è la Toolbar Android, perché ha sostituito la vecchia ActionBar e come può migliorare la navigazione e l’esperienza utente delle tue schermate. Tutti gli esempi sono scritti in Java e sviluppati con Android Studio, così potrai applicare subito il codice ai tuoi progetti reali. Continua a leggere per imparare come configurarla correttamente e sfruttarla in modo professionale, imparando a personalizzare la Toolbar Android con Java in ogni dettaglio.

La Toolbar Android è il componente moderno che sostituisce la vecchia ActionBar, offrendo più controllo sul layout, sul design e sulla navigazione delle tue schermate. A differenza della ActionBar, la Toolbar è un normale widget di layout che puoi spostare, animare, nascondere o rendere trasparente, integrandola con AppBarLayout, CoordinatorLayout, TabLayout e CollapsingToolbarLayout. In questa guida pratica imparerai come integrare il componente Toolbar in Android Studio, dal tema NoActionBar al collegamento con setSupportActionBar(), dalla navigazione tra Activity alla gestione del menu, della SearchView e delle tab. Il tutorial è pensato per studenti, sviluppatori alle prime armi e chi vuole aggiornare il proprio codice alle linee guida moderne di Android: continua a leggere e segui passo passo la guida.

Toolbar Android: Guida Completa con Esempi Java

La Toolbar (o MaterialToolbar) ha sostituito la vecchia ActionBar nelle app Android. Mostra il titolo, le icone di navigazione e i pulsanti di azione in modo flessibile e personalizzabile, seguendo le regole del Material Design. In questa guida vedrai come impostare un tema NoActionBar, inserire una Toolbar nel layout, gestire la navigazione tra Activity con Java e configurare il Manifest.

Cos’è la Toolbar Android

La Toolbar è un widget delle librerie AppCompat che sostituisce in modo più flessibile la ActionBar tradizionale. A differenza della ActionBar puoi posizionarla in qualsiasi punto del layout, animarla, collegarla allo scroll e personalizzare colori, icone, titolo e menu. Per usarla correttamente devi prima rimuovere la ActionBar dal tema e poi impostare la Toolbar come ActionBar con il metodo setSupportActionBar().

Configurazione Toolbar Android: Impostare il Tema NoActionBar

Per usare la Toolbar al posto della ActionBar devi prima rimuovere la ActionBar dal tema dell’app. Nel file themes.xml imposta come padre un tema NoActionBar. In questo modo la finestra non mostrerà più la barra superiore predefinita e potrai inserire una Toolbar personalizzata nel layout. Per ulteriori dettagli consulta la documentazione ufficiale su AppBarLayout.

// res/values/themes.xml
<resources>
    <style name="Theme.MyApplication" parent="Theme.MaterialComponents.DayNight.NoActionBar">
        <!-- Personalizza qui il tema (colori, tipografia, ecc.) -->
    </style>
</resources>

Layout con MaterialToolbar Android e AppBarLayout

Dopo aver configurato il tema puoi aggiungere la Toolbar nel layout principale dell’Activity. Nell’esempio seguente usiamo un ConstraintLayout come root e inseriamo una MaterialToolbar dentro un AppBarLayout, una struttura tipica delle app basate su Material Design. La Toolbar è fissata nella parte superiore dello schermo e può essere usata come ActionBar tramite codice Java.

// res/layout/activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent">
        <com.google.android.material.appbar.MaterialToolbar
            android:id="@+id/app_bar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:title="Toolbar Android" />
    </com.google.android.material.appbar.AppBarLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

Navigazione tra Activity con Toolbar Android

Per usare la Toolbar come ActionBar nell’Activity principale richiama setSupportActionBar(toolbar) passando l’istanza della Toolbar. In questo modo puoi usare tutti i metodi di AppCompatActivity collegati alla ActionBar, ad esempio getSupportActionBar().setDisplayHomeAsUpEnabled(true) per mostrare la freccia di navigazione “indietro”. Puoi poi gestire il click sulla freccia con setNavigationOnClickListener(), ad esempio per avviare una nuova Activity (nel nostro caso Example) o per eseguire altre azioni di navigazione.

// java/com/example/toolbar/MainActivity.java
package com.example.toolbar;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = findViewById(R.id.app_bar);
        setSupportActionBar(toolbar);
        if (getSupportActionBar() != null) {
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        }
        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(MainActivity.this, Example.class));
                finish();
            }
        });
    }
}

Activity secondaria con Toolbar Android (Example.java)

Per completare l’esempio creiamo una seconda Activity chiamata Example. Il suo layout contiene un pulsante che, quando premuto, riporta l’utente alla MainActivity. In questo modo puoi vedere come la Toolbar apre la nuova Activity, mentre la schermata secondaria gestisce il ritorno tramite un normale Button.

// res/layout/example.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">
    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Torna alla MainActivity" />
</LinearLayout>

// java/com/example/toolbar/Example.java
package com.example.toolbar;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class Example extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.example);
        Button btn = findViewById(R.id.button);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(Example.this, MainActivity.class));
                finish();
            }
        });
    }
}

Dichiarazione Toolbar Android nel Manifest

Per poter avviare le Activity devi dichiararle nel file AndroidManifest.xml. Di seguito trovi un esempio minimale in cui MainActivity è l’Activity principale (con intent-filter MAIN/LAUNCHER) ed Example è una seconda schermata raggiungibile dalla Toolbar di MainActivity.

// AndroidManifest.xml
<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/Theme.MyApplication">
    <activity
        android:name=".Example" />
    <activity
        android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

Perché usare Toolbar Android invece di ActionBar

La scelta tra ActionBar e Toolbar Android oggi non dovrebbe più esistere: la Toolbar è lo standard moderno consigliato dalla documentazione Google. Usando la Toolbar Android ottieni un widget flessibile che puoi inserire in qualsiasi punto del layout, agganciare allo scroll, nascondere o mostrare con animazioni e personalizzare completamente a livello di colori, testo e icone. Inoltre, con la Toolbar puoi avere più app bar nella stessa schermata (ad esempio una Toolbar principale e una secondaria in un fragment) e integrarla facilmente con pattern avanzati come Navigation Drawer, TabLayout e CollapsingToolbarLayout.

I principali vantaggi della Toolbar Android Java rispetto alla vecchia ActionBar sono:

• Flessibilità di posizionamento: non è vincolata alla parte alta della finestra, ma può essere inserita in qualsiasi container di layout.
• Maggiore controllo grafico: puoi personalizzare la Toolbar Android aggiungendo viste personalizzate, loghi, immagini di profilo, badge e indicatori.
• Compatibilità con Material Design: funziona perfettamente con AppBarLayout, CoordinatorLayout, DrawerLayout, TabLayout e gli altri componenti delle librerie Material.
• Supporto completo in AppCompat: con setSupportActionBar() continui a usare le API familiari della ActionBar, ma con la potenza di un widget di layout.
• Maggiore riusabilità: puoi riutilizzare lo stesso layout di Toolbar in più Activity o Fragment, mantenendo un design coerente.

Personalizzazione avanzata della Toolbar Android

Una delle richieste più comuni è personalizzare la Toolbar Android cambiando il colore di sfondo, il colore del testo del titolo e l’icona di navigazione “back”. Di seguito trovi un esempio completo in XML e Java che mostra come impostare una MaterialToolbar con colori personalizzati e una icona di back custom.

// res/layout/activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <com.google.android.material.appbar.MaterialToolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="@color/colorPrimary"   // colore sfondo
            app:title="Toolbar Android Java"            // testo titolo
            app:titleTextColor="@android:color/white"  // colore testo titolo
            app:navigationIcon="@drawable/ic_arrow_back" /> // icona back personalizzata
    </com.google.android.material.appbar.AppBarLayout>
    <FrameLayout
        android:id="@+id/content"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>

// java/com/example/toolbar/MainActivity.java
package com.example.toolbar;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        if (getSupportActionBar() != null) {
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        }
        // Cambia il titolo e il sottotitolo via codice
        toolbar.setTitle("Toolbar Android");
        toolbar.setSubtitle("Esempio di personalizzazione");
        // Cambia l'icona di navigazione via codice (opzionale)
        toolbar.setNavigationIcon(R.drawable.ic_arrow_back);
        // Gestisce il click sulla freccia back
        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(MainActivity.this, "Back premuto", Toast.LENGTH_SHORT).show();
                onBackPressed();
            }
        });
    }
}

Menu nella Toolbar Android: voci di menu e gestione click

Un uso fondamentale della Toolbar Android è mostrare le azioni principali dell’utente sotto forma di icone o testo nel menu in alto a destra. Per aggiungere voci di menu alla Toolbar Android con Java, si usano i file XML di menu e si sovrascrivono i metodi onCreateOptionsMenu() e onOptionsItemSelected() nell’Activity.

// res/menu/menu_main.xml
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/action_search"
        android:title="Cerca"
        android:icon="@drawable/ic_search"
        app:showAsAction="ifRoom|collapseActionView" />
    <item
        android:id="@+id/action_settings"
        android:title="Impostazioni"
        android:icon="@drawable/ic_settings"
        app:showAsAction="ifRoom" />
</menu>

// java/com/example/toolbar/MainActivity.java
@Override
public boolean onCreateOptionsMenu(android.view.Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu); // collega XML alla Toolbar
    return true;
}
@Override
public boolean onOptionsItemSelected(android.view.MenuItem item) {
    int id = item.getItemId();
    if (id == R.id.action_search) {
        // Gestisci click su Cerca
        Toast.makeText(this, "Cerca cliccato", Toast.LENGTH_SHORT).show();
        return true;
    } else if (id == R.id.action_settings) {
        // Gestisci click su Impostazioni
        Toast.makeText(this, "Impostazioni cliccato", Toast.LENGTH_SHORT).show();
        return true;
    }
    return super.onOptionsItemSelected(item);
}

SearchView integrata nella Toolbar Android

Per integrare una barra di ricerca nella Toolbar Android Java si usa di solito il widget SearchView come actionViewClass di una voce di menu. In questo modo la Toolbar mostra un’icona di ricerca che, se cliccata, espande la SearchView direttamente all’interno della barra superiore.

// res/menu/menu_search.xml
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/action_search"
        android:title="Cerca"
        android:icon="@drawable/ic_search"
        app:showAsAction="ifRoom|collapseActionView"
        app:actionViewClass="androidx.appcompat.widget.SearchView" />
</menu>

// java/com/example/toolbar/SearchActivity.java
package com.example.toolbar;
import android.os.Bundle;
import android.widget.Toast;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.SearchView;
import androidx.appcompat.widget.Toolbar;
public class SearchActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_search);
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
    }
    @Override
    public boolean onCreateOptionsMenu(android.view.Menu menu) {
        getMenuInflater().inflate(R.menu.menu_search, menu);
        android.view.MenuItem searchItem = menu.findItem(R.id.action_search);
        SearchView searchView = (SearchView) searchItem.getActionView();
        searchView.setQueryHint("Cerca nella lista...");
        searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
            @Override
            public boolean onQueryTextSubmit(String query) {
                Toast.makeText(SearchActivity.this,
                        "Ricerca: " + query, Toast.LENGTH_SHORT).show();
                return true;
            }
            @Override
            public boolean onQueryTextChange(String newText) {
                // Gestisci il filtro in tempo reale (lista, RecyclerView, ecc.)
                return false;
            }
        });
        return true;
    }
}

Toolbar Android con TabLayout per navigazione a tab

Un pattern molto diffuso nelle app moderne è combinare Toolbar Android, TabLayout e ViewPager2 per creare una navigazione a tab scorrevoli. In questo scenario la Toolbar mostra il titolo e il menu, mentre il TabLayout subito sotto mostra le etichette delle tab.

// res/layout/activity_tabs.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <com.google.android.material.appbar.MaterialToolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            app:title="Toolbar con Tab" />
        <com.google.android.material.tabs.TabLayout
            android:id="@+id/tab_layout"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />
    </com.google.android.material.appbar.AppBarLayout>
    <androidx.viewpager2.widget.ViewPager2
        android:id="@+id/view_pager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_behavior="@string/appbar_scrolling_view_behavior" />
</androidx.coordinatorlayout.widget.CoordinatorLayout>

// java/com/example/toolbar/TabsActivity.java
package com.example.toolbar;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.viewpager2.widget.ViewPager2;
import com.google.android.material.tabs.TabLayout;
import com.google.android.material.tabs.TabLayoutMediator;
public class TabsActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_tabs);
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        TabLayout tabLayout = findViewById(R.id.tab_layout);
        ViewPager2 viewPager = findViewById(R.id.view_pager);
        // Adapter personalizzato che restituisce i Fragment per ogni tab
        TabsPagerAdapter adapter = new TabsPagerAdapter(this);
        viewPager.setAdapter(adapter);
        new TabLayoutMediator(tabLayout, viewPager,
                new TabLayoutMediator.TabConfigurationStrategy() {
                    @Override
                    public void onConfigureTab(@NonNull TabLayout.Tab tab, int position) {
                        if (position == 0) {
                            tab.setText("Home");
                        } else if (position == 1) {
                            tab.setText("Preferiti");
                        } else {
                            tab.setText("Profilo");
                        }
                    }
                }).attach();
    }
}

Toolbar Android collassabile con CollapsingToolbarLayout

Per ottenere un effetto grafico avanzato, ad esempio una Toolbar che si espande con un’immagine grande e si collassa mentre l’utente scorre la lista, puoi usare CollapsingToolbarLayout insieme a AppBarLayout e CoordinatorLayout. Questo pattern è molto comune in schermate di dettaglio (ad esempio scheda di un prodotto o profilo utente).

// res/layout/activity_collapsing.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="300dp"
        android:fitsSystemWindows="true">
        <com.google.android.material.appbar.CollapsingToolbarLayout
            android:id="@+id/collapsing_toolbar"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layout_scrollFlags="scroll|exitUntilCollapsed"
            app:title="Collapsing Toolbar"
            app:contentScrim="@color/colorPrimary">
            <ImageView
                android:id="@+id/header_image"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:scaleType="centerCrop"
                android:src="@drawable/header" />
            <com.google.android.material.appbar.MaterialToolbar
                android:id="@+id/toolbar"
                android:layout_width="match_parent"
                android:layout_height="?attr/actionBarSize"
                app:layout_collapseMode="pin" />
        </com.google.android.material.appbar.CollapsingToolbarLayout>
    </com.google.android.material.appbar.AppBarLayout>
    <androidx.core.widget.NestedScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_behavior="@string/appbar_scrolling_view_behavior">
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:padding="16dp">
            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="Contenuto lungo..." />
        </LinearLayout>
    </androidx.core.widget.NestedScrollView>
</androidx.coordinatorlayout.widget.CoordinatorLayout>

// java/com/example/toolbar/CollapsingActivity.java
package com.example.toolbar;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import com.google.android.material.appbar.CollapsingToolbarLayout;
public class CollapsingActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collapsing);
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        if (getSupportActionBar() != null) {
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        }
        CollapsingToolbarLayout collapsingToolbar = findViewById(R.id.collapsing_toolbar);
        collapsingToolbar.setTitle("Dettaglio articolo");
    }
}

Domande frequenti

• Come nascondere la Toolbar Android?
  Puoi nascondere temporaneamente la Toolbar chiamando getSupportActionBar().hide() in un’Activity che usa setSupportActionBar(). Per mostrarla di nuovo usa getSupportActionBar().show(). Se invece vuoi una Toolbar che scompare mentre scorri, usa AppBarLayout e CoordinatorLayout con i flag di scroll.
• Come aggiungere un badge alla Toolbar Android?
  Per mostrare un badge (ad esempio il numero di notifiche) su un’icona della Toolbar, usa un ActionView personalizzato nel menu. Crea un layout XML con un’icona e un TextView per il numero, assegnalo come actionLayout all’item di menu e aggiorna il TextView da Java.
• Come fare la Toolbar Android trasparente?
  Per ottenere una Toolbar trasparente imposta android:background="@android:color/transparent" nella definizione XML della Toolbar o chiama toolbar.setBackgroundColor(Color.TRANSPARENT) da Java. Ricorda di adeguare il colore del testo del titolo per mantenere una buona leggibilità.
• Come cambiare il colore del testo del titolo nella Toolbar Android?
  Puoi impostare il colore del titolo in XML con app:titleTextColor oppure in Java con toolbar.setTitleTextColor(getResources().getColor(R.color.white));. Se usi un tema MaterialComponents puoi anche impostare il colore tramite gli attributi del tema (ad esempio colorOnPrimary).
• Come impostare una Toolbar diversa per ogni Activity?
  La Toolbar Android essendo un normale widget di layout può essere definita in ogni file XML di Activity o Fragment. Ogni Activity può avere la propria Toolbar personalizzata: basta richiamare setSupportActionBar() nell’Activity e configurare titolo, menu e icone in modo specifico per quella schermata.

Metodi e API principali

Di seguito trovi una panoramica rapida dei metodi più usati quando lavori con Toolbar e AppCompatActivity in Java.

Metodo	Descrizione
setSupportActionBar(Toolbar toolbar)	Imposta la Toolbar passata come ActionBar dell’Activity, consentendo l’uso dei metodi di getSupportActionBar().
getSupportActionBar().setDisplayHomeAsUpEnabled(true)	Mostra la freccia di navigazione “indietro” (icona Up) nella Toolbar.
toolbar.setNavigationOnClickListener(...)	Imposta il listener per il click sull’icona di navigazione (freccia indietro o icona personalizzata).
toolbar.setTitle(String title)	Imposta il titolo testuale mostrato nella Toolbar.
toolbar.setSubtitle(String subtitle)	Imposta il sottotitolo mostrato sotto o accanto al titolo principale.
toolbar.inflateMenu(int menuRes)	Gonfia un file di menu XML e aggiunge le voci di azione (icona o testo) alla Toolbar.

Conclusione: perché vale la pena usarla

La Toolbar è uno strumento essenziale per creare interfacce moderne e in linea con il Material Design. Configurando un tema NoActionBar, inserendo una MaterialToolbar nel layout e collegandola al codice con setSupportActionBar(), puoi gestire titoli, icone di navigazione e azioni in modo flessibile. Partendo dagli esempi Java di questa guida puoi estendere il comportamento della Toolbar, aggiungere menu, gestire più Activity e costruire una navigazione chiara per la tua applicazione.

---