Plataforma Java, Edição Standard - Java Platform, Standard Edition

Java Platform, Standard Edition ( Java SE ) é uma plataforma de computação para desenvolvimento e implantação de código portátil para ambientes de desktop e servidor . Java SE era conhecido anteriormente como Java 2 Platform, Standard Edition ( J2SE ).

A plataforma usa a linguagem de programação Java e faz parte da família de plataformas de software Java . Java SE define uma variedade de APIs de uso geral - como APIs Java para a Java Class Library - e também inclui a Especificação de linguagem Java e a Especificação de máquina virtual Java . OpenJDK é a implementação de referência oficial desde a versão 7.

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 plataformas Enterprise Edition ( Java EE ) e Micro Edition ( Java ME ). O "2" tinha a intenção original de enfatizar as principais 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 do histórico de versões do Java . Começando com J2SE 1.4 (Merlin), 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) . JSR 59 foi a especificação guarda-chuva para J2SE 1.4 e JSR 176 especificado J2SE 5.0 (Tiger). Java SE 6 (Mustang) foi lançado sob JSR 270.

Java Platform, Enterprise Edition (Java EE) é uma especificação relacionada que inclui todas as classes em Java SE, além de um número que é mais útil 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 pequenos dispositivos com recursos limitados, como telefones celulares , PDAs e decodificadores .

O Java Runtime Environment (JRE) e o Java Development Kit (JDK) são os arquivos reais baixados e instalados em um computador para executar ou desenvolver programas Java, respectivamente.

Pacotes de uso geral

java.lang

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

As principais classes e interfaces 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 Java .
Throwable - a classe que é a classe base da hierarquia de classes de exceção.
Error ,, Exception e RuntimeException - as classes básicas 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 executar manipulação de string (a StringBuilder partir do J2SE 5.0).
Comparable - a interface que permite comparação genérica e ordenação de objetos (a partir de J2SE 1.2).
Iterable - a interface que permite a iteração genérica usando o loop aprimorado for (a partir do J2SE 5.0).
ClassLoader , Process , Runtime , SecurityManager , E System - classes que fornecem "as operações do sistema" que gerem o carregamento dinâmico de aulas, criação de externos processos , inquéritos ambiente de acolhimento, tais como a hora do dia, e à execução das políticas de segurança .
Math e StrictMath - classes que fornecem funções matemáticas básicas, como seno , cosseno e raiz quadrada (a StrictMath partir de J2SE 1.3).
As classes de wrapper primitivas que encapsulam tipos primitivos como objetos .
As classes de exceção básicas lançadas para nível de linguagem e outras exceções comuns.

As aulas java.lang são importadas automaticamente para cada arquivo de origem .

java.lang.ref

O java.lang.ref pacote fornece tipos de referências mais flexíveis do que os disponíveis, permitindo interação limitada entre o aplicativo e o coletor de lixo da Java Virtual Machine (JVM) . É um pacote importante, central o suficiente para a linguagem para que os designers de linguagem dêem a ele um nome que comece com "java.lang", mas tem um propósito especial e não é usado por muitos desenvolvedores. Este pacote foi adicionado no J2SE 1.2.

Java possui um expressivo sistema de referências e permite um comportamento especial para a coleta de lixo. Uma referência normal em Java é conhecida como "referência forte". O java.lang.ref pacote define três outros tipos de referências - referências suaves, fracas e fantasmas. Cada tipo de referência é projetado para um uso específico.

A SoftReference pode ser usado para implementar um cache . Um objeto que não é alcançável por uma referência forte (ou seja, não é facilmente alcançável), mas é referenciado por uma referência flexível é chamado de "alcançável moderadamente." Um objeto facilmente alcançável pode ser o lixo coletado a critério do coletor de lixo. Isso geralmente significa que objetos facilmente alcançáveis são coletados como lixo apenas quando a memória livre é baixa - mas, novamente, isso fica a critério do coletor de lixo. Semanticamente, uma referência suave significa: "Mantenha este objeto quando nada mais fizer referência a ele, a menos que a memória seja necessária."
A WeakReference é usado 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 é o lixo coletado no próximo ciclo de coleta. Esse comportamento é usado na aula java.util.WeakHashMap . Um mapa fraco permite que o programador coloque pares de chave / valor no mapa e não se preocupe com os objetos ocupando memória quando a chave não está mais acessível em nenhum outro lugar. Outra aplicação possível de referências fracas é o pool interno de strings . Semanticamente, uma referência fraca significa "livre-se deste objeto quando nada mais fizer referência a ele na próxima coleta de lixo".
A PhantomReference é usado para fazer referência a objetos que foram marcados para coleta de lixo e foram finalizados , mas ainda não foram recuperados. Um objeto que não é fortemente, suavemente ou fracamente alcançável, mas é referenciado por uma referência fantasma é chamado de "alcançável fantasma." Isso permite uma limpeza mais flexível do que é possível com o mecanismo de finalização sozinho. Semanticamente, uma referência fantasma significa "este objeto não é mais necessário e foi finalizado na preparação para ser coletado".

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

O java.lang.ref também define a classe ReferenceQueue , que pode ser usada em cada um dos aplicativos discutidos acima para controlar os objetos que mudaram o tipo de referência. Quando um Reference é criado, ele é opcionalmente registrado com uma fila de referência. O aplicativo pesquisa a fila de referência para obter referências que mudaram o estado de acessibilidade.

java.lang.reflect

A reflexão é um componente da API Java que permite que o código Java examine e "reflita" nos componentes Java no tempo de execução e use os membros refletidos. Classes no java.lang.reflect pacote, junto com java.lang.Class e java.lang.Package acomodam aplicativos como depuradores , intérpretes , inspetores de objetos, navegadores de classe e serviços como serialização de objetos e JavaBeans que precisam de acesso aos membros públicos de um objeto de destino (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 a 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 possui 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, então, possivelmente, usar os elementos descobertos.
Usar 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 chama o Object.getClass() método para obter o do objeto Class . O Class objeto possui vários métodos para descobrir o conteúdo da classe, por exemplo:

getMethods() - retorna uma matriz de Method objetos que representam todos os métodos públicos da classe ou interface
getConstructors() - retorna uma matriz de Constructor objetos que representam todos os construtores públicos da classe
getFields() - retorna uma matriz de Field objetos que representam todos os campos públicos da classe ou interface
getClasses() - retorna uma matriz de Class objetos que representam todas as classes públicas e interfaces que são membros (por exemplo, classes internas ) da classe ou interface
getSuperclass() - retorna o Class objeto que representa a superclasse da classe ou interface ( null é retornado para interfaces)
getInterfaces() - retorna uma matriz de Class objetos que representam todas as interfaces que são implementadas pela classe ou interface

Use pelo nome

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

getMethod("methodName", Class...) - retorna o Method objeto que representa o método público com o nome "methodName" da classe ou interface que aceita os parâmetros especificados pelos Class... parâmetros.
getConstructor(Class...) - retorna o Constructor objeto que representa o construtor público da classe que aceita os parâmetros especificados pelos Class... parâmetros.
getField("fieldName") - retorna o Field objeto que representa o campo público com o nome "fieldName" da classe ou interface.

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

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

Matrizes e proxies

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

A implementação de uma Proxy classe é fornecida por um objeto fornecido que implementa a InvocationHandler interface. A InvocationHandler 's invoke(Object, Method, Object[]) método é chamado para cada método chamado no objecto-a primeiro parâmetro proxy é o objecto de proxy, o segundo parâmetro é o Method objecto que representa o método a partir da interface implementada pelo proxy, e o terceiro parâmetro é a matriz de parâmetros passados para o método de interface. O invoke() método retorna um Object resultado que contém o resultado retornado ao código que chamou o método de interface de proxy.

java.io

O java.io pacote contém classes que suportam entrada e saída . As classes do pacote são principalmente orientadas ao fluxo ; no entanto, uma classe para arquivos de acesso aleatório também é fornecida. As classes centrais do pacote são e , que são classes básicas abstratas para leitura e gravação em fluxos de bytes , respectivamente. As classes relacionadas e são classes básicas abstratas para leitura e gravação em fluxos de caracteres , respectivamente. O pacote também possui algumas classes diversas para suportar interações com o sistema de arquivos host . InputStreamOutputStreamReaderWriter

Streams

As classes de fluxo seguem o padrão do decorador , estendendo a subclasse de base para adicionar recursos às classes de fluxo. As subclasses das classes de fluxo base são normalmente nomeadas para um dos seguintes atributos:

a origem / destino dos dados de fluxo
o tipo de dados gravados / lidos no fluxo
processamento adicional ou filtragem realizada nos dados de fluxo

As subclasses de fluxo são nomeados usando o nomeando padrão XxxStreamType onde Xxx é o nome que descreve o recurso e StreamType é um dos InputStream , OutputStream , Reader , ou Writer .

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

Fonte de destino	Nome	Tipos de fluxo	Dentro / Fora	Aulas
`byte` array ( `byte[]` )	`ByteArray`	`byte`	dentro, fora	`ByteArrayInputStream` , `ByteArrayOutputStream`
`char` array ( `char[]` )	`CharArray`	`char`	dentro, fora	`CharArrayReader` , `CharArrayWriter`
Arquivo	`File`	`byte` , `char`	dentro, fora	`FileInputStream` , `FileOutputStream` , `FileReader` , `FileWriter`
string ( `StringBuffer` )	`String`	`char`	dentro, fora	`StringReader` , `StringWriter`
discussão ( `Thread` )	`Piped`	`byte` , `char`	dentro, fora	`PipedInputStream` , `PipedOutputStream` , `PipedReader` , `PipedWriter`

Outros pacotes de biblioteca padrão fornecem implementações de fluxo para outros destinos, como o InputStream retornado pelo java.net.Socket.getInputStream() método ou a javax.servlet.ServletOutputStream classe Java EE .

O tratamento e o processamento ou a filtragem do tipo de dados de dados de fluxo são realizados por meio de filtros de fluxo . Todas as classes de filtro aceitam outro objeto de fluxo compatível como um parâmetro para o construtor e decoram o fluxo fechado com recursos adicionais. Os filtros são criados, alargando uma das classes de filtro de base FilterInputStream , FilterOutputStream , FilterReader , or FilterWriter .

As classes Reader e Writer são, na verdade, apenas fluxos de bytes com processamento adicional executado no fluxo de dados para converter os bytes em caracteres. Eles usam a codificação de caracteres padrão para a plataforma, que a partir do J2SE 5.0 é representada pelo Charset retornado pelo java.nio.charset.Charset.defaultCharset() método estático. A InputStreamReader classe converte um InputStream em a Reader e a OutputStreamWriter classe converte um OutputStream em a Writer . Ambas as classes têm construtores que suportam a especificação da codificação de caracteres a ser usada. Se nenhuma codificação for especificada, o programa usará a codificação padrão para a plataforma.

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

Operação	Nome	Tipos de fluxo	Dentro / Fora	Aulas
carregando	`Buffered`	`byte` , `char`	dentro, fora	`BufferedInputStream` , `BufferedOutputStream` , `BufferedReader` , `BufferedWriter`
"push back" último valor lido	`Pushback`	`byte` , `char`	dentro	`PushbackInputStream` , `PushbackReader`
ler / escrever tipos primitivos	`Data`	`byte`	dentro, fora	`DataInputStream` , `DataOutputStream`
serialização de objetos (objetos de leitura / gravação)	`Object`	byte	dentro, fora	`ObjectInputStream` , `ObjectOutputStream`

Acesso aleatório

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

Sistema de arquivo

A File classe representa um arquivo ou caminho de diretório em um sistema de arquivos . os objetos 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 registro de data e hora da última modificação . objetos que representam diretórios podem ser usados para obter uma lista de todos os arquivos e diretórios contidos. FileFile

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

java.nio

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

java.math

O java.math pacote 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 chave criptográfica. As principais classes do pacote são:

BigDecimal - fornece números decimais assinados de precisão arbitrária. BigDecimal dá ao usuário controle sobre o comportamento de arredondamento RoundingMode .
BigInteger - fornece inteiros de precisão arbitrária. As operações ativadasBigInteger não transbordam nem perdem a precisão. Além das operações aritméticas padrão, ele fornece aritmética modular , cálculo GCD , teste de primalidade , geração de número primo , 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.

java.net

O java.net pacote fornece rotinas IO especiais para redes, permitindo solicitações HTTP , bem como outras transações comuns.

java.text

O java.text pacote implementa rotinas de análise para strings e oferece suporte a vários idiomas legíveis por humanos e análise específica de localidade.

java.util

Estruturas de dados que agregam objetos são o foco do java.util pacote. Incluída no pacote está a API de coleções , uma hierarquia de estrutura de dados organizada fortemente influenciada pelas considerações de padrões de design .

Pacotes de propósito especial

java.applet

Criado para oferecer suporte à criação de miniaplicativos Java , o java.applet pacote permite que os aplicativos sejam baixados em uma rede e executados em uma caixa de proteção protegida. As restrições de segurança são facilmente impostas na sandbox. Um desenvolvedor, por exemplo, pode aplicar uma assinatura digital a um miniaplicativo, rotulando-o como seguro. Isso permite que o usuário conceda ao miniaplicativo permissão para realizar operações restritas (como acessar o disco rígido local) e remove algumas ou todas as restrições da sandbox. Os certificados digitais são emitidos por autoridades de certificação .

java.beans

Incluídas no java.beans pacote 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 bean, na qual os beans podem ser combinados, customizados e manipulados. Um tipo de editor de bean é um designer de GUI em um ambiente de desenvolvimento integrado .

java.awt

O java.awt , ou Abstract Window Toolkit, fornece acesso a um conjunto básico de widgets GUI com base no conjunto de widgets da plataforma nativa subjacente, o núcleo do subsistema de eventos da GUI e a interface entre o sistema de janelas nativo e o aplicativo 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 de suporte. Este pacote javax.swing contém o maior número de enums (7 no total) no JDK 6.

java.rmi

O java.rmi pacote fornece chamada de método remoto Java para suportar chamadas de procedimento remoto entre dois aplicativos Java em execução em JVMs diferentes .

java.security

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

java.sql

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

javax.rmi

O javax.rmi pacote fornece o suporte para a comunicação remota entre aplicações, utilizando o protocolo RMI sobre IIOP. Este protocolo combina os recursos RMI e CORBA.

Java SE Core Technologies - CORBA / RMI-IIOP

javax.swing

Swing é uma coleção de rotinas que se baseiam java.awt para fornecer um kit de ferramentas de widget independente de plataforma . javax.swing usa as rotinas de desenho 2D para renderizar os componentes da interface do usuário em vez de depender do suporte da 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 oferece suporte a aparência conectável (PLAFs) para que os widgets na GUI pode imitar aqueles do sistema nativo subjacente. Os 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. Soluções alternativas, como o uso de fontes de bitmap, existem. Em geral, "layouts" são usados e mantêm os elementos em uma GUI esteticamente consistente em todas as plataformas.

javax.swing.text.html.parser

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

javax.xml.bind.annotation

O javax.xml.bind.annotation pacote contém o maior número de tipos de anotação (30 ao todo) no JDK 6. Ele define anotações para customizar os elementos do programa Java para mapeamento do esquema XML.

Pacotes OMG

org.omg.CORBA

O org.omg.CORBA pacote fornece o suporte para a comunicação remota entre aplicativos usando o Protocolo Inter-ORB Geral e oferece suporte a outros recursos da arquitetura do common object request broker . Da mesma forma que RMI e RMI-IIOP , este pacote é para chamar métodos remotos de objetos em outras máquinas virtuais (geralmente via rede).

Este pacote contém o maior número de Exception classes (45 no total) no JDK 6. De todas as possibilidades de comunicação, o CORBA é portátil entre vários idiomas; no entanto, com isso vem mais complexidade.

Esses pacotes foram descontinuados no Java 9 e removidos do Java 11.

org.omg.PortableInterceptor

O org.omg.PortableInterceptor pacote contém o maior número de interfaces (39 ao todo) no JDK 6. Ele fornece um mecanismo para registrar ganchos ORB por meio dos quais os serviços ORB interceptam o fluxo normal de execução do ORB.

Segurança

Várias vulnerabilidades críticas de segurança foram relatadas. Os alertas de segurança da Oracle anunciam patches essenciais relacionados à segurança para o Java SE.

Languages

In other projects