image

Access unlimited bootcamps and 650+ courses forever

60
%OFF
Content list

JF

Jefferson Francisco13/10/2025 23:08
Share

Fundamentos de Java: 5 Conceitos Essenciais Para Dominar a Linguagem Mais Poderosa da Programação

    Você sabia que Java está presente em 97% das empresas Fortune 500 e é executado em mais de 3 bilhões de dispositivos ao redor do mundo? Mesmo após 29 anos desde seu lançamento, Java continua sendo uma das linguagens mais demandadas do mercado, movimentando um ecossistema que vai desde aplicações móveis Android até sistemas críticos de bancos e e-commerce.

    Mas aqui está a verdade que poucos falam: dominar Java não é sobre decorar sintaxe - é sobre compreender profundamente seus fundamentos. A diferença entre um programador Java iniciante e um profissional experiente não está na quantidade de frameworks que conhece, mas na solidez com que aplica os conceitos fundamentais da linguagem.

    Neste artigo, vou revelar os 5 fundamentos essenciais de Java que separam os desenvolvedores casuais dos verdadeiros especialistas. Se você está iniciando sua jornada ou busca consolidar seus conhecimentos, estes conceitos são indispensáveis para sua evolução como desenvolvedor.

    Por Que Java Permanece Dominando o Mercado de Desenvolvimento?

    Java não é apenas uma linguagem de programação – é uma filosofia de desenvolvimento que prioriza portabilidade, segurança e performance. Criado pela Sun Microsystems (hoje Oracle) em 1995, Java revolucionou o desenvolvimento de software com sua premissa "Write Once, Run Anywhere" (Escreva Uma Vez, Execute Em Qualquer Lugar).

    Os pilares que sustentam Java:

    • Portabilidade: Código compilado para bytecode roda em qualquer sistema com JVM
    • Orientação a Objetos: Paradigma que organiza código de forma intuitiva e reutilizável
    • Gerenciamento Automático de Memória: Garbage Collector elimina vazamentos de memória
    • Robustez: Sistema de tipos forte previne erros em tempo de compilação
    • Segurança: Modelo de segurança multicamadas protege contra código malicioso

    Números que comprovam a relevância:

    • #2 linguagem mais popular no ranking GitHub (2024)
    • 45% dos desenvolvedores backend usam Java profissionalmente
    • Salário médio R$ 9.200 para desenvolvedores Java no Brasil
    • 90%+ das aplicações enterprise têm Java em sua stack

    Fundamento 1: Variáveis e Tipos de Dados - A Base de Tudo

    Em Java, toda informação precisa estar armazenada em uma variável. Java é uma linguagem fortemente tipada, onde cada variável deve ter seu tipo explicitamente declarado, proporcionando maior segurança e prevenção de erros.

    Tipos Primitivos Fundamentais

    Java possui 8 tipos primitivos que armazenam valores diretamente na memória:

    public class TiposPrimitivos {
  public static void main(String[] args) {
      // Tipos inteiros
      byte idade = 25;           // -128 a 127
      short ano = 2024;          // -32.768 a 32.767  
      int populacao = 215_000_000; // -2 bilhões a 2 bilhões
      long distanciaLua = 384_400_000L; // Valores muito grandes
      
      // Tipos decimais
      float preco = 19.99f;      // Precisão simples
      double salario = 8500.75;  // Precisão dupla (padrão)
      
      // Outros tipos
      char inicial = 'J';        // Um único caractere Unicode
      boolean ativo = true;      // true ou false
      
      // Demonstrando uso prático
      System.out.println("Informações do Funcionário:");
      System.out.println("Idade: " + idade + " anos");
      System.out.println("Ano atual: " + ano);
      System.out.println("População brasileira: " + populacao);
      System.out.println("Salário: R$ " + salario);
      System.out.println("Status ativo: " + ativo);
  }
}

    Tipos de Referência e Strings

    Além dos tipos primitivos, Java trabalha com tipos de referência que armazenam endereços de memória onde os objetos estão localizados:

    public class TiposReferencia {
  public static void main(String[] args) {
      // String - tipo de referência mais usado
      String nomeCompleto = "Maria Silva Santos";
      String empresa = "Tech Solutions";
      
      // Operações comuns com Strings
      System.out.println("Nome em maiúsculas: " + nomeCompleto.toUpperCase());
      System.out.println("Primeira palavra: " + nomeCompleto.substring(0, 5));
      System.out.println("Contém 'Silva': " + nomeCompleto.contains("Silva"));
      System.out.println("Comprimento: " + nomeCompleto.length() + " caracteres");
      
      // Concatenação e formatação
      String mensagem = String.format("Funcionária %s trabalha na %s", 
                                     nomeCompleto, empresa);
      System.out.println(mensagem);
  }
}

    Conversão Entre Tipos (Casting)

    Java permite conversão entre tipos compatíveis, essencial para operações matemáticas e manipulação de dados:

    public class ConversaoTipos {
  public static void main(String[] args) {
      // Conversão implícita (widening)
      int numeroInteiro = 100;
      double numeroDecimal = numeroInteiro; // int -> double (automático)
      
      // Conversão explícita (narrowing) 
      double preco = 49.99;
      int precoInteiro = (int) preco; // double -> int (manual)
      
      // Conversão de String para números
      String idadeTexto = "30";
      int idade = Integer.parseInt(idadeTexto);
      
      String salarioTexto = "5500.80";
      double salario = Double.parseDouble(salarioTexto);
      
      System.out.println("Preço original: " + preco);
      System.out.println("Preço inteiro: " + precoInteiro);
      System.out.println("Idade convertida: " + idade);
      System.out.println("Salário convertido: " + salario);
      
      // Formatação de números
      System.out.printf("Salário formatado: R$ %.2f%n", salario);
  }
}

    Fundamento 2: Estruturas de Controle - Dando Inteligência ao Código

    Estruturas de controle determinam o fluxo de execução do programa, permitindo tomada de decisões e repetições baseadas em condições específicas.

    Estruturas Condicionais

    As condições permitem que o programa tome decisões diferentes baseadas nos dados:

    public class EstruturaCondicionais {
  public static void main(String[] args) {
      int nota = 75;
      String conceito;
      
      // IF-ELSE tradicional
      if (nota >= 90) {
          conceito = "A - Excelente";
      } else if (nota >= 80) {
          conceito = "B - Bom";  
      } else if (nota >= 70) {
          conceito = "C - Regular";
      } else if (nota >= 60) {
          conceito = "D - Insuficiente";
      } else {
          conceito = "F - Reprovado";
      }
      
      System.out.println("Nota: " + nota + " -> " + conceito);
      
      // Operador ternário para condições simples
      String status = (nota >= 60) ? "Aprovado" : "Reprovado";
      System.out.println("Status: " + status);
  }
}

    Switch Statement - Múltiplas Escolhas

    Para decisões baseadas em valores específicos de uma variável, switch oferece uma alternativa mais limpa:

    public class ExemploSwitch {
  public static void main(String[] args) {
      int diaSemana = 3;
      String nomeDia;
      boolean diaUtil;
      
      switch (diaSemana) {
          case 1:
              nomeDia = "Segunda-feira";
              diaUtil = true;
              break;
          case 2: 
              nomeDia = "Terça-feira";
              diaUtil = true;
              break;
          case 3:
              nomeDia = "Quarta-feira";
              diaUtil = true;
              break;
          case 4:
              nomeDia = "Quinta-feira"; 
              diaUtil = true;
              break;
          case 5:
              nomeDia = "Sexta-feira";
              diaUtil = true;
              break;
          case 6:
              nomeDia = "Sábado";
              diaUtil = false;
              break;
          case 7:
              nomeDia = "Domingo";
              diaUtil = false;
              break;
          default:
              nomeDia = "Dia inválido";
              diaUtil = false;
      }
      
      System.out.println("Dia: " + nomeDia);
      System.out.println("É dia útil: " + (diaUtil ? "Sim" : "Não"));
      
      // Switch moderno (Java 14+) - mais conciso
      String categoria = switch (diaSemana) {
          case 1, 2, 3, 4, 5 -> "Dia útil";
          case 6, 7 -> "Fim de semana";
          default -> "Inválido";
      };
      System.out.println("Categoria: " + categoria);
  }
}

    Laços de Repetição

    Os loops permitem executar blocos de código repetidamente, essenciais para processar coleções de dados:

    public class LacosRepeticao {
  public static void main(String[] args) {
      System.out.println("=== LOOP FOR ===");
      // For tradicional - ideal quando sabemos quantas iterações
      for (int i = 1; i <= 5; i++) {
          System.out.println("Contagem: " + i);
      }
      
      System.out.println("\\n=== TABUADA COM FOR ===");
      int numero = 7;
      for (int i = 1; i <= 10; i++) {
          System.out.printf("%d x %d = %d%n", numero, i, numero * i);
      }
      
      System.out.println("\\n=== LOOP WHILE ==="); 
      // While - executa enquanto condição for verdadeira
      int contador = 1;
      while (contador <= 3) {
          System.out.println("Iteração: " + contador);
          contador++; // Essencial para evitar loop infinito!
      }
      
      System.out.println("\\n=== LOOP DO-WHILE ===");
      // Do-while - executa pelo menos uma vez
      int opcao;
      do {
          opcao = 0; // Simulação de entrada do usuário
          System.out.println("Executou pelo menos uma vez");
      } while (opcao != 0);
      
      System.out.println("\\n=== FOR-EACH COM ARRAY ===");
      String[] linguagens = {"Java", "Python", "JavaScript", "C++", "Go"};
      
      for (String linguagem : linguagens) {
          System.out.println("Linguagem: " + linguagem);
      }
  }
}

    Fundamento 3: Classes e Objetos - O Coração da Orientação a Objetos

    Java é uma linguagem orientada a objetos, onde tudo gira em torno de classes e objetos. Uma classe é um molde que define a estrutura e comportamento, enquanto um objeto é uma instância específica dessa classe.

    Criando Classes Fundamentais

    public class Funcionario {
  // Atributos (características do objeto)
  private String nome;
  private String cargo;
  private double salario;
  private int anosExperiencia;
  
  // Construtor - define como criar um objeto
  public Funcionario(String nome, String cargo, double salario, int anosExperiencia) {
      this.nome = nome;
      this.cargo = cargo; 
      this.salario = salario;
      this.anosExperiencia = anosExperiencia;
  }
  
  // Métodos (comportamentos/ações do objeto)
  public void exibirInformacoes() {
      System.out.println("=== INFORMAÇÕES DO FUNCIONÁRIO ===");
      System.out.println("Nome: " + nome);
      System.out.println("Cargo: " + cargo);
      System.out.println("Salário: R$ " + String.format("%.2f", salario));
      System.out.println("Anos de experiência: " + anosExperiencia);
  }
  
  public double calcularBonusAnual() {
      // Bonus baseado na experiência
      if (anosExperiencia >= 5) {
          return salario * 0.15; // 15% para experientes
      } else if (anosExperiencia >= 2) {
          return salario * 0.10; // 10% para intermediários  
      } else {
          return salario * 0.05; // 5% para iniciantes
      }
  }
  
  public void receberAumento(double percentual) {
      double aumentoValor = salario * (percentual / 100);
      salario += aumentoValor;
      System.out.printf("Aumento de %.1f%% aplicado! Novo salário: R$ %.2f%n", 
                       percentual, salario);
  }
  
  public boolean podeSerPromovido() {
      return anosExperiencia >= 2 && salario < 10000;
  }
  
  // Getters e Setters (acesso controlado aos atributos)
  public String getNome() {
      return nome;
  }
  
  public String getCargo() {
      return cargo;
  }
  
  public void setCargo(String novoCargo) {
      this.cargo = novoCargo;
      System.out.println("Cargo atualizado para: " + novoCargo);
  }
  
  public double getSalario() {
      return salario;
  }
}

    Usando Classes e Objetos na Prática

    public class SistemaRH {
  public static void main(String[] args) {
      // Criando objetos (instâncias da classe Funcionario)
      Funcionario dev1 = new Funcionario("Ana Silva", "Desenvolvedora Java", 8500.0, 3);
      Funcionario dev2 = new Funcionario("Carlos Santos", "Analista Júnior", 4500.0, 1);
      
      // Usando métodos dos objetos
      dev1.exibirInformacoes();
      System.out.println("Bonus anual: R$ " + String.format("%.2f", dev1.calcularBonusAnual()));
      System.out.println("Pode ser promovido: " + (dev1.podeSerPromovido() ? "Sim" : "Não"));
      
      System.out.println("\\n" + "=".repeat(40) + "\\n");
      
      dev2.exibirInformacoes(); 
      System.out.println("Bonus anual: R$ " + String.format("%.2f", dev2.calcularBonusAnual()));
      
      // Modificando objetos
      dev2.receberAumento(15);
      dev2.setCargo("Desenvolvedor Java Pleno");
      
      System.out.println("\\n=== APÓS PROMOÇÃO ===");
      dev2.exibirInformacoes();
      
      // Demonstrando que cada objeto mantém seu estado independente
      System.out.println("\\n=== COMPARAÇÃO DE SALÁRIOS ===");
      System.out.printf("%s: R$ %.2f%n", dev1.getNome(), dev1.getSalario());
      System.out.printf("%s: R$ %.2f%n", dev2.getNome(), dev2.getSalario());
  }
}

    Fundamento 4: Arrays e Manipulação de Dados

    Arrays são estruturas fundamentais que armazenam múltiplos valores do mesmo tipo em posições sequenciais na memória, essenciais para processar coleções de dados.

    Declaração e Inicialização de Arrays

    public class ExemplosArrays {
  public static void main(String[] args) {
      // Diferentes formas de declarar arrays
      int[] idades = new int; // Array de 5 posições (inicializado com zeros)
      String[] nomes = {"Ana", "Bruno", "Carlos", "Diana", "Eduardo"};
      double[] salarios = {4500.0, 6800.0, 7200.0, 5500.0, 8900.0};
      
      // Preenchendo array manualmente
      idades = 25;
      idades = 30; 
      idades = 28;
      idades = 32;
      idades = 27;
      
      System.out.println("=== DADOS DOS FUNCIONÁRIOS ===");
      for (int i = 0; i < nomes.length; i++) {
          System.out.printf("Funcionário: %s | Idade: %d | Salário: R$ %.2f%n", 
                          nomes[i], idades[i], salarios[i]);
      }
      
      // Usando for-each para leitura (mais simples)
      System.out.println("\\n=== LISTA DE NOMES (FOR-EACH) ===");
      for (String nome : nomes) {
          System.out.println("- " + nome);
      }
      
      // Operações estatísticas com arrays
      double somaSalarios = 0;
      double maiorSalario = salarios;
      double menorSalario = salarios;
      
      for (double salario : salarios) {
          somaSalarios += salario;
          if (salario > maiorSalario) {
              maiorSalario = salario;
          }
          if (salario < menorSalario) {
              menorSalario = salario;
          }
      }
      
      double mediaSalarios = somaSalarios / salarios.length;
      
      System.out.println("\\n=== ESTATÍSTICAS SALARIAIS ===");
      System.out.printf("Maior salário: R$ %.2f%n", maiorSalario);
      System.out.printf("Menor salário: R$ %.2f%n", menorSalario);
      System.out.printf("Média salarial: R$ %.2f%n", mediaSalarios);
      System.out.printf("Total folha de pagamento: R$ %.2f%n", somaSalarios);
  }
}

    Arrays Multidimensionais

    Para representar dados mais complexos, Java suporta arrays multidimensionais:

    public class ArraysMultidimensionais {
  public static void main(String[] args) {
      // Array 2D representando notas de alunos em diferentes matérias
      double[][] notasAlunos = {
          {8.5, 7.0, 9.0, 8.0}, // Aluno 1: Matemática, Português, História, Ciências
          {7.5, 8.5, 7.0, 9.0}, // Aluno 2
          {9.0, 8.0, 8.5, 7.5}, // Aluno 3
          {6.5, 7.5, 8.0, 8.5}  // Aluno 4
      };
      
      String[] nomesMaterias = {"Matemática", "Português", "História", "Ciências"};
      String[] nomesAlunos = {"Ana", "Bruno", "Carlos", "Diana"};
      
      System.out.println("=== BOLETIM ESCOLAR ===");
      
      // Exibir notas de cada aluno
      for (int aluno = 0; aluno < notasAlunos.length; aluno++) {
          System.out.println("\\nAluno: " + nomesAlunos[aluno]);
          double somaNotas = 0;
          
          for (int materia = 0; materia < notasAlunos[aluno].length; materia++) {
              double nota = notasAlunos[aluno][materia];
              System.out.printf("  %s: %.1f%n", nomesMaterias[materia], nota);
              somaNotas += nota;
          }
          
          double media = somaNotas / notasAlunos[aluno].length;
          String situacao = media >= 7.0 ? "APROVADO" : "RECUPERAÇÃO";
          System.out.printf("  Média: %.1f - %s%n", media, situacao);
      }
      
      // Calcular média por matéria
      System.out.println("\\n=== MÉDIA POR MATÉRIA ===");
      for (int materia = 0; materia < nomesMaterias.length; materia++) {
          double somaMateria = 0;
          for (int aluno = 0; aluno < notasAlunos.length; aluno++) {
              somaMateria += notasAlunos[aluno][materia];
          }
          double mediaMateria = somaMateria / notasAlunos.length;
          System.out.printf("%s: %.1f%n", nomesMaterias[materia], mediaMateria);
      }
  }
}

    Fundamento 5: Métodos - Organizando e Reutilizando Código

    Métodos são blocos de código reutilizáveis que executam tarefas específicas. Eles são fundamentais para organizar código, evitar repetição e criar programas mais maintíveis.

    Estrutura e Tipos de Métodos

    public class ExemplosMetodos {
  
  // Método sem retorno (void) e sem parâmetros
  public static void exibirBanner() {
      System.out.println("================================");
      System.out.println("    SISTEMA DE CÁLCULOS JAVA    ");
      System.out.println("================================\\n");
  }
  
  // Método com retorno e parâmetros
  public static double calcularMedia(double nota1, double nota2, double nota3) {
      return (nota1 + nota2 + nota3) / 3.0;
  }
  
  // Método com múltiplos parâmetros e lógica condicional
  public static String determinarSituacao(double media) {
      if (media >= 9.0) {
          return "EXCELENTE";
      } else if (media >= 7.0) {
          return "APROVADO";
      } else if (media >= 5.0) {
          return "RECUPERAÇÃO";
      } else {
          return "REPROVADO";
      }
  }
  
  // Método que processa array
  public static void exibirEstatisticas(double[] valores, String titulo) {
      System.out.println("=== " + titulo.toUpperCase() + " ===");
      
      double soma = 0;
      double maior = valores;
      double menor = valores;
      
      for (double valor : valores) {
          soma += valor;
          if (valor > maior) maior = valor;
          if (valor < menor) menor = valor;
      }
      
      double media = soma / valores.length;
      
      System.out.printf("Quantidade: %d%n", valores.length);
      System.out.printf("Maior valor: %.2f%n", maior);
      System.out.printf("Menor valor: %.2f%n", menor);
      System.out.printf("Média: %.2f%n", media);
      System.out.printf("Total: %.2f%n\\n", soma);
  }
  
  // Sobrecarga de método (mesmo nome, parâmetros diferentes)
  public static int somar(int a, int b) {
      return a + b;
  }
  
  public static double somar(double a, double b) {
      return a + b;
  }
  
  public static double somar(double a, double b, double c) {
      return a + b + c;
  }
  
  // Método com validação e tratamento de erros
  public static double calcularDesconto(double preco, double percentualDesconto) {
      if (preco < 0) {
          System.out.println("ERRO: Preço não pode ser negativo!");
          return 0;
      }
      
      if (percentualDesconto < 0 || percentualDesconto > 100) {
          System.out.println("ERRO: Percentual deve estar entre 0 e 100!");
          return preco;
      }
      
      double desconto = preco * (percentualDesconto / 100);
      return preco - desconto;
  }
  
  public static void main(String[] args) {
      exibirBanner();
      
      // Usando métodos de cálculo
      double media1 = calcularMedia(8.5, 7.0, 9.0);
      double media2 = calcularMedia(6.0, 5.5, 7.5);
      double media3 = calcularMedia(9.5, 9.0, 8.5);
      
      System.out.println("=== RESULTADOS DOS ALUNOS ===");
      System.out.printf("Aluno 1: Média %.1f - %s%n", media1, determinarSituacao(media1));
      System.out.printf("Aluno 2: Média %.1f - %s%n", media2, determinarSituacao(media2));
      System.out.printf("Aluno 3: Média %.1f - %s%n", media3, determinarSituacao(media3));
      
      System.out.println();
      
      // Testando sobrecarga de métodos
      System.out.println("=== TESTANDO SOBRECARGA ===");
      System.out.println("somar(5, 3) = " + somar(5, 3));
      System.out.println("somar(2.5, 1.3) = " + somar(2.5, 1.3));
      System.out.println("somar(1.0, 2.0, 3.0) = " + somar(1.0, 2.0, 3.0));
      
      System.out.println();
      
      // Usando método de estatísticas
      double[] salarios = {4500.0, 6800.0, 7200.0, 5500.0, 8900.0, 3200.0};
      exibirEstatisticas(salarios, "Análise Salarial");
      
      // Testando método com validação
      System.out.println("=== CALCULADORA DE DESCONTOS ===");
      double precoOriginal = 1000.0;
      System.out.printf("Preço original: R$ %.2f%n", precoOriginal);
      System.out.printf("Com 10%% de desconto: R$ %.2f%n", 
                       calcularDesconto(precoOriginal, 10));
      System.out.printf("Com 25%% de desconto: R$ %.2f%n", 
                       calcularDesconto(precoOriginal, 25));
      
      // Testando validações
      calcularDesconto(-100, 10); // Preço inválido
      calcularDesconto(1000, 150); // Desconto inválido
  }
}

    Aplicações Práticas: Integrando os 5 Fundamentos

    Para demonstrar como todos esses fundamentos trabalham juntos, vou criar um sistema completo que simula uma aplicação real:

    import java.util.Scanner;


// Classe representando um produto
class Produto {
  private String nome;
  private double preco;
  private int quantidadeEstoque;
  
  public Produto(String nome, double preco, int quantidadeEstoque) {
      this.nome = nome;
      this.preco = preco;
      this.quantidadeEstoque = quantidadeEstoque;
  }
  
  public boolean temEstoque(int quantidade) {
      return this.quantidadeEstoque >= quantidade;
  }
  
  public void reduzirEstoque(int quantidade) {
      if (temEstoque(quantidade)) {
          this.quantidadeEstoque -= quantidade;
      }
  }
  
  public double calcularTotal(int quantidade) {
      return this.preco * quantidade;
  }
  
  // Getters
  public String getNome() { return nome; }
  public double getPreco() { return preco; }
  public int getQuantidadeEstoque() { return quantidadeEstoque; }
  
  public void exibirInfo() {
      System.out.printf("%-20s | R$ %6.2f | Estoque: %3d%n", 
                       nome, preco, quantidadeEstoque);
  }
}


public class SistemaVendas {
  // Array de produtos disponíveis
  private static Produto[] produtos = {
      new Produto("Notebook Dell", 2500.00, 10),
      new Produto("Mouse Logitech", 89.90, 50), 
      new Produto("Teclado Mecânico", 299.00, 25),
      new Produto("Monitor 24\"", 899.00, 15),
      new Produto("WebCam HD", 149.90, 30)
  };
  
  // Array para armazenar itens do carrinho
  private static String[] itensCarrinho = new String;
  private static double[] valoresCarrinho = new double;
  private static int contadorItens = 0;
  
  public static void exibirMenu() {
      System.out.println("\\n" + "=".repeat(50));
      System.out.println("           SISTEMA DE VENDAS JAVA");
      System.out.println("=".repeat(50));
      System.out.println("1. Ver produtos disponíveis");
      System.out.println("2. Adicionar produto ao carrinho");
      System.out.println("3. Ver carrinho");
      System.out.println("4. Finalizar compra");
      System.out.println("0. Sair");
      System.out.print("Escolha uma opção: ");
  }
  
  public static void listarProdutos() {
      System.out.println("\\n=== PRODUTOS DISPONÍVEIS ===");
      System.out.println("ID | Nome                 | Preço      | Estoque");
      System.out.println("-".repeat(55));
      
      for (int i = 0; i < produtos.length; i++) {
          System.out.printf("%2d | ", (i + 1));
          produtos[i].exibirInfo();
      }
  }
  
  public static void adicionarAoCarrinho(Scanner scanner) {
      listarProdutos();
      
      System.out.print("\\nDigite o ID do produto (1-" + produtos.length + "): ");
      int id = scanner.nextInt() - 1;
      
      if (id < 0 || id >= produtos.length) {
          System.out.println("ERRO: Produto não encontrado!");
          return;
      }
      
      System.out.print("Digite a quantidade: ");
      int quantidade = scanner.nextInt();
      
      Produto produto = produtos[id];
      
      if (!produto.temEstoque(quantidade)) {
          System.out.printf("ERRO: Estoque insuficiente! Disponível: %d\\n", 
                          produto.getQuantidadeEstoque());
          return;
      }
      
      if (contadorItens >= itensCarrinho.length) {
          System.out.println("ERRO: Carrinho cheio!");
          return;
      }
      
      // Adiciona ao carrinho
      double valorItem = produto.calcularTotal(quantidade);
      String itemDescricao = quantidade + "x " + produto.getNome();
      
      itensCarrinho[contadorItens] = itemDescricao;
      valoresCarrinho[contadorItens] = valorItem;
      contadorItens++;
      
      // Reduz estoque
      produto.reduzirEstoque(quantidade);
      
      System.out.printf("✓ Adicionado: %s - Total: R$ %.2f\\n", 
                       itemDescricao, valorItem);
  }
  
  public static void visualizarCarrinho() {
      if (contadorItens == 0) {
          System.out.println("\\nCarrinho vazio!");
          return;
      }
      
      System.out.println("\\n=== SEU CARRINHO ===");
      double totalCarrinho = 0;
      
      for (int i = 0; i < contadorItens; i++) {
          System.out.printf("%-25s R$ %8.2f\\n", 
                          itensCarrinho[i], valoresCarrinho[i]);
          totalCarrinho += valoresCarrinho[i];
      }
      
      System.out.println("-".repeat(37));
      System.out.printf("%-25s R$ %8.2f\\n", "TOTAL:", totalCarrinho);
  }
  
  public static void finalizarCompra() {
      if (contadorItens == 0) {
          System.out.println("\\nCarrinho vazio! Adicione produtos antes de finalizar.");
          return;
      }
      
      visualizarCarrinho();
      
      double total = 0;
      for (int i = 0; i < contadorItens; i++) {
          total += valoresCarrinho[i];
      }
      
      System.out.println("\\n=== FINALIZAR COMPRA ===");
      System.out.printf("Total da compra: R$ %.2f\\n", total);
      
      // Simula formas de pagamento
      if (total > 1000) {
          double desconto = total * 0.05; // 5% desconto para compras > R$ 1000
          total -= desconto;
          System.out.printf("Desconto aplicado: R$ %.2f\\n", desconto);
          System.out.printf("Total com desconto: R$ %.2f\\n", total);
      }
      
      System.out.println("\\n✓ Compra realizada com sucesso!");
      System.out.println("Obrigado pela preferência!");
      
      // Limpa carrinho
      contadorItens = 0;
  }
  
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      int opcao;
      
      do {
          exibirMenu();
          opcao = scanner.nextInt();
          
          switch (opcao) {
              case 1:
                  listarProdutos();
                  break;
              case 2:
                  adicionarAoCarrinho(scanner);
                  break;
              case 3:
                  visualizarCarrinho();
                  break;
              case 4:
                  finalizarCompra();
                  break;
              case 0:
                  System.out.println("\\nObrigado por usar o Sistema de Vendas Java!");
                  break;
              default:
                  System.out.println("\\nOpção inválida! Tente novamente.");
          }
          
          if (opcao != 0) {
              System.out.println("\\nPressione Enter para continuar...");
              scanner.nextLine(); // Limpa buffer
              scanner.nextLine(); // Aguarda Enter
          }
          
      } while (opcao != 0);
      
      scanner.close();
  }
}

    Próximos Passos: Expandindo Seus Conhecimentos em Java

    Dominar estes 5 fundamentos é apenas o início de sua jornada Java. Com essa base sólida, você está preparado para explorar conceitos mais avançados:

    Conceitos Intermediários Recomendados:

    1. Herança e Polimorfismo: Reutilização e flexibilidade de código
    2. Interfaces e Classes Abstratas: Contratos e abstrações
    3. Collections Framework: ArrayList, HashMap, LinkedList
    4. Tratamento de Exceções: try-catch, throw, finally
    5. Programação Funcional: Streams API, Lambda Expressions

    Frameworks e Tecnologias para Aprofundar:

    • Spring Framework: Para aplicações enterprise
    • Spring Boot: Desenvolvimento rápido de APIs REST
    • JPA/Hibernate: Persistência de dados
    • Maven/Gradle: Gerenciamento de projetos
    • JUnit: Testes automatizados

    Recursos Recomendados para Continuidade:

    • Documentação Oracle Java: Referência oficial completa
    • Baeldung.com: Tutoriais práticos e atualizados
    • Java Code Geeks: Artigos técnicos aprofundados
    • Effective Java (Joshua Bloch): Best practices essenciais
    • Clean Code (Robert Martin): Princípios de código limpo

    Conclusão: Fundamentos Sólidos, Carreira Sólida

    Os 5 fundamentos de Java que exploramos neste artigo não são apenas conceitos teóricos - são as ferramentas essenciais que você usará diariamente como desenvolvedor. Cada linha de código profissional que você escreverá combinará variáveis bem tipadas, estruturas de controle inteligentes, objetos bem modelados, arrays organizados e métodos reutilizáveis.

    Recapitulando os pilares fundamentais:

    1. Variáveis e Tipos de Dados: A fundação que garante segurança e performance
    2. Estruturas de Controle: A inteligência que torna programas dinâmicos
    3. Classes e Objetos: A organização que torna código maintível e escalável
    4. Arrays: A estrutura que permite processar múltiplos dados eficientemente
    5. Métodos: A reutilização que elimina redundância e melhora organização

    Java não é apenas uma linguagem de programação - é um ecossistema completo que continua evoluindo há quase três décadas. Empresas como Netflix, Amazon, Google e LinkedIn baseiam suas operações críticas em Java, e profissionais que dominam seus fundamentos sempre encontram oportunidades no mercado.

    A Jornada Continua

    Lembre-se: programação é uma habilidade prática. Os conceitos que apresentei só se tornam realmente seus quando você os aplica em projetos reais. Comece pequeno - crie calculadoras, jogos simples, sistemas de cadastro - e gradualmente evolua para aplicações mais complexas.

    A cada projeto que desenvolver usando estes fundamentos, você estará construindo não apenas software, mas também sua expertise e confiança como desenvolvedor Java.

    O mundo da tecnologia está cheio de oportunidades para quem domina os fundamentos. Sua jornada Java começa agora - com base sólida, propósito claro e os fundamentos que separam bons desenvolvedores de grandes desenvolvedores.

    Continue aprendendo, continue evoluindo. Java é mais que uma linguagem - é seu passaporte para o futuro da programação. ☕🚀

    Share
    Recommended for you
    Cognizant - Mobile Developer
    Luizalabs - Back-end com Python
    PcD Tech Bradesco - Java & QA Developer
    Comments (0)
    Read below

    JA

    Fundamentos de JavaJader Anjos - 13 de Outubro
    #Java

    MC

    Fundamentos de Java: Explorando o Poder das StreamsMauricio Cruz - 13 de Outubro
    #Java
    Carlos Bonadia
    Desvendando o Java: Um Guia de Primeiros Passos e Boas Práticas para Quem Está ComeçandoCarlos Bonadia - 13 de Outubro
    #Java