Java (linguagem de programação)

O desenvolvimento de Java começou em 1991, na Sun Microsystems, com o Green Project. A equipe central incluía James Gosling, Mike Sheridan e Patrick Naughton. O projeto procurava desenvolver software para dispositivos eletrônicos e sistemas computacionais que poderiam interagir com diferentes tipos de equipamentos. A linguagem criada durante o projeto recebeu inicialmente o nome de Oak.^[6]

Um dos protótipos produzidos foi o Star-7, um dispositivo portátil com interface gráfica sensível ao toque, concebido para controlar outros equipamentos. O projeto também originou Duke, personagem que se tornou o mascote da tecnologia Java. A equipe demonstrou uma versão funcional do sistema em 1992.^[6]

A equipe posteriormente redirecionou o desenvolvimento para aplicações distribuídas e para o uso em redes de computadores, em particular na internet. O nome Oak foi substituído por Java, e a tecnologia foi apresentada publicamente em 23 de maio de 1995. A plataforma foi concebida para permitir que o mesmo programa fosse executado em sistemas diferentes, desde que houvesse uma implementação compatível do ambiente de execução.^[1][10]

Durante os primeiros anos, Java ficou conhecida também pelo uso em aplicações executadas em navegadores por meio de applets. Esse modelo teve importância histórica para a difusão da linguagem, mas deixou de ser uma forma corrente de distribuição de aplicações web com o abandono do suporte a applets nos navegadores modernos. Java continuou a ser utilizada em diferentes domínios, incluindo aplicações empresariais, serviços de rede, software para computadores e sistemas embarcados.^[6]

O desenvolvimento das especificações de Java passou a contar com o Java Community Process (JCP), um processo de participação comunitária destinado a desenvolver e revisar especificações, implementações de referência e testes de compatibilidade para tecnologias Java.^[11]

O JCP não é uma licença de software. Trata-se de um processo de especificação e evolução de tecnologias; os termos de licenciamento dependem da implementação, dos componentes e da versão considerados.^[11][12]

Em novembro de 2006, a Sun Microsystems anunciou a disponibilização de grande parte do código-fonte da implementação da plataforma sob a GNU GPL. O processo de abertura do código foi concluído em 2007 e deu origem ao projeto OpenJDK, uma implementação de referência de código aberto da plataforma Java.^[13][12]

A Oracle anunciou a aquisição da Sun Microsystems em 2009 e concluiu a operação em 27 de janeiro de 2010.^[7] Com a aquisição, a Oracle assumiu a gestão de produtos e tecnologias da Sun, incluindo Java. O desenvolvimento da plataforma passou a envolver a Oracle, o projeto OpenJDK e a comunidade participante dos processos de especificação e implementação.

A partir do Java 9, lançado em 2017, os lançamentos da plataforma passaram a seguir uma cadência regular, em geral com novas versões principais em março e setembro. Algumas versões recebem suporte de longo prazo (LTS, do inglês *Long-Term Support*), conforme a política de suporte do fornecedor. A designação LTS e os prazos de suporte podem variar entre fornecedores e distribuições.^[14]

Não existe uma única condição de licenciamento aplicável indistintamente a todas as distribuições de Java. O OpenJDK é disponibilizado sob a GNU GPL versão 2, acompanhada da Classpath Exception. As condições de uso de uma distribuição Oracle JDK dependem da versão e dos termos aplicáveis a essa distribuição.^[12]

A abertura do código-fonte de grande parte da implementação da plataforma Java começou em 2006, durante a gestão da Sun Microsystems, e foi concluída em 2007. O projeto OpenJDK passou a oferecer uma implementação de código aberto da plataforma e serve de base para diversas distribuições de JDK.^[12][20]

Em programas Java tradicionais iniciados pelo lançador da plataforma, um dos pontos de entrada mais conhecidos é o método `main`, com a assinatura `public static void main(String[] args)`. O parâmetro `args` recebe os argumentos informados na linha de comando.

public class OlaMundo {
    /**
     * Método de entrada do programa.
     *
     * public: permite o acesso ao método pelo lançador.
     * static: permite chamar o método sem criar uma instância da classe.
     * void: indica que o método não retorna um valor.
     * main: nome reconhecido como ponto de entrada convencional.
     * String[] args: array com os argumentos da linha de comando.
     */
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
    }
}

O exemplo seguinte apresenta uma classe abstrata e duas classes derivadas que implementam seu método abstrato.

abstract class Animal {
    public abstract void fazerBarulho();
}

class Cachorro extends Animal {
    @Override
    public void fazerBarulho() {
        System.out.println("Au au!");
    }
}

class Gato extends Animal {
    @Override
    public void fazerBarulho() {
        System.out.println("Miau!");
    }
}

As classes `Cachorro` e `Gato` herdam de `Animal` e fornecem implementações próprias para `fazerBarulho()`. A redefinição de um método herdado é denominada sobrescrita (override).

Java não permite que uma classe estenda diretamente mais de uma classe. Uma classe pode, porém, implementar várias interfaces; interfaces também podem estender outras interfaces. Essa possibilidade permite que um tipo satisfaça diferentes contratos sem exigir herança de múltiplas classes. Uma classe que não declara explicitamente outra superclasse herda diretamente de `Object`, a raiz da hierarquia de classes de Java.^[21]

Uma interface define um contrato de operações que uma classe pode implementar. As interfaces podem declarar métodos abstratos, métodos padrão (*default*), métodos estáticos e constantes, entre outros elementos previstos pela especificação da linguagem. Uma classe pode implementar mais de uma interface.

import java.awt.Color;

abstract class Animal {
    public abstract void fazerBarulho();
}

interface Pesado {
    double obterPeso();
}

interface Colorido {
    Color obterCor();
}

class Porco extends Animal implements Pesado, Colorido {
    @Override
    public void fazerBarulho() {
        System.out.println("Óinc!");
    }

    @Override
    public double obterPeso() {
        return 50.0;
    }

    @Override
    public Color obterCor() {
        return Color.BLACK;
    }

    public boolean enlameado() {
        return true;
    }
}

No exemplo, `Porco` estende `Animal` e implementa as interfaces `Pesado` e `Colorido`. A classe fornece uma implementação para cada método abstrato herdado ou declarado pelas interfaces.

É possível criar um objeto sem armazenar sua referência em uma variável. Isso não torna a classe do objeto anônima: no primeiro caso do exemplo, a classe `Cavalo` tem nome. No segundo, a expressão cria uma classe anônima que estende `Animal` e implementa seu método abstrato.

abstract class Animal {
    public abstract void fazerBarulho();
}

class Cavalo extends Animal {
    @Override
    public void fazerBarulho() {
        System.out.println("Relincho!");
    }
}

class MostraBarulho {
    public static void main(String[] args) {
        new Cavalo().fazerBarulho();

        new Animal() {
            @Override
            public void fazerBarulho() {
                System.out.println("Quac!");
            }
        }.fazerBarulho();
    }
}

A versão 8 de Java, lançada em 2014, acrescentou recursos importantes para a programação funcional, entre eles expressões lambda, referências a métodos e a API de *streams*. Esses recursos permitem, por exemplo, representar operações por meio de interfaces funcionais e encadear operações sobre coleções de dados.

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> paradigmas = new ArrayList<>();

        paradigmas.add("Genérico (1.5)");
        paradigmas.add("Funcional (8)");

        paradigmas.stream()
            .map(String::toUpperCase)
            .forEach(System.out::println);
    }
}

Nesse exemplo, `stream()` cria um fluxo de elementos; `map()` transforma cada texto em letras maiúsculas; e `forEach()` executa uma operação para cada elemento resultante.

Há frameworks e bibliotecas que apoiam diferentes etapas do desenvolvimento de aplicações Java. Entre os exemplos conhecidos estão:

• Hibernate — framework de mapeamento objeto-relacional.
• JUnit — framework para testes automatizados.
• Apache Log4j — biblioteca de registro de eventos e mensagens de diagnóstico.
• Spring — framework que inclui recursos para injeção de dependência, inversão de controle e desenvolvimento de aplicações.
• Apache Struts — framework web baseado no padrão de arquitetura MVC.

A presença de uma ferramenta nessa lista não implica que seja a mais utilizada ou recomendada para todos os projetos. A escolha depende do objetivo, da arquitetura, da manutenção e dos requisitos da aplicação.

O desenvolvimento Java pode ser feito em editores de texto e por ferramentas de linha de comando ou por meio de ambientes de desenvolvimento integrado (IDEs). Exemplos de ambientes e ferramentas associados ao ecossistema incluem:

• BlueJ — ambiente educacional para aprender programação orientada a objetos.
• Eclipse — ambiente de desenvolvimento extensível.
• IntelliJ IDEA — ambiente de desenvolvimento integrado da JetBrains.
• JDeveloper — ambiente de desenvolvimento da Oracle.
• NetBeans — ambiente de desenvolvimento integrado que oferece suporte a Java.
• jEdit — editor de texto extensível com recursos para edição de código.
• JCreator — ambiente de desenvolvimento Java que teve uso em versões anteriores do ecossistema.
• JBuilder — ambiente de desenvolvimento historicamente associado à Borland.