Java (linguagem de programação)

Java é uma linguagem de programação de alto nível, baseada em classe e orientada a objetos, projetada para ter o mínimo possível de dependências de implementação. É uma linguagem de programação de uso geral destinada a permitir que os programadores escrevam uma vez, executem em qualquer lugar (WORA), o que significa que o código Java compilado pode ser executado em todas as plataformas que suportam Java sem a necessidade de recompilação. Os aplicativos Java são normalmente compilados em bytecode que podem ser executados em qualquer máquina virtual Java (JVM), independentemente da arquitetura subjacente do computador. A sintaxe de Java é semelhante a C e C++, mas possui menos recursos de baixo nível do que qualquer um deles. O tempo de execução Java fornece recursos dinâmicos (como reflexão e modificação de código de tempo de execução) que normalmente não estão disponíveis em linguagens compiladas tradicionais. Em 2019, Java era uma das linguagens de programação mais populares em uso de acordo com o GitHub, particularmente para aplicativos da Web cliente-servidor, com 9 milhões de desenvolvedores relatados.

Java foi originalmente desenvolvido por James Gosling na Sun Microsystems. Foi lançado em maio de 1995 como um componente central do Sun Microsystems' plataforma Java. Os compiladores Java de implementação original e de referência, máquinas virtuais e bibliotecas de classe foram originalmente lançados pela Sun sob licenças proprietárias. Em maio de 2007, em conformidade com as especificações do Java Community Process, a Sun relicenciou a maioria de suas tecnologias Java sob a licença GPL-2.0 somente. A Oracle oferece seu próprio HotSpot Java Virtual Machine, no entanto, a implementação de referência oficial é o OpenJDK JVM, que é um software de código aberto gratuito e usado pela maioria dos desenvolvedores e é o JVM padrão para quase todas as distribuições do Linux.

Desde setembro de 2022, Java 19 é a versão mais recente, enquanto Java 17, 11 e 8 são as versões atuais de suporte de longo prazo (LTS).

História

Duke, o mascote Java

James Gosling, o criador de Java, em 2008

O gráfico índice de popularidade da linguagem de programação TIOBE de 2002 a 2022. Java estava firmemente no topo de meados de 2015 até o início de 2020.

James Gosling, Mike Sheridan e Patrick Naughton iniciaram o projeto de linguagem Java em junho de 1991. Java foi originalmente projetado para televisão interativa, mas era muito avançado para a indústria de televisão digital a cabo na época. A linguagem foi inicialmente chamada de Oak em homenagem a um carvalho que ficava do lado de fora do escritório de Gosling. Mais tarde, o projeto recebeu o nome de Green e finalmente foi renomeado para Java, de Java coffee, um tipo de café da Indonésia. Gosling projetou o Java com uma sintaxe no estilo C/C++ que os programadores de sistemas e aplicativos achariam familiar.

A Sun Microsystems lançou a primeira implementação pública como Java 1.0 em 1996. Ela prometia a funcionalidade escrever uma vez, executar em qualquer lugar (WORA), fornecendo tempos de execução gratuitos em plataformas populares. Bastante seguro e com segurança configurável, permitia restrições de acesso à rede e a arquivos. Os principais navegadores da Web logo incorporaram a capacidade de executar applets Java em páginas da Web, e o Java rapidamente se tornou popular. O compilador Java 1.0 foi reescrito em Java por Arthur van Hoff para obedecer estritamente à especificação da linguagem Java 1.0. Com o advento do Java 2 (lançado inicialmente como J2SE 1.2 em dezembro de 1998 – 1999), as novas versões tinham várias configurações criadas para diferentes tipos de plataformas. O J2EE inclui tecnologias e APIs para aplicativos corporativos normalmente executados em ambientes de servidor, enquanto o J2ME apresenta APIs otimizadas para aplicativos móveis. A versão desktop foi renomeada como J2SE. Em 2006, para fins de marketing, a Sun renomeou as novas versões do J2 como Java EE, Java ME e Java SE, respectivamente.

Em 1997, a Sun Microsystems abordou o corpo de padrões ISO/IEC JTC 1 e posteriormente a Ecma International para formalizar o Java, mas logo desistiu do processo. Java continua sendo um padrão de fato, controlado por meio do Java Community Process. Ao mesmo tempo, a Sun disponibilizou a maioria de suas implementações Java gratuitamente, apesar de seu status de software proprietário. A Sun gerou receita com o Java por meio da venda de licenças para produtos especializados, como o Java Enterprise System.

Em 13 de novembro de 2006, a Sun lançou grande parte de sua Java virtual machine (JVM) como software livre e de código aberto (FOSS), sob os termos da licença GPL-2.0-only. Em 8 de maio de 2007, a Sun concluiu o processo, disponibilizando todo o código principal de sua JVM sob os termos de distribuição de software livre/código aberto, além de uma pequena parte do código da qual a Sun não detinha os direitos autorais.

O vice-presidente da Sun, Rich Green, disse que o papel ideal da Sun em relação a Java era como um evangelista. Após a aquisição da Sun Microsystems pela Oracle Corporation em 2009–10, a Oracle se descreveu como administradora da tecnologia Java com um compromisso incansável de promover uma comunidade de participação e transparência. Isso não impediu a Oracle de abrir um processo contra o Google logo depois disso por usar Java dentro do Android SDK (consulte a seção Android).

Em 2 de abril de 2010, James Gosling renunciou à Oracle.

Em janeiro de 2016, a Oracle anunciou que os ambientes de tempo de execução Java baseados no JDK 9 descontinuariam o plug-in do navegador.

O software Java roda em tudo, de laptops a data centers, consoles de jogos a supercomputadores científicos.

A Oracle (e outras) recomenda enfaticamente a desinstalação de versões desatualizadas e sem suporte do Java, devido a problemas de segurança não resolvidos em versões mais antigas.

Princípios

Havia cinco objetivos principais na criação da linguagem Java:

1. Deve ser simples, orientada a objetos e familiar.
2. Deve ser robusto e seguro.
3. Deve ser arquitetônico neutro e portátil.
4. Ele deve executar com alto desempenho.
5. Deve ser interpretado, roscado e dinâmico.

Versões

Desde setembro de 2021, Java 8, 11 e 17 são compatíveis como versões de suporte de longo prazo (LTS).

A Oracle lançou a última atualização pública de custo zero para a versão legada do Java 8 LTS em janeiro de 2019 para uso comercial, embora ainda ofereça suporte ao Java 8 com atualizações públicas para uso pessoal indefinidamente. Outros fornecedores começaram a oferecer compilações de custo zero do OpenJDK 18 e 8, 11 e 17 que ainda estão recebendo segurança e outras atualizações.

Principais versões de lançamento do Java, juntamente com suas datas de lançamento:

Edições

A Sun definiu e oferece suporte a quatro edições do Java destinadas a diferentes ambientes de aplicativos e segmentou muitas de suas APIs para que pertençam a uma das plataformas. As plataformas são:

• Cartão Java para cartões inteligentes.
• Java Platform, Micro Edition (Java ME) – visando ambientes com recursos limitados.
• Java Platform, Standard Edition (Java SE) – visando ambientes de estação de trabalho.
• Java Platform, Enterprise Edition (Java EE) – visando grandes ambientes corporativos ou de Internet distribuídos.

As classes nas APIs Java são organizadas em grupos separados chamados pacotes. Cada pacote contém um conjunto de interfaces, classes, subpacotes e exceções relacionadas.

A Sun também forneceu uma edição chamada Personal Java que foi substituída por emparelhamentos de perfil de configuração Java ME baseados em padrões posteriores.

Sistema de execução

Java JVM e bytecode

Um objetivo de design do Java é a portabilidade, o que significa que os programas escritos para a plataforma Java devem ser executados de maneira semelhante em qualquer combinação de hardware e sistema operacional com suporte de tempo de execução adequado. Isso é obtido compilando o código da linguagem Java para uma representação intermediária chamada Java bytecode, em vez de diretamente para o código de máquina específico da arquitetura. As instruções de bytecode Java são análogas ao código de máquina, mas devem ser executadas por uma máquina virtual (VM) escrita especificamente para o hardware do host. Os usuários finais geralmente usam um Java Runtime Environment (JRE) instalado em seu dispositivo para aplicativos Java autônomos ou um navegador da Web para applets Java.

As bibliotecas padrão fornecem uma maneira genérica de acessar recursos específicos do host, como gráficos, encadeamento e rede.

O uso de bytecode universal simplifica a portabilidade. No entanto, a sobrecarga de interpretar bytecode em instruções de máquina fez com que os programas interpretados quase sempre fossem executados mais lentamente do que os executáveis nativos. Os compiladores just-in-time (JIT) que compilam códigos de byte para código de máquina durante o tempo de execução foram introduzidos desde o início. O compilador Hotspot do Java é na verdade dois compiladores em um; e com GraalVM (incluído, por exemplo, no Java 11, mas removido a partir do Java 16), permitindo a compilação em camadas. O próprio Java é independente de plataforma e é adaptado à plataforma específica em que será executado por uma máquina virtual Java (JVM) para ele, que traduz o bytecode Java na linguagem de máquina da plataforma.

Desempenho

Os programas escritos em Java têm a reputação de serem mais lentos e exigirem mais memória do que aqueles escritos em C++. No entanto, os programas Java' a velocidade de execução melhorou significativamente com a introdução da compilação just-in-time em 1997/1998 para Java 1.1, a adição de recursos de linguagem que suportam melhor análise de código (como classes internas, a classe StringBuilder, asserções opcionais etc.) e otimizações na máquina virtual Java, como HotSpot se tornando a JVM padrão da Sun em 2000. Com Java 1.5, o desempenho foi melhorado com a adição do pacote java.util.concurrent, incluindo implementações sem bloqueio de ConcurrentMaps e outros coleções multi-core e foi aprimorado ainda mais com o Java 1.6.

Não-JVM

Algumas plataformas oferecem suporte direto de hardware para Java; existem microcontroladores que podem executar o bytecode Java em hardware em vez de uma máquina virtual Java de software, e alguns processadores baseados em ARM podem ter suporte de hardware para executar o bytecode Java por meio de sua opção Jazelle, embora o suporte tenha sido descartado principalmente nas implementações atuais do ARM.

Gerenciamento automático de memória

Java usa um coletor de lixo automático para gerenciar a memória no ciclo de vida do objeto. O programador determina quando os objetos são criados, e o Java runtime é responsável por recuperar a memória quando os objetos não estiverem mais em uso. Uma vez que nenhuma referência a um objeto permaneça, a memória inacessível torna-se elegível para ser liberada automaticamente pelo coletor de lixo. Algo semelhante a um vazamento de memória ainda pode ocorrer se o código de um programador contém uma referência a um objeto que não é mais necessário, normalmente quando objetos que não são mais necessários são armazenados em contêineres que ainda estão em uso. Se métodos para um objeto inexistente forem chamados, uma exceção de ponteiro nulo será lançada.

Uma das ideias por trás do modelo de gerenciamento automático de memória do Java é que os programadores podem ser poupados do fardo de realizar o gerenciamento manual de memória. Em algumas linguagens, a memória para a criação de objetos é alocada implicitamente na pilha ou explicitamente alocada e desalocada do heap. Neste último caso, a responsabilidade de gerenciar a memória é do programador. Se o programa não desalocar um objeto, ocorrerá um vazamento de memória. Se o programa tentar acessar ou desalocar a memória que já foi desalocada, o resultado será indefinido e difícil de prever, e o programa provavelmente ficará instável ou travará. Isso pode ser parcialmente remediado pelo uso de ponteiros inteligentes, mas eles aumentam a sobrecarga e a complexidade. Observe que a coleta de lixo não evita vazamentos de memória lógica, ou seja, aqueles em que a memória ainda é referenciada, mas nunca usada.

A coleta de lixo pode acontecer a qualquer momento. Idealmente, ocorrerá quando um programa estiver ocioso. É garantido que será acionado se não houver memória livre suficiente no heap para alocar um novo objeto; isso pode fazer com que um programa pare momentaneamente. O gerenciamento explícito de memória não é possível em Java.

Java não suporta aritmética de ponteiro de estilo C/C++, onde os endereços de objeto podem ser manipulados aritmeticamente (por exemplo, adicionando ou subtraindo um deslocamento). Isso permite que o coletor de lixo realoque os objetos referenciados e garanta a proteção e a segurança do tipo.

Assim como em C++ e algumas outras linguagens orientadas a objetos, as variáveis dos tipos de dados primitivos de Java são armazenadas diretamente em campos (para objetos) ou na pilha (para métodos) em vez de no heap, como é geralmente verdadeiro para tipos de dados não primitivos (mas consulte a análise de escape). Esta foi uma decisão consciente dos designers de Java por motivos de desempenho.

Java contém vários tipos de coletores de lixo. Desde o Java 9, o HotSpot usa o Garbage First Garbage Collector (G1GC) como padrão. No entanto, também existem vários outros coletores de lixo que podem ser usados para gerenciar o heap. Para a maioria dos aplicativos em Java, G1GC é suficiente. Anteriormente, o coletor de lixo paralelo era usado no Java 8.

Resolver o problema de gerenciamento de memória não alivia o programador do fardo de lidar adequadamente com outros tipos de recursos, como conexões de rede ou banco de dados, manipuladores de arquivos, etc., especialmente na presença de exceções.

Sintaxe

Gráfico de dependência das classes Java Core (criado com jdeps e Gephi)

A sintaxe de Java é amplamente influenciada por C++ e C. Ao contrário de C++, que combina a sintaxe para programação estruturada, genérica e orientada a objetos, Java foi construída quase exclusivamente como uma linguagem orientada a objetos. Todo o código é escrito dentro de classes e cada item de dados é um objeto, com exceção dos tipos de dados primitivos (ou seja, inteiros, números de ponto flutuante, valores booleanos e caracteres), que não são objetos por motivos de desempenho. Java reutiliza alguns aspectos populares de C++ (como o printf).

Ao contrário de C++, Java não suporta sobrecarga de operador ou herança múltipla para classes, embora herança múltipla seja suportada para interfaces.

Java usa comentários semelhantes aos de C++. Existem três estilos diferentes de comentários: um estilo de linha única marcado com duas barras (//), um estilo de várias linhas aberto com /* e fechado com * /, e o estilo de comentário Javadoc aberto com /** e fechado com */. O estilo Javadoc de comentários permite que o usuário execute o Javadoc executável para criar documentação para o programa e pode ser lido por alguns ambientes de desenvolvimento integrado (IDEs), como o Eclipse, para permitir que os desenvolvedores acessem a documentação dentro do IDE.

Olá mundo exemplo

O tradicional programa Hello world pode ser escrito em Java como:

público classe Olá. ( público estática vazio principal(String[] Args) ( Sistema.fora.Impressão("Olá Mundo!"); // Imprime a string para o console. ??

Todos os arquivos de origem devem ser nomeados após a classe pública que eles contêm, acrescentando o sufixo .java, por exemplo, HelloWorldApp.java. Ele deve primeiro ser compilado em bytecode, usando um compilador Java, produzindo um arquivo com o sufixo .class (HelloWorldApp.class, neste caso). Só então ele pode ser executado ou lançado. O arquivo de origem Java pode conter apenas uma classe pública, mas pode conter várias classes com um modificador de acesso não público e qualquer número de classes internas públicas. Quando o arquivo de origem contém várias classes, é necessário tornar uma classe (introduzida pela palavra-chave class) pública (precedida pela palavra-chave public palavra-chave) e nomeie o arquivo de origem com esse nome de classe pública.

Uma classe que não é declarada pública pode ser armazenada em qualquer arquivo .java. O compilador irá gerar um arquivo de classe para cada classe definida no arquivo fonte. O nome do arquivo de classe é o nome da classe, com .class anexado. Para a geração do arquivo de classe, as classes anônimas são tratadas como se seus nomes fossem a concatenação do nome de sua classe delimitadora, um $ e um inteiro.

A palavra-chave public denota que um método pode ser chamado do código em outras classes ou que uma classe pode ser usada por classes fora da hierarquia de classes. A hierarquia de classes está relacionada ao nome do diretório no qual o arquivo.java está localizado. Isso é chamado de modificador de nível de acesso. Outros modificadores de nível de acesso incluem as palavras-chave private (um método que só pode ser acessado na mesma classe) e protected (que permite o acesso do código do mesmo pacote). Se um trecho de código tentar acessar métodos privados ou métodos protegidos, a JVM lançará uma SecurityException

A palavra-chave static na frente de um método indica um método estático, que está associado apenas à classe e não a nenhuma instância específica dessa classe. Somente métodos estáticos podem ser invocados sem uma referência a um objeto. Os métodos estáticos não podem acessar nenhum membro de classe que também não seja estático. Os métodos que não são designados como estáticos são métodos de instância e requerem uma instância específica de uma classe para operar.

A palavra-chave void indica que o método principal não retorna nenhum valor para o chamador. Se um programa Java for encerrado com um código de erro, ele deverá chamar System.exit() explicitamente.

O nome do método main não é uma palavra-chave na linguagem Java. É simplesmente o nome do método que o iniciador Java chama para passar o controle para o programa. As classes Java executadas em ambientes gerenciados, como applets e Enterprise JavaBeans, não usam ou precisam de um método main(). Um programa Java pode conter várias classes com métodos main, o que significa que a VM precisa ser informada explicitamente de qual classe iniciar.

O método principal deve aceitar uma matriz de objetos String. Por convenção, é referenciado como args embora qualquer outro nome de identificador legal possa ser usado. Desde Java 5, o método principal também pode usar argumentos variáveis, na forma de public static void main(String... args), permitindo que o método principal seja invocado com um número arbitrário de String. O efeito desta declaração alternativa é semanticamente idêntico (ao parâmetro args que ainda é um array de objetos String), mas permite uma sintaxe alternativa para criar e passar o array.

O iniciador Java inicia o Java carregando uma determinada classe (especificada na linha de comando ou como um atributo em um JAR) e iniciando seu método public static void main(String[]). Programas autônomos devem declarar esse método explicitamente. O parâmetro String[] args é uma matriz de objetos String contendo quaisquer argumentos passados para a classe. Os parâmetros para main geralmente são passados por meio de uma linha de comando.

A impressão faz parte de uma biblioteca padrão Java: a classe System define um campo estático público chamado out. O objeto out é uma instância da classe PrintStream e fornece muitos métodos para imprimir dados para padrão, incluindo println(String) que também acrescenta uma nova linha à string passada.

A string "Hello World!" é automaticamente convertida em um objeto String pelo compilador.

Exemplo com métodos

// Este é um exemplo de um comentário de linha única usando duas faixasNão. * Este é um exemplo de um comentário de linha múltipla usando o slash e asterisco. * Este tipo de comentário pode ser usado para manter um monte de informações ou desativar * código, mas é muito importante lembrar-se de fechar o comentário. *pacote Esforços;importação Java.util. Mapa;importação java.util.HashMap;Não. * Este é um exemplo de um comentário Javadoc; Javadoc pode compilar documentação * deste texto. Os comentários do Javadoc devem preceder imediatamente a classe, método, * ou campo sendo documentado. * @autor Wikipedia Voluntários *público classe FibCalculator estende Fibonacina instrumentos Calculadora ( privado estática Mapa<Integer, Integer> memorizado = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = novo novo HashMap<(); Não. * O método principal escrito da seguinte forma é usado pela JVM como ponto de partida * para o programa. * público estática vazio principal(String[] Args) ( memorizado.Põe-te a andar.(1, 1); memorizado.Põe-te a andar.(2, 1); Sistema.fora.Impressão(Fibonacinas(12)); // Obter o número 12 Fibonacci e imprimir para console ? Não. * Um exemplo de um método escrito em Java, envolvido em uma classe. * Dado um número não negativo FIBINDEX, retorna * o número Nth Fibonacci, onde N é igual a FIBINDEX. *  * @param fibIndex O índice do número de Fibonacci * @return o número Fibonacci * público estática - Não. Fibonacinas(- Não. FibIndex) ( se (memorizado.contém Chaveiro(FibIndex) ( retorno memorizado.Vamos.(FibIndex); ? - Não. resposta = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Fibonacinas(FibIndex - Não. 1) + Fibonacinas(FibIndex - Não. 2); memorizado.Põe-te a andar.(FibIndex, resposta); retorno resposta; ??

Aulas especiais

Aplicativo

Os applets Java eram programas embutidos em outros aplicativos, geralmente em uma página da Web exibida em um navegador da Web. A API do applet Java agora está obsoleta desde o Java 9 em 2017.

Servlet

A tecnologia de servlet Java fornece aos desenvolvedores da Web um mecanismo simples e consistente para estender a funcionalidade de um servidor da Web e para acessar sistemas de negócios existentes. Servlets são componentes Java EE do lado do servidor que geram respostas a solicitações de clientes. Na maioria das vezes, isso significa gerar páginas HTML em resposta a solicitações HTTP, embora haja várias outras classes de servlet padrão disponíveis, por exemplo, para comunicação WebSocket.

A API de servlet Java foi até certo ponto substituída (mas ainda usada sob o capô) por duas tecnologias Java padrão para serviços da Web:

• a API Java para RESTful Web Services (JAX-RS 2.0) útil para serviços AJAX, JSON e REST, e
• a API Java para XML Web Services (JAX-WS) útil para SOAP Web Services.

As implementações típicas dessas APIs em servidores de aplicativos ou contêineres de servlet usam um servlet padrão para lidar com todas as interações com as solicitações e respostas HTTP que delegam aos métodos de serviço da web para a lógica de negócios real.

Páginas JavaServer

JavaServer Pages (JSP) são componentes Java EE do lado do servidor que geram respostas, geralmente páginas HTML, para solicitações HTTP de clientes. JSPs incorporam código Java em uma página HTML usando os delimitadores especiais <% e %>. Um JSP é compilado para um servlet Java, um aplicativo Java por direito próprio, na primeira vez em que é acessado. Depois disso, o servlet gerado cria a resposta.

Aplicativo Swing

Swing é uma biblioteca de interface gráfica com o usuário para a plataforma Java SE. É possível especificar uma aparência diferente por meio do sistema plugável de aparência e sensação do Swing. Clones de Windows, GTK+ e Motif são fornecidos pela Sun. A Apple também oferece uma aparência Aqua para o macOS. Onde as implementações anteriores dessas aparências podem ter sido consideradas ausentes, o Swing no Java SE 6 aborda esse problema usando mais rotinas de desenho de widget de GUI nativa das plataformas subjacentes.

Aplicativo JavaFX

JavaFX é uma plataforma de software para criar e fornecer aplicativos de desktop, bem como aplicativos da Web avançados que podem ser executados em uma ampla variedade de dispositivos. O JavaFX destina-se a substituir o Swing como a biblioteca GUI padrão para o Java SE, mas desde o JDK 11 o JavaFX não está no núcleo do JDK e, em vez disso, em um módulo separado. O JavaFX tem suporte para computadores desktop e navegadores da Web no Microsoft Windows, Linux e macOS. O JavaFX não tem suporte para a aparência do sistema operacional nativo.

Genéricos

Em 2004, os genéricos foram adicionados à linguagem Java, como parte do J2SE 5.0. Antes da introdução dos genéricos, cada declaração de variável tinha que ser de um tipo específico. Para classes container, por exemplo, isso é um problema porque não há uma maneira fácil de criar um container que aceite apenas tipos específicos de objetos. O contêiner opera em todos os subtipos de uma classe ou interface, geralmente Object, ou uma classe de contêiner diferente deve ser criada para cada classe contida. Os genéricos permitem a verificação de tipo em tempo de compilação sem a necessidade de criar muitas classes de contêiner, cada uma contendo código quase idêntico. Além de permitir um código mais eficiente, certas exceções de tempo de execução são impedidas de ocorrer, emitindo erros de tempo de compilação. Se o Java evitasse que todos os erros de tipo de tempo de execução (ClassCastExceptions) ocorressem, seria um tipo seguro.

Em 2016, o sistema de tipos de Java provou ser ineficaz, pois é possível usar genéricos para construir classes e métodos que permitem a atribuição de uma instância de uma classe a uma variável de outra classe não relacionada. Esse código é aceito pelo compilador, mas falha em tempo de execução com uma exceção de conversão de classe.

Críticas

As críticas dirigidas ao Java incluem a implementação de genéricos, velocidade, manipulação de números não assinados, implementação de aritmética de ponto flutuante e um histórico de vulnerabilidades de segurança no HotSpot de implementação Java VM primário.

Bibliotecas de classes

A Java Class Library é a biblioteca padrão, desenvolvida para dar suporte ao desenvolvimento de aplicativos em Java. Ele é controlado pela Oracle em cooperação com outros por meio do programa Java Community Process. As empresas ou indivíduos que participam desse processo podem influenciar o design e o desenvolvimento das APIs. Este processo tem sido objeto de controvérsia durante a década de 2010. A biblioteca de classes contém recursos como:

• As bibliotecas principais, que incluem:
  • IO/NIO
  • Networking (NOTE: novo cliente HTTP desde Java 11)
  • Reflexão
  • Concorrência
  • Genéricos
  • Scripting/Compiler
  • Programação funcional (Lambda, Streaming)
  • Coletar bibliotecas que implementam estruturas de dados, tais como listas, dicionários, árvores, conjuntos, filas e filas duplas ou pilhas
  • Bibliotecas XML Processing (Parsing, Transforming, Validating)
  • Segurança
  • Bibliotecas de internacionalização e localização
• As bibliotecas de integração, que permitem que o escritor de aplicativos se comunique com sistemas externos. Estas bibliotecas incluem:
  • A API Java Database Connectivity (JDBC) para acesso ao banco de dados
  • Java Naming and Directory Interface (JNDI) para pesquisa e descoberta
  • RMI e CORBA para desenvolvimento de aplicações distribuídas
  • JMX para gerenciar e monitorar aplicações
• Bibliotecas de interface do usuário, que incluem:
  • O (peso pesado, ou nativo) Resumo Window Toolkit (AWT), que fornece componentes de GUI, os meios para colocar esses componentes e os meios para lidar com eventos desses componentes
  • O (peso leve) Bibliotecas de balanço, que são construídas em AWT, mas fornecem implementações (não nativas) do widgetry AWT
  • APIs para captura de áudio, processamento e reprodução
  • JavaFX
• Uma implementação dependente da plataforma da máquina virtual Java que é o meio pelo qual os bytecodes das bibliotecas Java e aplicativos de terceiros são executados
• Plugins, que permitem applets ser executado em navegadores da web
• Java Web Start, que permite que aplicações Java sejam distribuídas de forma eficiente para usuários finais em toda a Internet
• Licenciamento e documentação

Documentação

Javadoc é um sistema de documentação abrangente, criado pela Sun Microsystems. Ele fornece aos desenvolvedores um sistema organizado para documentar seu código. Os comentários Javadoc têm um asterisco extra no início, ou seja, os delimitadores são /** e */, enquanto os comentários normais de várias linhas em Java são delimitados por /* e */, e comentários de uma única linha começam com //.

Implementações

A Oracle Corporation é a atual proprietária da implementação oficial da plataforma Java SE, após a aquisição da Sun Microsystems em 27 de janeiro de 2010. Esta implementação é baseada na implementação original do Java pela Sun. A implementação do Oracle está disponível para Microsoft Windows (ainda funciona para XP, enquanto apenas versões posteriores são oficialmente suportadas), macOS, Linux e Solaris. Como o Java carece de qualquer padronização formal reconhecida pela Ecma International, ISO/IEC, ANSI ou outras organizações de padrões de terceiros, a implementação do Oracle é o padrão de fato.

A implementação do Oracle é empacotada em duas distribuições diferentes: O Java Runtime Environment (JRE), que contém as partes da plataforma Java SE necessárias para executar programas Java e é destinado a usuários finais, e o Java Development Kit (JDK), que se destina a desenvolvedores de software e inclui ferramentas de desenvolvimento como o compilador Java, Javadoc, Jar e um depurador. A Oracle também lançou o GraalVM, um compilador e interpretador dinâmico Java de alto desempenho.

OpenJDK é outra notável implementação do Java SE licenciada sob a GNU GPL. A implementação começou quando a Sun começou a liberar o código-fonte Java sob a GPL. A partir do Java SE 7, o OpenJDK é a implementação de referência Java oficial.

O objetivo do Java é tornar todas as implementações de Java compatíveis. Historicamente, a licença de marca registrada da Sun para uso da marca Java insiste que todas as implementações sejam compatíveis. Isso resultou em uma disputa legal com a Microsoft depois que a Sun alegou que a implementação da Microsoft não suportava RMI ou JNI e havia adicionado recursos próprios específicos da plataforma. A Sun processou em 1997 e, em 2001, ganhou um acordo de US$ 20 milhões, bem como uma ordem judicial aplicando os termos da licença da Sun. Como resultado, a Microsoft não envia mais o Java com o Windows.

O Java independente de plataforma é essencial para o Java EE, e uma validação ainda mais rigorosa é necessária para certificar uma implementação. Esse ambiente permite aplicativos portáteis do lado do servidor.

Uso fora da plataforma Java

A linguagem de programação Java requer a presença de uma plataforma de software para que os programas compilados sejam executados.

A Oracle fornece a plataforma Java para uso com Java. O Android SDK é uma plataforma de software alternativa, usada principalmente para desenvolver aplicativos Android com seu próprio sistema GUI.

Android

A linguagem Java é um pilar fundamental no Android, um sistema operacional móvel de código aberto. Embora o Android, construído no kernel do Linux, seja escrito em grande parte em C, o Android SDK usa a linguagem Java como base para aplicativos Android, mas não usa nenhum de seus padrões GUI, SE, ME ou outros padrões Java estabelecidos. A linguagem bytecode suportada pelo Android SDK é incompatível com o bytecode Java e roda em sua própria máquina virtual, otimizada para dispositivos com pouca memória, como smartphones e tablets. Dependendo da versão do Android, o bytecode é interpretado pela máquina virtual Dalvik ou compilado em código nativo pelo Android Runtime.

O Android não fornece a biblioteca padrão Java SE completa, embora o Android SDK inclua uma implementação independente de um grande subconjunto dela. Suporta Java 6 e alguns recursos do Java 7, oferecendo uma implementação compatível com a biblioteca padrão (Apache Harmony).

Controvérsia

O uso de tecnologia relacionada ao Java no Android gerou uma disputa legal entre a Oracle e o Google. Em 7 de maio de 2012, um júri de São Francisco concluiu que, se as APIs pudessem ser protegidas por direitos autorais, o Google havia infringido os direitos autorais da Oracle pelo uso de Java em dispositivos Android. O juiz distrital William Alsup decidiu em 31 de maio de 2012 que as APIs não podem ser protegidas por direitos autorais, mas isso foi revertido pelo Tribunal de Apelações do Circuito Federal dos Estados Unidos em maio de 2014. Em 26 de maio de 2016, o tribunal distrital decidiu em favor do Google, decidir a violação de direitos autorais da API Java no Android constitui uso justo. Em março de 2018, essa decisão foi anulada pelo Tribunal de Apelações, que rejeitou o caso de determinação dos danos ao tribunal federal de San Francisco. O Google entrou com uma petição de writ of certiorari na Suprema Corte dos Estados Unidos em janeiro de 2019 para contestar as duas decisões proferidas pelo Tribunal de Apelações a favor da Oracle. Em 5 de abril de 2021, o Tribunal decidiu 6-2 a favor do Google, que seu uso de APIs Java deve ser considerado uso justo. No entanto, o tribunal se recusou a decidir sobre os direitos autorais das APIs, optando por determinar sua decisão considerando a API do Java passível de direitos autorais "apenas para fins de argumentação"

Trabalhos citados