Nomeação do pacote
Os nomes dos pacotes devem evitar conflitos com outros pacotes, portanto, escolher um nome significativo e único é um aspecto importante do design de pacotes. No entanto, programadores em todo o mundo estão desenvolvendo pacotes, e não há como saber quem usou qual nome de pacote, portanto, escolher o único nome do pacote é um problema. Se determinarmos que um pacote é usado apenas em nossa organização, podemos ter um árbitro interno para garantir que não haja conflitos de nome entre projetos.
Mas para o mundo inteiro, essa abordagem não é prática. Os identificadores de pacotes são todos nomes simples e uma maneira melhor de garantir que o nome do pacote seja usar um nome de domínio da Internet. Se a empresa em que estamos trabalhando é Magic.LNC e o nome de domínio da empresa é Magic C.com, a declaração do pacote de atributos deve ser:
pacote com.magic.attr; Observe que os elementos constituintes do nome de domínio aqui são organizados na ordem inversa do nome de domínio convencional.
Se adotarmos esse idioma, os nomes de pacotes que usamos não entrarão em conflito com a de mais ninguém, exceto o possível conflito em nossa organização. Se houver de fato um conflito em nossa organização (provavelmente uma grande empresa), podemos usar nomes de domínio mais específicos para se qualificarem ainda mais. Muitas grandes empresas têm subdomínios internos, como o Oriente e a Europa, que podem ser usados para qualificar ainda mais o nome do pacote:
pacote milho.magic.japan.attr;
O uso dessa solução pode tornar o nome do pacote muito longo, mas é relativamente seguro. Os programadores que usam essa técnica não escolherão o mesmo nome do pacote, e os programadores que não usam essa técnica não escolherão o nome que usamos.
Acesso ao pacote
Ao declarar a acessibilidade de classes de nível superior e interfaces de nível superior em pacotes, existem duas opções: acesso ao pacote (pacote) e acesso público (público). Aulas ou interfaces modificadas com o público podem ser acessadas por código fora da embalagem, enquanto os tipos não decorados com o público têm escopo de embalagem: eles podem ser acessados por outros códigos no mesmo pacote; Mas eles estão ocultos para códigos de pacote, mesmo em códigos de subpackagem. Ao declarar tipos, devemos declarar apenas esses tipos que outros programadores precisam usar como público e ocultar os tipos que pertencem aos detalhes da implementação do pacote. Essa tecnologia nos fornece grande flexibilidade e, como os programadores não confiam nesses tipos de detalhes de implementação que eles não podem acessar, podemos alterá -los livremente quando queremos alterar os detalhes da implementação.
Os membros da classe que não são declarados como públicos, protegidos ou privados podem ser acessados diretamente por qualquer código dentro do pacote, mas estão ocultos de fora do pacote. Em outras palavras, o modificador de acesso padrão é o "pacote", com exceção dos membros da interface, e seu modificador de acesso padrão é "público".
Campos ou métodos que não são declarados privados dentro de um pacote podem ser acessados por todos os outros códigos nesse pacote; portanto, as classes no mesmo pacote são consideradas "amigáveis" ou "confiáveis". Isso nos permite definir uma estrutura de aplicativo que combina código predefinido e código de espaço reservado, onde o código do espaço reservado é substituído por uma subclasse da classe Framework. Os códigos predefinidos podem usar modificadores de acesso ao pacote para que outros códigos colaborativos no pacote possam acessá-los diretamente, mas para usuários fora da embalagem, esses códigos são inacessíveis. No entanto, as subpackagens dos pacotes onde esses códigos estão localizados não são confiáveis e vice -versa. Por exemplo, o código modificado com o modificador de acesso ao pacote no pacote DIT não pode ser acessado pelo código em seu pacote filho Dit.dat e vice -versa.
Portanto, cada tipo define três contratos diferentes:
Acessibilidade e método de cobertura
Somente métodos acessíveis em superclasses podem ser substituídos em subclasses. Se um método na superclasse não puder ser acessado, o método não poderá ser substituído na subclasse, mesmo que o método na subclasse tenha o mesmo nome que o método. Quando um método é chamado em tempo de execução, o sistema considera sua acessibilidade e, portanto, determina qual implementação está em execução.
O seguinte exemplo especialmente construído é explicado com mais clareza. Suponha que declaremos uma classe de base abstrata no pacote P1:
Pacote P1; {AbA abA abab public abstract classe abstratebase private void Pri () {print ("stractbase.pri ()"):} void Pac () {print ("stractbase.pac ()");} nav. show () PRI (); Pac (); pró(); pub(); }}Nesta classe, definimos 4 métodos, cada um com um modificador de acesso diferente, e o corpo do método apenas se identifica. O método mostra que chama esses 4 métodos no objeto atual, por sua vez. Ao aplicar esse método a diferentes objetos de subclasse, ele pode explicar qual implementação desses métodos é chamada.
Agora, definimos o concreto de classe, que estende a classe AbstractBase, mas está localizado no pacote P2:
Pacote P2; Importar P1.ABStractBase Public Class Concretel estende abstratoBase {public void Pri () {print ("concretel.pri ()");} public void Pac () {print ("concretel.pac ()");} public void proid () {Print ("concretel.pro ()");}; }Os 4 métodos na superclasse são redeclarados nesta classe e suas implementações são alteradas, que estão relatando que pertencem à classe Con-Cretel. Ao mesmo tempo, seus direitos de acesso foram alterados para o público para outro código para acessar. Executar o seguinte código
novo concreto (). Show ():
A seguinte saída será gerada:
AbstractBase.pri () abstractBase.pac () concretel.pro () concretel.pub ()
Como o método privado PRI não pode ser acessado por subclasses (ou outras classes), o método Show sempre chama a implementação do método PRI na classe AbstractBase. O método PAC com permissões de acesso ao pacote na classe AbstractBase não pode ser acessado pelo Concretel; portanto, a implementação do método PAC na classe concretel não pode substituir a definição na classe AbstractBase, portanto, o método de show chama o método abstractBase.pac. O método Pro e o método do pub são acessíveis na classe de concretel e também podem ser substituídos; portanto, o método do show chama a implementação desses dois métodos na classe de concretel.
Siga nosso pé, que significa classe concreto2 para estender o concreto de classe e, em seguida, colocamos -o no mesmo pacote P1 que a classe abstrataBase ':
Pacote P1; Importar p2.Concretel public class concrete2 estende concretel {public void Pri () {print ("concreto2.Pri ()");} public void Pac () {print ("concreto2.pac ()");} public void proid () {print ("concreto2.pro ()");} n);Como os métodos no concreto têm direitos de acesso público, eles podem ser acessados no concreto2 e cada método no concreto2 cobre seus métodos correspondentes separadamente. Além disso, como o concreto2 e o abstratoBase estão no mesmo pacote, o método abstratebase.pac também pode ser acessado no concreto2 e o método concreto2.pac pode ser substituído. Ligue para o método Show no objeto Concrete2, e o resultado da impressão é o seguinte:
AbstractBase.pri () concreto2.pac () concreto2.pro () concreto2.pub ()
Finalmente, definimos o concreto de classe 3 para estender o concreto da classe e colocá -lo no pacote P3:
pacote p3 importar p1.Concrete2; public class concrete3 estende concreto2 {public void Pri () {print ("concreto3.Pri ()");} public void Pac q {print ("concreto3.pac ()");} public void pro ("Print3.p (" concreto3.Pro () ");} vazio público» {) {" O resultado da impressão é o seguinte: AbstractBase.pri () concreto3.pac () concrete3.pro () concrete3.pub ()Aqui, o método concreto3.PAC parece substituir o método inacessível abstractBase.pac, mas, de fato, o método concreto3.pac substitui o método concreto2.pac e o método concreto2.pac substituem o método abstrateBase.pac, portanto, o método concreto3.pac substitui indiretamente o método abstractas.pac. Ao redigir o método PAC na classe concreto2 como tendo permissões de acesso público, ele pode ser acessado e substituído por qualquer subclasse. '