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. 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. OpenJDK é a implementação de referência oficial desde a versão 7.Moving to OpenJDK as the official Java SE 7 Reference ImplementationJava Platform, Standard Edition 7 Reference Implementations
Nomenclatura, padrões e especificações 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). 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.
Pacotes de propósito geral A maioria desses pacotes é exportada pelo módulo java.base do Sistema de Módulos da Plataforma Java (desde o Java 9).
java.lang 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.
java.lang.ref 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.
java.lang.reflect 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.
Técnicas 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.
Descoberta 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
Uso por nome 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.)