# Variáveis Java: declaração, inicialização, tipos e exemplos

As variáveis Java são recipientes onde podem ser armazenados determinados [tipos de dados Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/tipos-de-dados-java/). Podem ser subdivididas em variáveis locais, de instâncias e estáticas. Embora não seja possível alterar o tamanho de uma variável Java posteriormente, é possível editar o seu conteúdo.

## O que são variáveis Java?

Em todas as linguagens de programação existem variáveis que são utilizadas para trabalhar dentro de um código e, portanto, dentro de um programa. Em sentido estrito, são **recipientes nos quais são armazenados determinados dados de um tipo, e apenas desse tipo**. As variáveis Java podem, por um lado, armazenar [tipos de dados primitivos](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/primitivos-de-java/), como números inteiros, decimais, valores verdadeiros (verdadeiro e falso) ou dígitos individuais. Por outro lado, também servem para armazenar tipos de dados complexos, como [strings de Java](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/strings-java/). As variáveis Java têm um tamanho claro e definido que não pode ser modificado posteriormente. No entanto, o conteúdo pode ser editado posteriormente. A seguir, explicamos cada variável com o seu exemplo correspondente.

## Como declarar e inicializar Java var

Antes de mais nada, vamos mostrar como declarar e inicializar variáveis em Java. Esse processo é o mesmo para todos os tipos de dados. Para **declarar**, são necessários **dois parâmetros**: primeiro, o tipo de dado que será armazenado nessa variável; depois, o nome da variável Java.

Depois, para **inicializar**, deve ter **três fatores**: por um lado, o tipo de dado e o nome da variável e, por outro, um valor. A inicialização atribui um valor à variável até então vazia. A sintaxe é a seguinte:

```java
Nombre del tipo de dato = valor;
```

## Três tipos de variáveis em Java

As variáveis Java podem ser subdivididas em três categorias distintas: variáveis locais, variáveis de instância e variáveis estáticas.

### Variáveis locais

Se **uma variável Java** for **declarada no segmento principal**, ela é considerada uma variável local. Ela só pode ser usada dentro de um método, um construtor ou um bloco. No exemplo a seguir, você verá como uma variável local é usada na prática:

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

Retorna o seguinte:

```java
La variable local es: 5
```

### Variáveis de instância

Se uma variável Java for declarada **dentro da classe, mas fora do método, construtor ou bloco**, trata-se de uma variável de instância. Ela é criada quando um objeto é criado com a palavra-chave “new”. Ao contrário das variáveis locais, as variáveis de instância têm valores padrão. São 0 ou 0,0 para tipos numéricos, false para tipos booleanos e zero para referências a objetos. Você pode ver seu uso no exemplo a seguir. Imagine que um grupo de pessoas quer participar de um presente de aniversário e escreve o que cada um contribuiu.

```java
public class regalo {
	public String name;
	private double aportacion;
	public regalo (String person) {
		name = person;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getAportacion() {
		return aportacion;
	}
	public void setAportacion(double participanteAportacion) {	
		aportacion = participanteAportacion;
	}
	public static void main(String[] args) {
		regalo participante = new regalo ("Pedro");
		participante.setAportacion(10);
		System.out.println("Name: " + participante.getName());
		System.out.println("Aportación = " + participante.getAportacion());
		regalo participante2 = new regalo ("Sara");
		participante2.setAportacion(15);
		System.out.println("Name: " + participante2.getName());
		System.out.println("Aportación = " + participante2.getAportacion());
	}
}
```

O resultado para este fragmento de código é:

```java
Name: Pedro
Aportación = 10.0
Name: Sara
Aportación = 15.0
```

### Variáveis estáticas

Enquanto as outras duas variáveis Java não podem ser declaradas como estáticas, evidentemente esse não é o caso da variável estática. Ela é declarada **fora de um método, um construtor ou um bloco** e pertence à classe e não a uma instância, portanto, é partilhada por todas as instâncias da classe. A sua atribuição de memória é realizada enquanto a classe é carregada na memória. Aqui está um exemplo de código:

```java
public class regalo {
	public static String participante = "Pedro";
	public static void main(String[] args) {
		System.out.println("participante: " + regalo.participante);
	}
}
```

O seguinte é devolvido:

```java
Participante: Pedro
```

## Como são criadas as diferentes variáveis?

O procedimento para criar diferentes variáveis Java é muito semelhante. Aqui está um exemplo dos tipos de variáveis mais comuns com algumas das suas particularidades.

### booleano

Um [booleano](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-booleano-1/) só pode conter um valor **verdadeiro (true) ou falso (false)**. É declarado assim:

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

Retorna:

```java
true
```

### int

int é o tipo de dados mais utilizado **para números inteiros**. As variáveis Java que pertencem a este tipo são declaradas assim:

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

E sai:

```java
10
```

### float

float é usado **para números decimais**. A variável é declarada assim:

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

É devolvido:

```java
-17.03
```

### char

char contém **um único caractere** que é marcado com aspas simples na parte superior. Aqui está um fragmento de código:

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

E assim é o que aparece:

```java
S
```

### String

Além dos tipos de dados primitivos mencionados acima, as variáveis Java também podem conter strings ou **cadeias de caracteres completas**. Essas sequências são colocadas entre aspas duplas na parte superior. Veja um exemplo:

```java
public class Main {
	public static void main(String[] args) {
		String ejemplo = "Esto es un ejemplo de string en Java.";
		System.out.println(ejemplo);
	}
}
```

E retorna:

```java
Esto es un ejemplo de string en Java.
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/variaveis-java/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/variaveis-java/) for AI/LLM consumption.