Java Platform, Standard Edition 📖 Wikipedia

Java Platform, Standard Edition (Java SE) é uma plataforma de computação, padrão técnico para execução de aplicações em plataformas independentes suportadas por Java, como código portável para ambientes desktop e servidores.^[1][2] Java SE era anteriormente conhecido como Java 2 Platform, Standard Edition (J2SE).

A plataforma utiliza a linguagem de programação Java e faz parte da família plataforma de software Java. O Java SE define um conjunto de APIs de propósito geral — como as APIs Java para a Biblioteca de Classes Java — e também inclui a Especificação da Linguagem Java e a Especificação da Máquina Virtual Java.^[3] OpenJDK é a implementação de referência oficial desde a versão 7.^[4][5][6]

A plataforma era conhecida como Java 2 Platform, Standard Edition ou J2SE a partir da versão 1.2, até que o nome foi alterado para Java Platform, Standard Edition ou Java SE na versão 1.5. O "SE" é usado para distinguir a plataforma base das edições Enterprise (Java EE) e Micro (Java ME). O "2" foi originalmente destinado a enfatizar as grandes mudanças introduzidas na versão 1.2, mas foi removido na versão 1.6. A convenção de nomenclatura foi alterada várias vezes ao longo da história de versões do Java. A partir do J2SE 1.4 (Merlin), o Java SE foi desenvolvido sob o Java Community Process, que produz descrições de especificações propostas e finais para a plataforma Java chamadas Java Specification Requests (JSR).^[7] O JSR 59 foi a especificação guarda-chuva para o J2SE 1.4 e o JSR 176 especificou o J2SE 5.0 (Tiger). O Java SE 6 (Mustang) foi lançado sob o JSR 270.

Java Platform, Enterprise Edition (Java EE) é uma especificação relacionada que inclui todas as classes do Java SE, mais várias que são mais úteis para programas executados em servidores em vez de estações de trabalho.

Java Platform, Micro Edition (Java ME) é uma especificação relacionada destinada a fornecer uma coleção certificada de APIs Java para o desenvolvimento de software para dispositivos pequenos com recursos limitados, como telefones celulares, PDAs e set-top boxes.

O Ambiente de Execução Java (JRE) e o Kit de Desenvolvimento Java (JDK) são os arquivos reais baixados e instalados em um computador para executar ou desenvolver programas Java, respectivamente.

A maioria desses pacotes é exportada pelo módulo java.base do Sistema de Módulos da Plataforma Java (desde o Java 9).

O pacote Java java.lang contém classes fundamentais e interfaces intimamente ligadas à linguagem e ao sistema de tempo de execução. Isso inclui as classes raiz que formam a hierarquia de classes, tipos ligados à definição da linguagem, exceções básicas, funções matemáticas, threads, funções de segurança, bem como algumas informações sobre o sistema nativo subjacente. Este pacote contém 22 das 32 classes java.lang.Error fornecidas no JDK 6.

As principais classes e interfaces em java.lang são:

• Object – a classe que é a raiz de toda hierarquia de classes.
• Enum – a classe base para classes de enumeração (a partir do J2SE 5.0).
• Class – a classe que é a raiz do sistema de reflexão do Java.
• Throwable – a classe que é a classe base da hierarquia de classes de exceção.
• Error, Exception e RuntimeException – as classes base para cada tipo de exceção.
• Thread – a classe que permite operações em threads.
• String – a classe para strings e literais de string.
• StringBuffer e StringBuilder – classes para realizar manipulação de strings (StringBuilder a partir do J2SE 5.0).
• Comparable – a interface que permite comparação e ordenação genérica de objetos (a partir do J2SE 1.2).
• Iterable – a interface que permite iteração genérica usando o loop for melhorado (a partir do J2SE 5.0).
• ClassLoader, Process, Runtime, SecurityManager e System – classes que fornecem "operações de sistema" que gerenciam o carregamento dinâmico de classes, criação de processos externos, consultas ao ambiente hospedeiro, como a hora do dia, e aplicação de políticas de segurança.
• Math e StrictMath – classes que fornecem funções matemáticas básicas como seno, cosseno e raiz quadrada (java.lang.StrictMath a partir do J2SE 1.3).
• As classes wrapper primitivas que encapsulam tipos primitivos como objetos.
• As classes de exceção básicas lançadas para exceções de nível de linguagem e outras comuns.

Classes em java.lang são automaticamente importadas em todos os arquivos fonte.

O pacote java.lang.ref fornece tipos mais flexíveis de referências do que os disponíveis de outra forma, permitindo interação limitada entre a aplicação e o coletor de lixo da Máquina Virtual Java (JVM). É um pacote importante, central o suficiente para a linguagem para que os projetistas da linguagem o colocassem sob o espaço de nomes java.lang, mas é um tanto específico e não usado por muitos desenvolvedores. Este pacote foi adicionado no J2SE 1.2.

Java tem um sistema expressivo de referências e permite comportamento especial para coleta de lixo. Uma referência normal em Java é conhecida como "referência forte". O pacote java.lang.ref define três outros tipos de referência — soft, fraca e phantom. Cada tipo de referência é projetado para um uso específico.

• Uma SoftReference pode ser usada para implementar um cache. Um objeto que não é alcançável por uma referência forte (ou seja, não é fortemente alcançável), mas é referenciado por uma referência soft, é chamado de "fracamente alcançável". Um objeto fracamente alcançável pode ser coletado pelo coletor de lixo a seu critério. Isso geralmente significa que objetos fracamente alcançáveis só são coletados quando a memória livre está baixa — mas novamente, isso é a critério do coletor de lixo. Semanticamente, uma referência soft significa: "Mantenha este objeto quando mais nada o referenciar, a menos que a memória seja necessária."
• Uma WeakReference é usada para implementar mapas fracos. Um objeto que não é forte ou fracamente alcançável, mas é referenciado por uma referência fraca, é chamado de "fracamente alcançável". Um objeto fracamente alcançável é coletado no próximo ciclo de coleta. Este comportamento é usado na classe WeakHashMap. Um mapa fraco permite ao programador colocar pares chave/valor no mapa e não se preocupar com os objetos ocupando memória quando a chave não for mais alcançável em nenhum outro lugar. Outra aplicação possível de referências fracas é o pool de strings internas. Semanticamente, uma referência fraca significa: "Livre-se deste objeto quando mais nada o referenciar na próxima coleta de lixo."
• Uma PhantomReference é usada para referenciar objetos que foram marcados para coleta de lixo e foram finalizados, mas ainda não foram recuperados. Um objeto que não é forte, soft ou fracamente alcançável, mas é referenciado por uma referência phantom, é chamado de "phantom alcançável". Isso permite uma limpeza mais flexível do que é possível apenas com o mecanismo de finalização. Semanticamente, uma referência phantom significa: "Este objeto não é mais necessário e foi finalizado em preparação para ser coletado."

Cada um desses tipos de referência estende a classe Reference, que fornece o método get() para retornar uma referência forte ao objeto referente (ou null se a referência foi limpa ou se o tipo de referência for phantom), e o método clear() para limpar a referência.

O java.lang.ref também define a classe ReferenceQueue, que pode ser usada em cada uma das aplicações discutidas acima para rastrear objetos que mudaram de tipo de referência. Quando uma java.lang.ref.Reference<T> é criada, ela é opcionalmente registrada com uma fila de referências. A aplicação consulta a fila de referências para obter referências que mudaram o estado de alcançabilidade.

Reflexão é um constituinte da API Java que permite que o código Java examine e "reflita" sobre componentes Java em tempo de execução e use os membros refletidos. Classes no pacote java.lang.reflect, juntamente com java.lang.Class<T> e Package, acomodam aplicações como depuradores, interpretadores, inspetores de objetos, navegadores de classes e serviços como serialização de objetos e JavaBeans que precisam acessar os membros públicos de um objeto alvo (com base em sua classe de tempo de execução) ou os membros declarados por uma determinada classe. Este pacote foi adicionado no JDK 1.1.

A reflexão é usada para instanciar classes e invocar métodos usando seus nomes, um conceito que permite programação dinâmica. Classes, interfaces, métodos, campos e construtores podem ser descobertos e usados em tempo de execução. A reflexão é suportada por metadados que a JVM tem sobre o programa.

Existem técnicas básicas envolvidas na reflexão:

• Descoberta – envolve pegar um objeto ou classe e descobrir os membros, superclasses, interfaces implementadas e, em seguida, possivelmente usar os elementos descobertos.
• Uso por nome – envolve começar com o nome simbólico de um elemento e usar o elemento nomeado.

A descoberta normalmente começa com um objeto e chamando o método getClass() para obter o java.lang.Class<?> do objeto. O objeto java.lang.Class<T> tem vários métodos para descobrir o conteúdo da classe, por exemplo:

• getMethods() – retorna um array de objetos Method representando todos os métodos públicos da classe ou interface
• getConstructors() – retorna um array de objetos Constructor representando todos os construtores públicos da classe
• getFields() – retorna um array de objetos Field representando todos os campos públicos da classe ou interface
• getClasses() – retorna um array de objetos java.lang.Class<?>[] representando todas as classes e interfaces públicas que são membros (por exemplo, classes internas) da classe ou interface
• getSuperclass() – retorna o objeto java.lang.Class<? super T> representando a superclasse da classe ou interface (null é retornado para interfaces)
• getInterfaces() – retorna um java.lang.Class<?>[] representando todas as interfaces que são implementadas pela classe ou interface

O objeto java.lang.Class<T> pode ser obtido através de descoberta, usando o literal de classe (por exemplo, X.class, para uma classe X) ou usando o nome da classe (por exemplo, Class.forName("mypackage.MyClass")). Com um objeto java.lang.Class<T>, objetos membro Method, Constructor<T> ou Field podem ser obtidos usando o nome simbólico do membro. Por exemplo:

• getMethod(String name, Class<?>... parameterTypes) – retorna o objeto Method representando o método público com o nome name da classe ou interface que aceita os parâmetros especificados pelos parâmetros java.lang.Class<?>....
• getConstructor(Class<?>... parameterTypes) – retorna o objeto Constructor<T> representando o construtor público da classe que aceita os parâmetros especificados pelos parâmetros java.lang.Class<?>....
• getField(String name) – retorna o objeto Field representando o campo público com o nome name da classe ou interface.

Os objetos Method, Constructor<T> e Field podem ser usados para acessar dinamicamente o membro representado da classe. Por exemplo:

• Field.get(Object obj) – retorna um java.lang.Object contendo o valor do campo da instância do objeto passado para get(). (Se o objeto Field representar um campo estático, o parâmetro java.lang.Object é ignorado e pode ser null.)
• Method.invoke(Object obj, Object... args) – retorna um java.lang.Object contendo o resultado da invocação do método para a instância do primeiro parâmetro java.lang.Object passado para invoke(). Os parâmetros restantes java.lang.Object... são passados para o método. (Se o objeto Method representar um método estático, o primeiro parâmetro java.lang.Object é ignorado e pode ser null.)
• Constructor.newInstance(Object... initargs) – retorna a nova instância java.lang.Object da invocação do construtor. Os parâmetros java.lang.Object... são passados para o construtor. (Note que o construtor sem parâmetros de uma classe também pode ser invocado chamando newInstance().)

O pacote java.lang.reflect também fornece uma classe Array que contém métodos estáticos para criar e manipular objetos array, e desde o J2SE 1.3, uma classe Proxy que suporta criação dinâmica de classes proxy que implementam interfaces especificadas.

A implementação de uma classe Proxy é fornecida por um objeto fornecido que implementa a interface InvocationHandler. O método invoke(Object proxy, Method method, Object[] args) do InvocationHandler é chamado para cada método invocado no objeto proxy — o primeiro parâmetro é o objeto proxy, o segundo parâmetro é o objeto Method representando o método da interface implementada pelo proxy, e o terceiro parâmetro é o array de parâmetros passados para o método da interface. O método invoke() retorna um resultado java.lang.Object que contém o resultado retornado ao código que chamou o método da interface proxy.

O pacote java.io contém classes que suportam entrada e saída. As classes no pacote são primariamente orientadas a stream; no entanto, uma classe para acesso aleatório a arquivos também é fornecida. As classes centrais no pacote são InputStream e OutputStream, que são classes base abstratas para ler de e escrever para streams de bytes, respectivamente. As classes relacionadas Reader e Writer são classes base abstratas para ler de e escrever para streams de caracteres, respectivamente. O pacote também tem algumas classes diversas para suportar interações com o sistema de arquivos hospedeiro.

As classes de stream seguem o padrão decorator estendendo a subclasse base para adicionar recursos às classes de stream. As subclasses das classes de stream base são tipicamente nomeadas para um dos seguintes atributos:

• a fonte/destino dos dados do stream
• o tipo de dados escritos/lidos do stream
• processamento ou filtragem adicional realizado nos dados do stream

As subclasses de stream são nomeadas usando o padrão de nomenclatura XxxStreamType onde Xxx é o nome que descreve o recurso e StreamType é um de InputStream, OutputStream, Reader ou Writer.

A tabela a seguir mostra as fontes/destinos suportados diretamente pelo pacote java.io:

Outras bibliotecas padrão fornecem implementações de stream para outros destinos, como o InputStream retornado pelo método getInputStream() de java.net.Socket ou a classe Java EE ServletOutputStream.

O tratamento de tipos de dados e processamento ou filtragem de dados de stream é realizado através de filtros de stream. As classes de filtro aceitam outro objeto de stream compatível como parâmetro para o construtor e decoram o stream encapsulado com recursos adicionais. Filtros são criados estendendo uma das classes de filtro base FilterInputStream, FilterOutputStream, FilterReader ou FilterWriter.

As classes Reader e Writer são realmente apenas streams de bytes com processamento adicional realizado no stream de dados para converter os bytes em caracteres. Elas usam a codificação de caracteres padrão para a plataforma, que a partir do J2SE 5.0 é representada pelo Charset retornado pelo método estático defaultCharset(). A classe InputStreamReader converte um InputStream em um Reader e a classe OutputStreamWriter converte um OutputStream em um Writer. Ambas as classes têm construtores que suportam especificar a codificação de caracteres a ser usada. Se nenhuma codificação for especificada, o programa usa a codificação padrão para a plataforma.

A tabela a seguir mostra os outros processos e filtros que o pacote java.io suporta diretamente. Todas essas classes estendem a classe FilterInputStream correspondente.

A classe RandomAccessFile suporta leitura e escrita de acesso aleatório de arquivos. A classe usa um ponteiro de arquivo que representa um deslocamento em bytes dentro do arquivo para a próxima operação de leitura ou escrita. O ponteiro de arquivo é movido implicitamente pela leitura ou escrita e explicitamente chamando os métodos seek(long) ou skipBytes(int). A posição atual do ponteiro de arquivo é retornada pelo método getFilePointer().

A classe File representa um caminho de arquivo ou diretório em um sistema de arquivos. Objetos File suportam a criação, exclusão e renomeação de arquivos e diretórios e a manipulação de atributos de arquivo como somente leitura e timestamp da última modificação. Objetos File que representam diretórios podem ser usados para obter uma lista de todos os arquivos e diretórios contidos.

A classe FileDescriptor é um descritor de arquivo que representa uma fonte ou sumidouro (destino) de bytes. Tipicamente, isso é um arquivo, mas também pode ser um console ou soquete de rede. Objetos FileDescriptor são usados para criar streams File. Eles são obtidos de streams File e soquetes e soquetes de datagrama java.net.

No J2SE 1.4, o pacote java.nio (NIO ou Non-blocking I/O) foi adicionado para suportar E/S mapeada em memória, facilitando operações de E/S mais próximas ao hardware subjacente com desempenho às vezes dramaticamente melhor. O pacote java.nio fornece suporte para vários tipos de buffer. O subpacote java.nio.charset fornece suporte para diferentes codificações de caracteres para dados de caracteres. O subpacote java.nio.channels fornece suporte para canais, que representam conexões a entidades capazes de realizar operações de E/S, como arquivos e soquetes. O pacote java.nio.channels também fornece suporte para bloqueio fino de arquivos.

O pacote java.math suporta aritmética multiprecisão (incluindo operações aritméticas modulares) e fornece geradores de números primos multiprecisão usados para geração de chaves criptográficas. As principais classes do pacote são:

• BigDecimal – fornece números decimais com sinal de precisão arbitrária. BigDecimal dá ao usuário controle sobre o comportamento de arredondamento através de RoundingMode.
• BigInteger – fornece inteiros de precisão arbitrária. Operações em BigInteger não estouram nem perdem precisão. Além das operações aritméticas padrão, fornece aritmética modular, cálculo de MDC, teste de primalidade, geração de números primos, manipulação de bits e outras operações diversas.
• MathContext – encapsula as configurações de contexto que descrevem certas regras para operadores numéricos.
• RoundingMode – uma enumeração que fornece oito comportamentos de arredondamento.

O pacote java.net fornece rotinas especiais de E/S para redes, permitindo requisições HTTP, bem como outras transações comuns.

O pacote java.text implementa rotinas de análise sintática para strings e suporta várias linguagens legíveis por humanos e análise específica de localidade.

Estruturas de dados que agregam objetos são o foco do pacote java.util. Incluído no pacote está a API de Coleções, uma hierarquia de estruturas de dados organizada fortemente influenciada por considerações de padrões de projeto.

Criado para suportar a criação de applets Java, o pacote java.applet permite que aplicações sejam baixadas através de uma rede e executadas dentro de uma sandbox vigiada. Restrições de segurança são facilmente impostas à sandbox. Um desenvolvedor, por exemplo, pode aplicar uma assinatura digital a um applet, rotulando-o como seguro. Isso permite que o usuário conceda permissão ao applet para realizar operações restritas (como acessar o disco rígido local) e remove algumas ou todas as restrições da sandbox. Certificados digitais são emitidos por autoridades certificadoras.

Como os applets Java estão agora obsoletos, este pacote está obsoleto.

Incluído no pacote java.beans estão várias classes para desenvolver e manipular beans, componentes reutilizáveis definidos pela arquitetura JavaBeans. A arquitetura fornece mecanismos para manipular propriedades de componentes e disparar eventos quando essas propriedades mudam.

As APIs em java.beans são destinadas ao uso por uma ferramenta de edição de beans, na qual beans podem ser combinados, personalizados e manipulados. Um tipo de editor de bean é um designer de GUI em um ambiente de desenvolvimento integrado.

O pacote java.awt, ou Abstract Window Toolkit, fornece acesso a um conjunto básico de widgets GUI baseados no conjunto de widgets da plataforma nativa subjacente, o núcleo do subsistema de eventos GUI e a interface entre o sistema de janelas nativo e a aplicação Java. Ele também fornece vários gerenciadores de layout básicos, um pacote de transferência de dados para uso com a Área de Transferência e Arrastar e Soltar, a interface para dispositivos de entrada como mouses e teclados, bem como acesso à bandeja do sistema em sistemas compatíveis. Este pacote, juntamente com javax.swing, contém o maior número de enums (7 no total) no JDK 6.

O pacote java.rmi fornece invocação de método remoto Java para suportar chamadas de procedimento remoto entre duas aplicações Java executando em diferentes JVMs.

Suporte para segurança, incluindo o algoritmo de resumo de mensagem, está incluído no pacote java.security.

Uma implementação da API JDBC (usada para acessar bancos de dados SQL) está agrupada no pacote java.sql.

O pacote javax.rmi fornecia suporte para a comunicação remota entre aplicações, usando o protocolo RMI sobre IIOP. Este protocolo combina características do RMI e do CORBA.

Java SE Core Technologies - CORBA / RMI-IIOP

Swing é uma coleção de rotinas que se baseiam no java.awt para fornecer um widget toolkit independente de plataforma. O pacote javax.swing usa as rotinas de desenho 2D para renderizar os componentes da interface do usuário em vez de depender do suporte GUI do sistema operacional nativo subjacente.

Este pacote contém o maior número de classes (133 no total) no JDK 6. Este pacote, juntamente com java.awt, também contém o maior número de enums (7 no total) no JDK 6. Ele suporta aparências plugáveis (PLAFs) para que os widgets na GUI possam imitar aqueles do sistema nativo subjacente. Padrões de projeto permeiam o sistema, especialmente uma modificação do padrão modelo–visão–controlador, que afrouxa o acoplamento entre função e aparência. Uma inconsistência é que (a partir do J2SE 1.3) as fontes são desenhadas pelo sistema nativo subjacente, e não pelo Java, limitando a portabilidade do texto. Existem soluções alternativas, como o uso de fontes bitmap. Em geral, "layouts" são usados e mantêm os elementos dentro de uma GUI esteticamente consistente entre plataformas.

O pacote javax.swing.text.html.parser fornece o analisador HTML tolerante a erros que é usado para escrever vários navegadores web e bots web.

O pacote javax.xml.bind.annotation continha o maior número de Tipos de Anotação (30 no total) no JDK 6. Ele define anotações para personalizar elementos de programa Java para mapeamento de esquema XML.

Java contém pacotes para utilitários do World Wide Web Consortium (principalmente XML) sob o espaço de nomes org.w3c. Muitos deles existem no módulo java.xml.

Os pacotes org.w3c.dom fornecem interfaces para o Document Object Model (DOM).

Os pacotes org.xml.sax fornecem interfaces para o Simple API for XML (SAX).

O pacote org.omg.CORBA fornecia suporte para a comunicação remota entre aplicações usando o General Inter-ORB Protocol e suporta outros recursos da arquitetura de broker de objetos comuns. Assim como o RMI e o RMI-IIOP, este pacote é para chamar métodos remotos de objetos em outras máquinas virtuais (geralmente via rede).

Este pacote continha o maior número de classes java.lang.Exception (45 no total) no JDK 6. De todas as possibilidades de comunicação, o CORBA é portável entre várias linguagens; no entanto, isso traz mais complexidade.

Esses pacotes foram descontinuados no Java 9 e removidos do Java 11.^[8]

O pacote org.omg.PortableInterceptor continha o maior número de interfaces (39 no total) no JDK 6. Ele fornece um mecanismo para registrar hooks ORB através dos quais os serviços ORB interceptam o fluxo normal de execução do ORB.

Várias vulnerabilidades críticas de segurança foram relatadas.^[9][10] Alertas de segurança da Oracle anunciam correções críticas de segurança relacionadas ao Java SE.^[11]

• Oracle Technology Network's Java SE
• Documentação da API Java SE
• Documentação da API Java SE (antiga)
• JSR 270 (Java SE 6)
• 1.8
• 1.7
• 1.6