# Variabili Java: dichiarazione, inizializzazione, tipi ed esempi

Le variabili Java sono contenitori in grado di memorizzare determinati [tipi di dati in Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-di-dati-in-java/). Possono essere suddivise in variabili locali, di istanza e statiche. La dimensione di una variabile in Java non può essere modificata successivamente, ma è comunque possibile modificarne il contenuto.

## Cosa sono le variabili Java?

In ogni [linguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/) esistono delle variabili che vengono utilizzate per lavorare all’interno di un codice e quindi di un programma. In senso stretto, si tratta di **contenitori in cui vengono memorizzati determinati dati di un unico tipo**. In Java, le variabili possono memorizzare [tipi di dati primitivi](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tipi-primitivi-di-java/) come numeri interi, numeri decimali, valori di verità (true e false) e singole cifre. Inoltre, consentono di memorizzare anche tipi di dati complessi come le [stringhe Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-string/). Le variabili Java hanno una dimensione specifica e ben definita, che non può essere cambiata in un secondo momento. È comunque possibile modificarne il contenuto. In questo articolo ti illustriamo le singole variabili con l’aiuto di alcuni esempi.

## Dichiarare e inizializzare le variabili in Java

Per prima cosa, però, ti mostriamo come dichiarare e successivamente inizializzare le variabili in Java. Questo processo è lo stesso per tutti i tipi di variabile. Per la **dichiarazione** sono necessari **due parametri**: prima il tipo di dati da memorizzare in questa variabile, poi il nome della variabile stessa.

Per la seguente **inizializzazione** ci sono **tre fattori** fondamentali: il tipo di dati, il nome della variabile e un valore. Con l’inizializzazione si assegna un valore alla variabile precedentemente vuota. La sintassi è la seguente:

```java
Tipo di dato Nome = Valore;
```

## I tre tipi di variabili in Java

Le variabili Java possono essere suddivise in tre diverse categorie: variabili locali, variabili di istanza e variabili statiche.

### Variabili locali

Se una variabile Java è **dichiarata nella parte principale**, viene definita variabile locale. Può essere utilizzata solo all’interno di un metodo, di un costruttore o di un blocco. L’esempio seguente mostra il funzionamento di una variabile locale nella pratica:

```java
public class Main {
	public static void main(String[] args) {
		int var = 5;
		System.out.println("La variabile locale è: " + var);
	}
}
```

L’output corrispondente ha questo aspetto:

```java
La variabile locale è: 5
```

### Variabili di istanza

Se una variabile Java è dichiarata **all’interno della classe ma al di fuori di un metodo, di un costruttore o di un blocco**, si parla di variabile di istanza. Questa viene generata creando un oggetto con la parola chiave “new”. A differenza delle variabili locali, le variabili di istanza hanno dei valori predefiniti, corrispondenti a “0” o “0.0” per i tipi numerici, “false” per i tipi booleani e “null” per i riferimenti agli oggetti. Ti spieghiamo come utilizzarle nel seguente esempio, dove immaginiamo un gruppo di persone che vogliono contribuire a un regalo di compleanno e specifichiamo il contributo dato da ciascuna persona.

```java
public class Regalo {
	public String nome;
	private double contributo;
	public Regalo (String persona) {
		nome = persona;
	}
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	public double getContributol() {
		return contributo;
	}
	public void setContributo(double partecipanteContributo) {	
		contributo = partecipanteContributo;
	}
	public static void main(String[] args) {
		Regalo partecipante = new Regalo ("Pietro");
		partecipante.setContributo (10);
		System.out.println("Nome: " + partecipante.getNome());
		System.out.println("Partecipante = " + partecipante.getContributo());
		Regalo partecipante2 = new Regalo ("Francesca");
		partecipante2.setContributo(15);
		System.out.println("Nome: " + partecipante2.getNome());
		System.out.println("Contributo = " + partecipante2.getContributo());
	}
}
```

L’output di questo frammento di codice è il seguente:

```java
Nome: Pietro
Contributo = 10.0
Nome: Francesca
Contributo = 15.0
```

### Variabili statiche

Le variabili locali e di istanza non possono essere dichiarate come statiche, al contrario, ovviamente, delle variabili statiche. Essendo dichiarata **fuori da un metodo, un costruttore o un blocco**, la variabile statica appartiene alla classe e non a un’istanza, ed è condivisa da tutte le istanze della classe. L’allocazione della memoria avviene durante il caricamento della classe in memoria. Di seguito un esempio di codice:

```java
public class Regalo {
	public static String partecipante = "Pietro";
	public static void main(String[] args) {
		System.out.println("Partecipante: " + Regalo.partecipante);
	}
}
```

L’output sarà il seguente:

```java
Partecipante: Pietro
```

## Come si creano le diverse variabili?

Il procedimento per creare delle variabili Java è simile a quello appena illustrato. Di seguito ti mostriamo degli esempi dei tipi di variabili più comuni e ti spieghiamo le loro caratteristiche.

### booleano

Un [booleano](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/boolean-in-java/) può contenere solo i valori di verità **true (vero) o false (falso)**. Viene dichiarato come segue:

```java
public class Main {
	public static void main(String[] args) {
		boolean lePatatineFritteSonoBuone = true;
		System.out.println(lePatatineFritteSonoBuone);
	}
}
```

Questo è l’output corrispondente:

```java
true
```

### int

int è il tipo di dati più comunemente utilizzato **per i numeri interi**. Le variabili Java di questo tipo vengono dichiarate come segue:

```java
public class Main {
	public static void main(String[] args) {
		int x = 10;
		System.out.println(x);
	}
}
```

L’output è il seguente:

```java
10
```

### float

La tipologia di dati float viene utilizzata **per i numeri decimali**. La variabile corrispondente viene dichiarata in questo modo:

```java
public class Main {
	public static void main(String[] args) {
		float x = -17.03f;
		System.out.println(x);
	}
}
```

Come output si ottiene:

```java
-17.03
```

### char

char contiene un **carattere singolo**, contrassegnato da virgolette singole. Il codice relativo può presentarsi in questo modo:

```java
public class Main {
	public static void main(String[] args) {
		char x = 'S';
		System.out.println(x);
	}
}
```

L’output che si ottiene è il seguente:

```java
S
```

### String

Oltre ai tipi di dati primitivi illustrati qui sopra, le variabili Java possono contenere anche **sequenze di caratteri complete**, ovvero stringhe. Queste sequenze sono racchiuse tra virgolette doppie. Lo vediamo in questo esempio:

```java
public class Main {
	public static void main(String[] args) {
		String esempio = "Questo è un esempio di stringa in Java.";
--		System.out.println(esempio);
	}
}
```

L’output si presenta come segue:

```java
Questo è un esempio di stringa in Java.
```


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/variabili-java/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/variabili-java/) for AI/LLM consumption.