image

Accede a bootcamps ilimitados y a más de 650 cursos para siempre

60
%OFF

JF

Jefferson Francisco13/10/2025 23:08
Compartir

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. ☕🚀

    Compartir
    Recomendado para ti
    Cognizant - Mobile Developer
    Luizalabs - Back-end com Python
    PcD Tech Bradesco - Java & QA Developer
    Comentarios (0)