30 Anos

Introdução

Em 2025, a linguagem de programação Java completa 30 anos desde seu lançamento oficial. Criada originalmente pela Sun Microsystems, Java se tornou uma das linguagens mais influentes e utilizadas do mundo, marcando gerações de desenvolvedores e moldando o desenvolvimento de software moderno.

Origens do Java

• Início do Projeto (1991): O projeto Java começou como uma iniciativa da Sun Microsystems chamada Project Green. O objetivo era criar uma linguagem para dispositivos embarcados, como decodificadores de TV a cabo.
• James Gosling: Considerado o "pai do Java", liderou a equipe que criou a linguagem.
• Nome original: Oak (carvalho), inspirado em uma árvore próxima ao escritório de Gosling. Depois foi renomeado para Java, uma referência ao café da ilha de Java.

Lançamento Oficial

• 1995: A linguagem Java foi lançada oficialmente com o slogan:

  "Write Once, Run Anywhere" (Escreva uma vez, execute em qualquer lugar)

• Esse lema refletia a principal inovação do Java: a máquina virtual Java (JVM), que permite a execução do mesmo código em diferentes sistemas operacionais.

Evolução da Linguagem

Anos 1990

• 1996: Lançamento do JDK 1.0
• Java começa a ganhar espaço com o crescimento da internet e os applets (pequenos aplicativos executados em navegadores).

Anos 2000

• 2004: Java 5 introduz recursos importantes como generics, annotations e o for-each loop.
• Grande adoção no mercado corporativo com plataformas como Java EE (Enterprise Edition).

Anos 2010

• 2010: A Oracle adquire a Sun Microsystems e passa a ser a nova mantenedora do Java.
• Java 8 (2014) traz expressões lambda e a API de streams, marcando uma grande modernização da linguagem.

Anos 2020

• Novo modelo de lançamentos: atualizações a cada 6 meses.
• Java continua a evoluir com melhorias de performance, sintaxe mais moderna e novos recursos como records, pattern matching e virtual threads (Project Loom).

Impacto na Indústria

• Base de aplicações Android
• Utilizado em sistemas bancários, servidores corporativos, jogos, ciência e mais
• Forte presença acadêmica e em concursos de programação
• Comunidade ativa e vasto ecossistema de bibliotecas e frameworks (Spring, Hibernate, etc.)

Curiosidade

• A primeira versão pública do Java foi lançada em 23 de maio de 1995.
• A logo do Java — a xícara de café fumegante — é hoje um dos ícones mais reconhecidos no mundo da tecnologia.

Linha do Tempo: 30 Anos de Java

1991 ─────────────────────► Projeto Green é iniciado pela Sun Microsystems

                           (James Gosling começa o desenvolvimento do que viria a ser o Java)



1995 ─────────────────────► Lançamento oficial do Java 1.0

                           (Slogan: "Write Once, Run Anywhere")



1996 ─────────────────────► Lançamento do JDK 1.0

                           (Primeira versão estável para desenvolvedores)



1998 ─────────────────────► Java 2 (J2SE, J2EE, J2ME)

                           (Divisão em edições para diferentes tipos de aplicações)



2004 ─────────────────────► Java 5 (Tiger)

                           (Introdução de Generics, Annotations, Enum, Autoboxing, For-each loop)



2006 ─────────────────────► Java é disponibilizado como código aberto pela Sun (OpenJDK)



2010 ─────────────────────► Oracle adquire a Sun Microsystems

                           (Oracle passa a ser a nova responsável pelo Java)



2014 ─────────────────────► Java 8

                           (Expressões Lambda, Streams API, nova API de Data e Hora)



2017 ─────────────────────► Java 9

                           (Sistema de módulos - Project Jigsaw)



2019 ─────────────────────► Java 12-13

                           (Novo modelo de lançamentos semestrais)



2021 ─────────────────────► Java 17 (versão LTS)

                           (Pattern Matching, Sealed Classes, melhorias de performance)



2023 ─────────────────────► Java 21 (LTS)

                           (Virtual Threads - Project Loom, String Templates, Structured Concurrency)



2025 ─────────────────────► Java completa 30 anos!

O Método main

O método main é o ponto de entrada de qualquer aplicação Java. É a primeira coisa que a JVM (Java Virtual Machine) executa ao iniciar um programa.

Assinatura padrão

public static void main(String args)

Vamos entender cada parte dessa assinatura:

public: O método precisa ser público para que a JVM possa acessá-lo de fora da classe. static: É declarado como estático porque a JVM chama esse método sem criar uma instância da classe. void: O método não retorna nenhum valor. main: O nome obrigatório que a JVM reconhece como ponto de partida. String args: Um array de Strings que representa os argumentos de linha de comando passados ao programa. Exemplo básico

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Olá, mundo!");

    }

}

Anatomia

• Classe é como uma ficha médica/anatomia humana: define o que todas as pessoas têm (nome, peso, sexo, data de nascimento), mas não é uma pessoa real.
• Objeto é como um corpo real: uma instância concreta de uma pessoa com características específicas.

Classe = Projeto ou molde Objeto = Instância concreta desse molde

Criando a Classe Pessoa em Java

Vamos representar uma pessoa com os seguintes atributos:

• nome: String
• peso: double
• sexo: char (M ou F)
• dataNascimento: String (poderia ser LocalDate, mas vamos simplificar para fins didáticos)

public class Pessoa {

    // Atributos (características da pessoa)

    String nome;
    double peso;
    char sexo;
    String dataNascimento;

    // Método para exibir informações
    void exibirInformacoes() {

        System.out.println("Nome: " + nome);
        
        System.out.println("Peso: " + peso + " kg");

        System.out.println("Sexo: " + sexo);

        System.out.println("Data de Nascimento: " + dataNascimento);

    }

}

Criando um Objeto do Tipo Pessoa

No método main, criamos uma pessoa real a partir da classe:

public class Main {

    public static void main(String[] args) {

        Pessoa p1 = new Pessoa(); // Criando o objeto (corpo)

        // Atribuindo valores (dados pessoais)

        p1.nome = "Ana Silva";

        p1.peso = 65.5;

        p1.sexo = 'F';

        p1.dataNascimento = "12/04/1998";

        // Exibindo as informações

        p1.exibirInformacoes();

    }

}

Visualização da analogia:

1. Classe Pessoa → Molde / Projeto / Ficha Médica
2. Objeto p1 → Pessoa real (Ana Silva)

Atributos:

• nome → Nome do paciente
• peso → Peso corporal
• sexo → Sexo biológico
• dataNascimento→ Data de nascimento

Resumidamente

Com essa analogia, entendemos que:

• Classe define o que um tipo de objeto deve ter.
• Objeto é uma entidade concreta com dados reais.
• Java permite criar quantos objetos quisermos a partir de uma mesma classe, assim como podemos ter muitas pessoas a partir da mesma estrutura anatômica. Se quiser, posso complementar com uma ilustração visual (desenho anatômico x ficha x pessoa real), ou com outros exemplos como Carro, Animal ou Livro. Deseja isso também?

Tipos de Dados

O que são tipos primitivos?

Em Java, tipos primitivos são os tipos de dados mais básicos. Eles não são objetos e são armazenados diretamente na memória.

Java possui 8 tipos primitivos:

Por que usar tipos primitivos?

• Leves: Usam pouca memória.
• Rápidos: São mais rápidos do que objetos.
• Diretos: São ideais para cálculos simples e estruturas de controle.

Tipos Wrappers

Java oferece classes empacotadoras (wrapper classes) para cada tipo primitivo, que transformam tipos primitivos em objetos.

Exemplo:

int numero = 10;                     // tipo primitivo

Integer objNumero = Integer.valueOf(numero); // wrapper

System.out.println(objNumero + 5);  // Operação com objeto

Por que usar Wrappers?

• Permitem que valores primitivos sejam usados em:
• Coleções (ArrayList, HashMap, etc.)
• APIs modernas
• Incluem métodos úteis:
• Integer.parseInt("123")
• Double.isNaN(x)
• Character.isLetter('A')

Autoboxing e Unboxing

Desde o Java 5, o compilador faz conversões automáticas entre tipos primitivos e wrappers:

Integer a = 5;       // Autoboxing (int → Integer)

int b = a;           // Unboxing (Integer → int)

Universo de Classes

Além das wrappers, Java oferece classes auxiliares para trabalhar com tipos:

String: Manipulação de texto (não é wrapper, mas frequentemente usada com char) Math: Funções matemáticas (Math.pow(), Math.sqrt(), etc.) BigInteger e BigDecimal: Para números grandes e cálculos de alta precisão

Sabia que?

• Tipos primitivos são rápidos e eficientes para cálculos simples.
• Wrappers são essenciais para usar primitivas em estruturas que exigem objetos.
• Com o uso de autoboxing, Java torna mais simples alternar entre esses dois mundos.

Tipagem correta

Ao modelar uma classe como Pessoa, é essencial escolher os tipos de dados apropriados para garantir:

• Eficiência de memória
• Clareza do código
• Correta representação dos dados

1. nome → String

• Representa uma sequência de caracteres.
• Exemplo: "João da Silva"
• Justificativa: nomes são textos, e String é ideal para armazenar dados textuais em Java.

2. peso → double

• Representa valores com casas decimais.
• Exemplo: 72.5
• Justificativa: o peso pode ter frações (ex: 72,5 kg), e double tem precisão suficiente para esse caso.

3. sexo → char ou String

• Exemplo: 'M', 'F' ou "Masculino", "Feminino"
• Melhor escolha: char se forem apenas códigos ('M'/'F'); String se quiser mais flexibilidade.
• Alternativa moderna: usar um enum Sexo { MASCULINO, FEMININO, OUTRO }

4. dataNascimento → LocalDate

• Representa uma data (sem hora).
• Exemplo: LocalDate.of(1995, 5, 27)
• Justificativa: usar a API moderna de datas (java.time) permite validação, cálculo de idade, formatação etc.

Classe Pessoa

import java.time.LocalDate;

public class Pessoa {
    String nome;
    double peso;
    char sexo;
    LocalDate dataNascimento;
    void exibirInformacoes() {

        System.out.println("Nome: " + nome);
        System.out.println("Peso: " + peso + " kg");
        System.out.println("Sexo: " + sexo);
        System.out.println("Data de Nascimento: " + dataNascimento);

    }

}

Falta pouco

public enum Sexo {
    MASCULINO, FEMININO, OUTRO
}

import java.time.LocalDate;
public class Pessoa {
    String nome;
    double peso;
    Sexo sexo;
    LocalDate dataNascimento;
}

Vantagem do uso de enum:

Evita valores inválidos como "m", "x", "masculina" etc. Mais seguro e semântico.

Conclusão

Java é uma linguagem que conseguiu se manter relevante por três décadas graças à sua filosofia de portabilidade, robustez e à constante evolução. Com uma vasta comunidade e um ecossistema maduro, o Java segue como uma das principais linguagens do mundo — pronta para continuar sua história nas próximas décadas.