0Pricing
Java Academy · Aula

Tipos Primitivos versus Tipos de Referência

Compreenda a diferença fundamental entre tipos primitivos e tipos de referência em Java.

Tipos Primitivos versus Tipos de Referência é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Tipos primitivos e de referência

Java tem duas categorias fundamentais de tipos de dados: tipos primitivos e tipos de referência. Entender a diferença é crucial para escrever código Java correto e eficiente.

Os oito tipos primitivos

Java tem exatamente oito tipos primitivos:

  • byte (inteiro de 8 bits)
  • short (inteiro de 16 bits)
  • int (inteiro de 32 bits)
  • long (inteiro de 64 bits)
  • float (decimal de 32 bits)
  • double (decimal de 64 bits)
  • char (caractere Unicode de 16 bits)
  • boolean (verdadeiro/falso)

Os primitivos armazenam o valor diretamente na memória — sem sobrecarga de objeto.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

Tipos de referência

Um tipo de referência armazena um endereço de memória (referência) que aponta para um objeto na memória dinâmica. Isso inclui:

  • Classes (por exemplo, String, Scanner)
  • Matrizes (por exemplo, int[])
  • Interfaces
  • Enumerações e registros

A variável não contém o objeto — ela contém um ponteiro para ele.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

Memória da pilha versus memória dinâmica

As variáveis primitivas são armazenadas na pilha — uma memória rápida e de curta duração, vinculada às chamadas de métodos.

Os objetos de tipos de referência vivem na memória dinâmica — uma memória maior e de longa duração, gerenciada pela coleta de lixo. A própria referência (endereço) fica na pilha.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: a referência ausente

As variáveis de referência podem receber null, o que significa que não apontam para nenhum objeto. Os primitivos não podem ser nulos — eles sempre têm um valor.

Acessar uma referência nula causa uma NullPointerException (NPE) — um dos erros de execução mais comuns do Java.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

Semântica de cópia: primitivos

Quando você atribui uma variável primitiva a outra, o Java copia o valor. Alterar uma não afeta a outra — elas são completamente independentes.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

Semântica de cópia: referências

Quando você atribui uma variável de referência a outra, ambas apontam para o mesmo objeto. Modificar o objeto por meio de uma referência fica visível por meio da outra.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

Classes de encapsulamento: conversão de primitivos em objetos

Cada primitivo tem uma classe de encapsulamento correspondente em java.lang:

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

As classes de encapsulamento permitem usar primitivos como objetos — algo necessário para coleções como List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

Armadilhas da conversão automática

A conversão automática é conveniente, mas pode causar erros sutis. A classe de inteiros armazena em cache valores de -128 a 127 — fora desse intervalo, == compara referências, não valores.

Use sempre .equals() para comparar objetos de encapsulamento.

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

Passagem para métodos: passagem por valor

Java sempre usa passagem por valor. Para os primitivos, o valor é copiado. Para as referências, a referência (endereço) é copiada — ambas apontam para o mesmo objeto, mas você não pode reatribuir a variável do chamador de dentro do método.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

Tabela prática de resumo

Referência rápida comparando tipos primitivos e de referência:

  • Armazenamento: primitivo → valor na pilha; referência → endereço na pilha + objeto na memória dinâmica
  • Valor padrão: primitivo → 0/falso/\u0000; referência → null
  • Pode ser nulo: primitivo → Não; referência → Sim
  • A atribuição copia: primitivo → valor; referência → endereço
  • Em coleções: os primitivos precisam de classes de encapsulamento

Verificação rápida

O que acontece quando você executa o código a seguir?

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

Resumo: tipos primitivos e de referência

Principais conclusões desta lição:

  • Java tem 8 tipos primitivos armazenados diretamente na pilha
  • Os tipos de referência armazenam o endereço de um objeto na memória dinâmica; a variável contém o endereço
  • Os primitivos são copiados por valor; as referências são copiadas por endereço
  • As variáveis de referência podem ser nulas; os primitivos não
  • As classes de encapsulamento (inteiros, decimais etc.) transformam primitivos em objetos
  • Java sempre usa passagem por valor — mesmo ao passar referências

Perguntas Frequentes

A aula “Tipos Primitivos versus Tipos de Referência” é grátis?

Sim — o texto completo de “Tipos Primitivos versus Tipos de Referência” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Tipos Primitivos versus Tipos de Referência”?

Compreenda a diferença fundamental entre tipos primitivos e tipos de referência em Java. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Tipos Primitivos versus Tipos de Referência”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tipos Primitivos versus Tipos de Referência
  2. Conversões de Alargamento e Redução
  3. O Operador instanceof
  4. Conversão de Tipos na Prática
← Voltar para Java Academy