Fundamentos de Java: 7 conceitos essenciais para começar

Introdução

Você já pensou em aprender Java e dar os primeiros passos em uma das linguagens de programação mais utilizadas no mundo?

Este artigo traz os fundamentos de Java, explicados de forma simples, clara e prática, para que você entenda desde os conceitos básicos até boas práticas que podem transformar sua forma de programar.

A ideia é que, ao final da leitura, você tenha uma visão sólida da base do Java e esteja preparado para criar seus primeiros programas, além de conhecer os próximos passos para evoluir como desenvolvedor.

1. O que é Java e por que aprender agora

O Java é uma linguagem de programação criada em 1995 por James Gosling e sua equipe na Sun Microsystems. Desde então, se tornou uma das linguagens mais importantes e influentes da história da computação.

Um dos fatores que garantiram sua popularidade é o conceito “Write Once, Run Anywhere” (Escreva uma vez, rode em qualquer lugar). Isso significa que um programa escrito em Java pode ser executado em diferentes sistemas operacionais sem necessidade de reescrita, graças à JVM (Java Virtual Machine).

Por que aprender Java em 2025?

Longevidade e estabilidade → Java está no mercado há quase 30 anos e continua em constante evolução.
Amplo uso corporativo → bancos, seguradoras, telecomunicações, governo e grandes empresas utilizam sistemas baseados em Java.
Ecossistema rico → frameworks como Spring Boot, Hibernate e Jakarta EE aceleram o desenvolvimento.
Oportunidades de carreira → há grande demanda por desenvolvedores Java no mercado global.
Comunidade ativa → fóruns, eventos, artigos e bibliotecas open source fortalecem o aprendizado.

📌 Exemplo 1 – Programa básico

public class HelloWorld {
  public static void main(String[] args) {
      System.out.println("Olá, mundo!");
  }
}
// Saída esperada:
// Olá, mundo!

📌 Exemplo 2 – Programa que imprime informações do sistema

public class Sistema {
  public static void main(String[] args) {
      System.out.println("Sistema Operacional: " + System.getProperty("os.name"));
      System.out.println("Versão da JVM: " + System.getProperty("java.version"));
  }
}
// Saída típica:
// Sistema Operacional: Windows 10
// Versão da JVM: 17.0.2

2. Variáveis e Tipos Primitivos em Java

Em Java, toda informação precisa estar armazenada em uma variável. Uma variável é como uma "caixa" com um nome que armazena dados enquanto o programa está rodando.

Java é uma linguagem fortemente tipada, ou seja, cada variável deve ter seu tipo definido e ele não pode mudar depois de declarado.

Tipos primitivos principais:

int → números inteiros (ex: 10, 25, -5)
double → números decimais (ex: 3.14, -7.89)
char → um único caractere (ex: 'A')
boolean → valores lógicos (true ou false)

📌 Exemplo 1 – Operações matemáticas simples

public class Operacoes {
  public static void main(String[] args) {
      int a = 10;
      int b = 3;
      System.out.println("Soma: " + (a + b));
      System.out.println("Subtração: " + (a - b));
      System.out.println("Multiplicação: " + (a * b));
      System.out.println("Divisão: " + (a / b));
      System.out.println("Resto da divisão: " + (a % b));
  }
}
// Saída esperada:
// Soma: 13
// Subtração: 7
// Multiplicação: 30
// Divisão: 3
// Resto da divisão: 1

📌 Exemplo 2 – Conversão de tipos

public class Conversao {
  public static void main(String[] args) {
      double preco = 19.99;
      int precoInteiro = (int) preco; // conversão de double para int
      System.out.println("Preço original: " + preco);
      System.out.println("Preço inteiro: " + precoInteiro);
  }
}
// Saída esperada:
// Preço original: 19.99
// Preço inteiro: 19

3. Estruturas de Controle em Java

Com estruturas de controle, você define o fluxo da aplicação: decisões e repetições.

Estruturas condicionais:

if / else → para decisões simples.
switch → múltiplas escolhas.

📌 Exemplo 1 – Classificação de notas

public class Classificacao {
  public static void main(String[] args) {
      int nota = 75;
      if (nota >= 90) {
          System.out.println("Nota A");
      } else if (nota >= 70) {
          System.out.println("Nota B");
      } else if (nota >= 50) {
          System.out.println("Nota C");
      } else {
          System.out.println("Nota D");
      }
  }
}
// Saída esperada:
// Nota B

📌 Exemplo 2 – Tabuada com for

public class Tabuada {
  public static void main(String[] args) {
      int numero = 5;
      System.out.println("Tabuada do " + numero + ":");
      for (int i = 1; i <= 10; i++) {
          System.out.println(numero + " x " + i + " = " + (numero * i));
      }
  }
}
// Saída esperada:
// Tabuada do 5:
// 5 x 1 = 5
// ...
// 5 x 10 = 50

4. Métodos e Orientação a Objetos em Java

A Orientação a Objetos (OO) é a base do Java.

Ela permite organizar o código em classes e objetos, facilitando manutenção e reaproveitamento.

Os 4 pilares da OO:

Encapsulamento → proteger os dados.
Herança → reutilizar código.
Polimorfismo → comportamentos diferentes.
Abstração → simplificação de conceitos.

📌 Exemplo 1 – Classe simples com métodos:

class Calculadora {
  int somar(int a, int b) {
      return a + b;
  }
  int multiplicar(int a, int b) {
      return a * b;
  }
}


public class TesteCalculadora {
  public static void main(String[] args) {
      Calculadora calculadora = new Calculadora();
      System.out.println("Soma: " + calculadora.somar(10, 20));
      System.out.println("Multiplicação: " + calculadora.multiplicar(5, 6));
  }
}
// Saída esperada:
// Soma: 30
// Multiplicação: 30

📌 Exemplo 2 – Herança simples

class Animal {
  void emitirSom() {
      System.out.println("O animal faz um som.");
  }
}


class Cachorro extends Animal {
  @Override
  void emitirSom() {
      System.out.println("O cachorro late: Au Au!");
  }
}


public class TesteAnimal {
  public static void main(String[] args) {
      Animal a = new Animal();
      Animal c = new Cachorro();
      a.emitirSom();
      c.emitirSom();
  }
}
// Saída esperada:
// O animal faz um som.
// O cachorro late: Au Au!

5. Coleções em Java: List, Set e Map

O Java Collections Framework fornece estruturas para armazenar e manipular dados.

Principais coleções:

List → lista ordenada (pode repetir elementos).
Set → conjunto sem duplicatas.
Map → pares chave/valor.

📌 Exemplo 1 – Uso de Set

import java.util.*;


public class ExemploSet {
  public static void main(String[] args) {
      Set<String> frutas = new HashSet<>();
      frutas.add("Maçã");
      frutas.add("Banana");
      frutas.add("Maçã"); // duplicata ignorada
      System.out.println(frutas);
  }
}
// Saída esperada:
// [Maçã, Banana]

📌 Exemplo 2 – Uso de Map

import java.util.*;


public class ExemploMap {
  public static void main(String[] args) {
      Map<String, Integer> notas = new HashMap<>();
      notas.put("Ana", 90);
      notas.put("Carlos", 75);
      notas.put("Beatriz", 85);
      System.out.println("Nota de Ana: " + notas.get("Ana"));
  }
}
// Saída esperada:
// Nota de Ana: 90

6. Tratamento de erros com Exceptions

Em Java, erros são tratados com exceptions. Isso evita que o programa quebre abruptamente.

Estrutura básica:

try → código que pode gerar erro.
catch → tratamento do erro.
finally → executa sempre.

📌 Exemplo 1 – Tratamento de múltiplas exceções

public class Divisao {
  public static void main(String[] args) {
      try {
          int[] numeros = {10, 20};
          int resultado = numeros[0] / 0;
          System.out.println("Resultado: " + resultado);
      } catch (ArithmeticException e) {
          System.out.println("Erro matemático: " + e.getMessage());
      } catch (ArrayIndexOutOfBoundsException e) {
          System.out.println("Erro de índice: " + e.getMessage());
      }
  }
}
// Saída esperada:
// Erro matemático: / by zero

📌 Exemplo 2 – Lançando exceções personalizadas

class IdadeInvalidaException extends Exception {
  public IdadeInvalidaException(String mensagem) {
      super(mensagem);
  }
}


public class Cadastro {
  static void verificarIdade(int idade) throws IdadeInvalidaException {
      if (idade < 18) {
          throw new IdadeInvalidaException("Idade mínima é 18 anos.");
      }
  }


  public static void main(String[] args) {
      try {
          verificarIdade(15);
      } catch (IdadeInvalidaException e) {
          System.out.println("Erro no cadastro: " + e.getMessage());
      }
  }
}
// Saída esperada:
// Erro no cadastro: Idade mínima é 18 anos.

7. Boas práticas e próximos passos em Java

Boas práticas:

Sempre nomeie variáveis e métodos de forma clara.
Utilize convenções de código (camelCase, PascalCase).
Evite código duplicado → extraia para métodos/classes.
Pratique com projetos reais: APIs, jogos simples, aplicações desktop.

📌 Exemplo – Evitando duplicação de código

public class ExemploBoasPraticas {
  static int calcularQuadrado(int numero) {
      return numero * numero;
  }


  public static void main(String[] args) {
      System.out.println("Quadrado de 2: " + calcularQuadrado(2));
      System.out.println("Quadrado de 5: " + calcularQuadrado(5));
  }
}
// Saída esperada:
// Quadrado de 2: 4
// Quadrado de 5: 25

Próximos passos para evoluir:

Aprender sobre Spring Boot (framework para criar APIs e sistemas robustos).
Explorar bancos de dados com JDBC e JPA.
Estudar Testes Unitários (JUnit e Mockito).
Entrar em projetos open source para ganhar experiência prática.

Conclusão

Aprender Java é abrir portas para inúmeras oportunidades na área de tecnologia.

Dominar os fundamentos é o primeiro passo para se tornar um desenvolvedor capaz de construir sistemas robustos, escaláveis e aplicáveis em diversos setores.

Seja para iniciar sua carreira, evoluir como profissional ou contribuir com grandes projetos, o Java continua sendo uma das melhores escolhas.