Conteúdo do pacote
O conteúdo do pacote deve ser cuidadosamente projetado para que eles incluam apenas classes e interfaces funcionalmente relevantes. As aulas no pacote podem acessar livremente membros não privados de outras classes no pacote, e algumas classes podem até ter permissões suficientes para acessar detalhes internos de outras classes. Para evitar essas classes de misopelar os alunos, precisamos proteger os alunos da classe. Qualquer membro não declarado como privado pode ser acessado por todos os outros tipos no mesmo pacote; portanto, qualquer aula não relacionada pode ter mais probabilidade de ser mais coordenada do que esperávamos.
Os pacotes também fornecem agrupamento lógico para programadores que procuram interfaces e classes úteis. Os pacotes compostos por classes irrelevantes dificultam os programadores de que interfaces e classes são úteis, e o agrupamento lógico de classes pode ajudar os programadores a reutilizar o código porque os programadores podem encontrar o que precisam mais facilmente através do agrupamento lógico. Se o pacote contiver apenas conjuntos de tipos relacionados e bem acoplados, significa que podemos dar ao tipo alguns nomes mais intuitivos para evitar conflitos de nome.
Os pacotes podem ser aninhados. Por exemplo, Java.lang é um pacote aninhado em que o pacote Lang é aninhado em um pacote maior, enquanto o pacote J Ava também contém alguns outros pacotes. O ninho faz com que os pacotes relacionados formem um sistema de nomenclatura com estrutura hierárquica.
Por exemplo, para criar um conjunto de pacotes para sistemas adaptativos, como redes neurais e algoritmos genéticos, podemos nomear pacotes com nomes separados por pontos para criar pacotes aninhados:
pacote adaptativo. rede neural;
O arquivo de origem que contém a declaração de declaração acima está localizado no pacote Adaptive.NururalNet, e o pacote Adaptive.NururalNet em si é uma subpackagem do pacote adaptativo. O pacote adaptativo pode conter algumas classes relacionadas a algoritmos adaptativos gerais, como classes de declaração de problemas de generalização ou classes de referência. Os pacotes que estão em uma posição mais profunda na hierarquia (por exemplo, adaptativa.neu-ralnet ou adaptativa.genética) contêm classes relacionadas a um tipo específico de algoritmo adaptativo.
O ninho de pacotes é apenas uma ferramenta para organizar pacotes relacionados e não fornece direitos de acesso especial entre os pacotes.
O código de classe no pacote Adaptive.Genetic não pode acessar os membros no pacote adaptativo ou adaptativo.EuralNet que possuem direitos de acesso ao pacote, e o escopo do pacote é aplicável apenas a pacotes específicos. O ninho de pacotes pode agrupar pacotes relevantes e ajudar os programadores a encontrar a classe desejada no nível lógico de maneira mais conveniente, mas além disso, não traz outros benefícios.
Notas do pacote
O pacote também pode ter anotações. Mas o problema é que, como os pacotes são uma estrutura organizacional e não possuem entidades de código -fonte e elas não têm definição real, elas não podem ser anotadas como classes ou métodos. Portanto, a anotação do pacote só pode ser alcançada anotando a declaração de declaração do pacote no arquivo de origem. No entanto, pode haver apenas uma declaração de pacote em cada pacote que pode ter anotações que agem sobre ele.
Então, como você anota pacotes? De fato, o Java não força os programadores a usar uma maneira de lidar com a regra de "declaração de pacote anotada única". A maneira recomendada é criar um arquivo chamado Package-i Nfo.java no diretório de pacotes, no qual apenas as instruções do pacote e as anotações do pacote são armazenadas sem colocar mais nada. Por exemplo, o arquivo do pacote info.java para o pacote ATTL se parece com o seguinte:
@Packagespec (nome dois "att Project", versão = "1.0" @Developmentmentsite ("Atttr.Project.org") @DevelopmentModel ("Open-Source") pacote de pacote;PackagesPec, Developmentsite e Desenvolvimento OpmentModel são usados para modificar os tipos de anotação. Obviamente, eles têm estratégias de economia de tempo de execução. O arquivo package-info.java deve ser compilado com outros arquivos de origem no pacote.
Recomendamos colocar todas as informações relacionadas ao pacote no arquivo package-info.java. Se você fizer isso, poderá colocar os comentários do documento no início do arquivo, para que esses documentos sejam anotados como documentos do pacote.
Objetos e especificações do pacote
Os pacotes geralmente implementam algumas especificações e geralmente são de uma organização. Os objetos do pacote são diferentes de outros tipos de reflexão e não podem ser usados para criar ou operar pacotes, mas só podem servir como base de conhecimento para fornecer informações, que fornecem informações sobre as especificações implementadas pelo pacote (o título, o fornecedor e o número da versão da especificação) e informações sobre a implementação do pacote (o título, o fornecedor e o número da versão do pacote). Embora os pacotes geralmente venham de organizações individuais, as especificações que ele implementa (como bibliotecas de análise estatística) podem ser definidas por outras organizações. Os programas que usam pacotes podem precisar conhecer a versão da especificação implementada pelo pacote, para que as funções definidas apenas em uma determinada versão possam ser usadas. Da mesma forma, esses programas também podem precisar saber qual versão de implementação é fornecida, principalmente para lidar com possíveis falhas em diferentes versões. Alguns dos principais métodos da classe do pacote permitem o acesso a essas informações:
Por exemplo, se você extrair essas informações do pacote java.lang em nosso sistema, obterá os seguintes resultados: '
Título da Especificação: Java Plataforma API Especificação Especificação Versão: 1.4 Specification Fornecedor: Sun Microsystems, Inc. Título da implementação: Java Runtime Environment Implementation Versão: 1.5.0_02 Fornecedor de implementação: Sun Microsystems, Inc.
O número da versão canônica consiste em números não negativos separados por delimitadores de período, como '' 2.0 '' ou '11 .0.12 '. Esse padrão nos permite chamar o método ISCompatiblewith para comparar o número da versão que segue esse padrão com o número da versão do pacote. Se o número da versão do pacote for maior ou igual ao número da versão do sucessor, o método retornará true. Essa comparação compara apenas um número separado pelo período por vez. Se algum desses números for menor que a posição correspondente no número da versão passada, as duas versões serão incompatíveis. Se um dos números da versão for mais longo que o outro, a parte que falta nos números da versão curta será considerada zero. Por exemplo, se o número da versão canônica do pacote for "1.4" e nós o comparamos com "1.2", "1.3.1 '. Ou" .1.81., Então true será retornado; mas se comparado com "1.4.2 '. ou" .5 ", false será retornado. Essa conclusão é tirada porque esse mecanismo de comparação assume que a versão de especificação é compatível com versões anteriores.
Não existe um formato especificado para o número da versão de implementação, porque diferentes organizações que fornecem a implementação definirão a versão de implementação de maneira diferente. A única comparação que pode ser feita entre as versões de implementação é testar se a versão é a mesma, onde não há suposição de compatibilidade com versões anteriores.
O pacote pode ser selado, o que significa que as classes não podem mais ser adicionadas ao pacote. Pacotes não selados podem conter classes de vários locais diferentes no caminho de pesquisa de classe, enquanto o conteúdo do pacote selado deve vir do mesmo local - um arquivo específico ou um local especificado por um URL. Existem duas maneiras de determinar se um pacote está selado:
.public boolean emitido P: Retorne Trueo se o pacote for selado
.Public boolean emitido (URL URL): retorne true se o pacote for selado para o URL fornecido, ou seja, as classes do pacote podem ser carregadas a partir deste URL fornecido. Se a classe no pacote não puder ser carregada a partir da URL fornecida, ou o pacote não for selado, False será retornado e as informações de especificação e implementação do pacote geralmente são fornecidas como parte do arquivo de manifesto armazenado com o pacote - por exemplo, como parte do arquivo manifesto em um arquivo Java (JAR), como descrito na seção 25.9.2, “Arquivo Arquivo Quando uma aula em um pacote é carregada, essas informações são lidas pela pessoa. Um carregador de classe pode definir dinamicamente um objeto de pacote para a classe que deseja carregar:
Podemos chamar o método getPackage do objeto de classe da classe fornecida para obter o objeto de pacote desta classe. Também podemos ligar para o pacote estático. Ambos os métodos estão relacionados ao carregador de classe que chama seu código, porque esses códigos chamarão os métodos Get-Package ou GetPackages do carregador de classe. Os métodos de carregadores de classe procurarão um carregador de classe específico e todos os seus carregadores de classe pai e, se nenhuma configuração for feita para o carregador de classe atual, o carregador de classe do sistema será usado no momento. Observe que, se o pacote for desconhecido, o método do carregador de classe retornará nulo porque nenhum tipo no pacote foi carregado no momento.