Introduzione

In questa guida creerai il tuo primo progetto Android in Java usando Android Studio. Vedremo: come installare Android Studio, creare un nuovo progetto, capire la struttura delle cartelle, analizzare i file MainActivity.java e activity_main.xml, ed eseguire l’app su un emulatore.

1. Installare Android Studio per il tuo Progetto Android Java

Android Studio è l’IDE ufficiale per sviluppare app Android. Include tutto il necessario: editor di codice, emulatori, strumenti di debug e gestione dei progetti.

Passaggi per l’installazione:

• Vai sul sito ufficiale: https://developer.android.com/studio.
• Scarica la versione di Android Studio adatta al tuo sistema operativo (Windows, macOS o Linux).
• Esegui il file di installazione e segui la procedura guidata (puoi lasciare le impostazioni predefinite).
• Al primo avvio, Android Studio ti chiederà di scaricare i componenti aggiuntivi (SDK, emulatori di base, ecc.): accetta e attendi il completamento.

Quando l’installazione è terminata e Android Studio si avvia senza errori, sei pronto a creare il tuo primo progetto.

2. Creare il primo progetto Android in Java

Ora creeremo un progetto semplice con una sola schermata (Activity) che mostra un testo.

Passaggi:

• Apri Android Studio.
• Nella schermata iniziale scegli New Project (Nuovo progetto).
• Seleziona il template Empty Activity e clicca su Next.
• Compila i campi principali:
  • Name: ad esempio PrimoProgettoJava.
  • Package name: sarà generato automaticamente, ad esempio com.example.primoprogettojava.
  • Save location: scegli la cartella dove salvare il progetto.
  • Language: seleziona Java.
  • Minimum SDK: ad esempio API 21: Android 5.0 (Lollipop) o superiore.
• Clicca su Finish.

Android Studio genererà il progetto. Alla fine vedrai l’editor con dei file già creati per te, tra cui MainActivity.java e activity_main.xml.

3. Struttura delle cartelle del Progetto Android Java

Nel pannello di sinistra (di solito chiamato Project) vedrai l’albero dei file. Assicurati che la vista sia impostata su Android (non Project Files) per una visualizzazione semplificata.

• app: è il modulo principale della tua app. Contiene codice sorgente, risorse e file di configurazione.
• java: dentro app/java/... trovi i file di codice Java, ad esempio MainActivity.java.
• res: contiene le risorse (layout, immagini, stringhe, colori, ecc.).
  • layout: in app/res/layout trovi i file di interfaccia utente in XML, ad esempio activity_main.xml.
  • values: contiene file come strings.xml, dove puoi definire testi riutilizzabili, e colors.xml per i colori.
• AndroidManifest.xml: file speciale, definisce informazioni di base sull’app (nome, icona, Activity principali, permessi, ecc.).

Per ora concentrati su MainActivity.java e activity_main.xml, che collegano la logica (Java) all’interfaccia grafica (XML).

4. Spiegazione di MainActivity.java

Apri il file MainActivity.java nel percorso app > java > com.example.primoprogettojava > MainActivity. Dovresti vedere un codice simile a questo:

package com.example.primoprogettojava;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Vediamo cosa significa, riga per riga, in modo semplice:

• package com.example.primoprogettojava; indica il pacchetto (cioè il “contenitore logico”) in cui si trova questa classe.
• import ... sono librerie aggiuntive che usiamo nel file.
• public class MainActivity extends AppCompatActivity: definisce una classe chiamata MainActivity che estende AppCompatActivity, una classe base fornita da Android per creare schermate (Activity) compatibili con molte versioni del sistema.
• onCreate(Bundle savedInstanceState) è il metodo chiamato quando l’Activity viene creata per la prima volta. Qui inizializzi l’interfaccia e la logica.
• setContentView(R.layout.activity_main); collega questa Activity al layout grafico definito nel file activity_main.xml. In pratica dice: “usa quel layout come schermata principale”.

Ora modifichiamo leggermente MainActivity.java per aggiungere un messaggio di log quando l’app si avvia (utile per il debug):

package com.example.primoprogettojava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "L'app è stata avviata correttamente");
    }
}

Questo non cambia l’aspetto dell’app, ma ti permette di vedere nei log che il codice viene eseguito.

5. Spiegazione di activity_main.xml

Ora apri il file activity_main.xml nel percorso app > res > layout > activity_main.xml. Android Studio potrebbe mostrarti due tab: Code e Design. Lavora pure in Code per capire la struttura XML.

Un layout di base potrebbe essere simile a questo:

<?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">
    <TextView
        android:id="@+id/textViewHello"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Ciao, questo è il tuo primo progetto Android!"
        android:textSize="18sp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Spiegazione rapida:

• ConstraintLayout è un tipo di layout flessibile che ti permette di posizionare i componenti fissando dei vincoli (constraints) rispetto ai bordi o ad altri elementi.
• TextView è un componente che mostra testo.
• android:id è l’identificatore univoco del componente, utile per riferirsi a lui nel codice Java.
• android:text è il testo mostrato.
• android:textSize imposta la dimensione del testo.
• Gli attributi app:layout_constraint... servono per centrare il testo nello schermo (vincolando il TextView ai bordi del layout padre).

Puoi modificare il testo come vuoi, ad esempio con il tuo nome o un messaggio personalizzato.

6. Collegare layout e codice (opzionale ma utile)

Per rendere la guida più pratica, colleghiamo il TextView definito in XML al codice Java, così da cambiare il testo da codice.

1. Assicurati che nel file XML il TextView abbia un id, ad esempio @+id/textViewHello (come nell’esempio sopra).

2. Torna in MainActivity.java e modifica il codice così:

package com.example.primoprogettojava;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "L'app è stata avviata correttamente");
        TextView textViewHello = findViewById(R.id.textViewHello);
        textViewHello.setText("Benvenuto nella tua prima app Android in Java!");
    }
}

Ora, quando l’app viene avviata, il testo del TextView verrà impostato dal codice Java.

7. Eseguire la tua App Android Java sull’emulatore

Per vedere la tua app in azione, userai un dispositivo virtuale (emulatore) fornito da Android Studio.

Prima configurazione di un emulatore:

• In Android Studio, in alto, clicca su Device Manager (icona del telefono o dal menu Tools > Device Manager).
• Clicca su Create Device.
• Scegli un modello di telefono (ad esempio Pixel 4) e clicca su Next.
• Scegli una versione di Android (ad esempio una con la dicitura “Recommended”). Se necessario, scarica l’immagine cliccando su Download.
• Conferma con Next e poi Finish.

Ora puoi eseguire l’app:

• Seleziona il tuo nuovo dispositivo virtuale dal menu a tendina in alto, vicino al pulsante “Run” (il triangolo verde).
• Clicca sul pulsante Run (triangolo verde) o premi Shift + F10 (su Windows) o l’equivalente su macOS.
• Android Studio compilerà il progetto e avvierà l’emulatore. La prima volta può richiedere qualche minuto.
• Quando l’app viene installata, vedrai comparire la schermata con il testo che hai impostato.

8. Riepilogo: il tuo Primo Progetto Android Java

Hai creato il tuo primo progetto Android in Java con Android Studio, hai visto come è organizzato il progetto, cosa fanno MainActivity.java e activity_main.xml, e hai eseguito l’app su un emulatore. I prossimi passi consigliati sono:

• Aggiungere un pulsante (Button) al layout e gestire il suo clic in Java.
• Imparare a usare Logcat per leggere i log prodotti dal tuo codice.
• Organizzare stringhe, colori e dimensioni nei file di risorse (res/values).
• Studiare i diversi tipi di layout (LinearLayout, RelativeLayout, ConstraintLayout, ecc.).

Più sperimenti con piccoli cambiamenti (nuovi testi, pulsanti, colori), più prenderai confidenza con il flusso completo: modificare il layout, aggiornare il codice Java ed eseguire l’app sull’emulatore.

Guide correlate

• Activity e Ciclo di Vita in Android
• Layout XML in Android (LinearLayout, RelativeLayout, ConstraintLayout)
• Intent Android
• Fragment in Android