Aprendendo Java do Zero — Parte 3: Variáveis e tipos primitivos

#Java

Este é o terceiro artigo da série Aprendendo Java do Zero. Na Parte 1 — Pré-requisitos e seu primeiro programa escrevemos nosso primeiro "Hello World" em um compilador online, e na Parte 2 — Instalando o Java, o IntelliJ IDEA e criando seu primeiro projeto local montamos um ambiente de desenvolvimento completo, local, com JDK e IntelliJ IDEA.

Agora que já temos onde escrever e rodar código Java, é hora de começar a explorar a linguagem de verdade. Neste artigo, nós vamos:

aprender a declarar e inicializar variáveis em Java;
entender as regras (obrigatórias e de convenção) para nomear variáveis;
conhecer as variáveis final e o que muda ao usá-las;
conhecer os oito tipos primitivos de dados da linguagem;
entender o que é conversão de tipos (casting), implícita e explícita;
entender o que são as classes wrapper e para que servem.

Como trabalhar com variáveis em Java

Para lidar com diferentes tipos de dado em Java, você cria variáveis. Por exemplo, para guardar uma idade em uma nova variável:

public class Main {
  public static void main(String[] args) {
      // <tipo> <nome>
      int idade;
  }
}

Você começa escrevendo o tipo do dado. Como idade é um número inteiro, o tipo é int, seguido do nome da variável e de ponto e vírgula.

Nesse ponto, a variável foi DECLARADA, mas ainda não foi INICIALIZADA (ou seja, ela não tem nenhum valor ainda). Você a inicializa desta forma:

public class Main {
  public static void main(String[] args) {
      int idade;
      idade = 27;
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

Ao atribuir um valor, você escreve o nome da variável, o sinal de igual (o operador de atribuição) e o valor desejado, terminando com ponto e vírgula.

O System.out.println acima vai imprimir Eu tenho 27 anos.. O sinal de mais (+) é uma das formas de concatenar (juntar) texto com variáveis dentro de uma string. Vamos explorar isso com mais calma quando falarmos de Strings, mais adiante na série.

Um ponto importante: em Java, você não pode usar uma variável não inicializada. Se você comentar a linha idade = 27; (colocando // na frente) e tentar compilar, o compilador vai acusar um ERRO parecido com:

error: variable idade might not have been initialized

Na prática, o que se costuma fazer é declarar e inicializar a variável numa única instrução:

public class Main {
  public static void main(String[] args) {Aprendendo Java do Zero — Parte 3: Variáveis e tipos primitivos
      int idade = 27;
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

O valor de uma variável pode ser alterado quantas vezes se desejar:

public class Main {
  public static void main(String[] args) {
      int idade = 27;
      idade = 28;
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

Mas atenção: embora você possa ATRIBUIR um valor várias vezes, você não pode DECLARAR a mesma variável duas vezes no mesmo escopo:

public class Main {
  public static void main(String[] args) {
      int idade = 27;
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

Isso gera um erro de compilação de variável duplicada.

Vale registrar também o termo LITERAL: uma literal é um valor escrito diretamente no código, sem ser calculado dinamicamente. No exemplo idade = 27, o número 27 é uma literal inteira.

Quais são as regras para declarar variáveis?

Existem algumas regras obrigatórias para nomear variáveis em Java:

O nome não pode começar com número.
O nome não pode conter espaços.
Nomes são case sensitive — ou seja, idade e IDADE são variáveis diferentes.
Você não pode usar nenhuma das palavras reservadas da linguagem (existem cerca de 50 delas, como class, public ou static, que já apareceram nos artigos anteriores).

Além das regras obrigatórias, existem convenções amplamente adotadas pela comunidade Java:

Comece o nome da variável com letra minúscula.
Se o nome tiver mais de uma palavra, use camelCase: primeiroNome, ultimoNome.
Evite nomes de uma única letra, como f ou l, exceto em contextos muito específicos (como contadores de loop).

Seguindo essas regras e convenções, você já está no caminho certo - e, com a prática, elas se tornam naturais.

O que são variáveis `final`?

Uma variável declarada como final só pode ser inicializada uma única vez. Depois disso, ela não pode mais ser reatribuída.

public class Main {
  public static void main(String[] args) {
      final int idade = 27;
      idade = 28; // erro de compilação
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

Como idade foi declarada como final e já tinha um valor, essa segunda atribuição gera um erro de compilação.

Por outro lado, se você declarar a variável final sem inicializá-la de imediato, ainda é possível atribuir um valor a ela depois — só que apenas uma vez:

public class Main {
  public static void main(String[] args) {
      final int idade;
      idade = 28;
      System.out.println("Eu tenho " + idade + " anos.");
  }
}

Em resumo: final limita a variável a uma única atribuição, seja ela feita imediatamente na declaração ou em um momento posterior.

Quais são os tipos primitivos de dados em Java?

Em um nível mais alto, existem dois grandes grupos de tipos em Java: os tipos primitivos e os tipos de referência (também chamados de não primitivos).

Tipos primitivos armazenam o valor diretamente. Tipos de referência armazenam uma referência (um endereço) para onde o valor de fato está guardado na memória — vamos explorar os tipos de referência com mais profundidade quando chegarmos em classes e objetos, mais adiante na série.

Existem oito tipos primitivos em Java:

byte — inteiro de 8 bits, de -128 a 127
short — inteiro de 16 bits, de -32.768 a 32.767
int — inteiro de 32 bits, de -2.147.483.648 a 2.147.483.647
long — inteiro de 64 bits, de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807
float — ponto flutuante de precisão simples, 32 bits
double — ponto flutuante de precisão dupla, 64 bits
boolean — pode ser true ou false
char — um único caractere Unicode de 16 bits

Não se preocupe em decorar essa tabela — com a prática, o uso do dia a dia vai fixar naturalmente int, double, boolean e char, que são os quatro tipos mais usados.

Você já viu como declarar um int. byte, short e long seguem exatamente o mesmo padrão. Já um double aceita casas decimais:

public class Main {
  public static void main(String[] args) {
      double media = 4.8;
      System.out.println("Minha média é " + media + ".");
  }
}

Se você atribuir um número inteiro a um double, o Java automaticamente adiciona a casa decimal (4 vira 4.0).

float e double parecem intercambiáveis, mas não são — por padrão, todo número com casa decimal no código é tratado como double. Para declarar um float explicitamente, é preciso adicionar f ou F no final do valor:

public class Main {
  public static void main(String[] args) {
      float media = 4.8f;
      System.out.println("Minha média é " + media + ".");
  }
}

boolean só guarda true ou false:

public class Main {
  public static void main(String[] args) {
      boolean fimDeSemana = false;
      System.out.println(fimDeSemana); // false
  }
}

char guarda um único caractere Unicode:

public class Main {
  public static void main(String[] args) {
      char simboloPorcentagem = '%';
      System.out.println(simboloPorcentagem); // %
  }
}

Também é possível usar sequências de escape Unicode para caracteres especiais:

public class Main {
  public static void main(String[] args) {
      char simboloCopyright = '\u00A9';
      System.out.println(simboloCopyright); // ©
  }
}

O que é conversão de tipos (CASTING)?

A conversão de tipos em Java pode ser implícita ou explícita.

Quando o compilador converte automaticamente um tipo menor em um maior, isso é chamado de conversão implícita (ou WIDENING):

public class Main {
  public static void main(String[] args) {
      int numero1 = 8;
      double numero2 = numero1;
      System.out.println(numero2); // 8.0
  }
}

Como double "cabe" mais do que int, o compilador consegue fazer essa conversão sozinho.

Já a conversão no sentido contrário — de um tipo maior para um menor — não acontece automaticamente. É preciso fazer uma conversão explícita, usando um operador de cast:

public class Main {
  public static void main(String[] args) {
      double numero1 = 8.5;
      int numero2 = (int) numero1; // casting
      System.out.println(numero2); // 8
  }
}

Ao fazer isso, você perde parte da informação — no exemplo, a casa decimal .5 é simplesmente descartada.

Também é possível converter um char em int:

public class Main {
  public static void main(String[] args) {
      char caractere = 'F';
      int numero = caractere;
      System.out.println(numero); // 70
  }
}

70 é o código ASCII correspondente ao caractere F — por isso esse é o resultado.

O que são classes WRAPPER em Java?

Classes wrapper ("envelope") transformam um tipo PRIMITIVO em um tipo de REFERÊNCIA. Existe uma classe wrapper para cada um dos oito tipos primitivos:

int → Integer
long → Long
short → Short
byte → Byte
boolean → Boolean
char → Character
float → Float
double → Double

Uso básico:

public class Main {
  public static void main (String[] args) {
      Integer idade = 27;
      Double media = 4.8;
      System.out.println(idade); // 27
      System.out.println(media); // 4.8
  }
}

Essas classes também oferecem métodos para extrair o valor primitivo de volta — por exemplo, idade.intValue() devolve o valor primitivo int. Você vai usar os tipos primitivos na maior parte do tempo, mas as classes wrapper se tornam necessárias em cenários específicos, como ao trabalhar com coleções, que veremos mais adiante nesta série.

O que vem a seguir

Neste terceiro artigo, você aprendeu a declarar, inicializar e nomear variáveis corretamente, conheceu as variáveis final, os oito tipos primitivos de dados do Java, a diferença entre conversão implícita e explícita de tipos, e o papel das classes wrapper.

Na Parte 4 desta série, vamos colocar essas variáveis para trabalhar de fato, com o tópico "Como usar operadores em Java", cobrindo operadores aritméticos, de atribuição, relacionais, lógicos e unários.

Até lá!

Este artigo é parte de uma série de introdução a Java escrita do zero, com progressão didática própria pensada para quem nunca programou na linguagem antes.

Artigos dessa série na DIO: