Em Java, tudo tem alguma forma de controle de acesso.
Os níveis de controle das permissões de acesso são das maiores para o mínimo: público, protegido, permissões de acesso ao pacote (sem palavras -chave) e privadas.
Quando usado, os modificadores de acesso a Java, públicos, protegidos e privados, são colocados antes da definição de cada membro (domínio ou método) na classe.
1. Direitos de acesso dos membros da classe
A única maneira de obter acesso a um membro é:
1). Tornar este membro público. Não importa quem é, o membro pode ser acessado;
2). Conceda o acesso de pacotes aos membros, desdobrando modificadores e colocando outras classes no mesmo pacote, e outras classes no pacote podem acessar o membro;
3). Aulas herdadas podem acessar membros públicos e membros protegidos.
4). Forneça métodos de acessórios e mutadores para ler e alterar valores numéricos.
1. Permissões de acesso ao pacote
A permissão de acesso padrão não possui palavras -chave, mas o passe refere -se a permissões de acesso ao pacote, o que significa que todas as outras classes do relatório atual têm acesso a esse membro, mas para todas as classes fora deste pacote, esse membro é realmente privado.
O acesso ao pacote combina todas as classes relevantes dentro do pacote para que possam interagir facilmente entre si.
Nota: Se as duas classes estiverem no mesmo diretório e não definirem nenhum nome de pacote para si, o Java considerará automaticamente os arquivos como o pacote padrão afiliado ao diretório, para que esses arquivos tenham acesso ao pacote.
O exemplo a seguir ilustra esse problema:
// classe Bolo e torta estão no mesmo diretório e não são explicitamente exibidos em nenhuma classe de pacote {void f () {System.out.println ("pie.f ()"); }} classe bolo {public static void main (string [] args) {pie x = new pie (); xf (); }} // A saída é PIE.F ()2.Public: Permissões de acesso à interface
Usar a palavra -chave Public significa que as declarações subsequentes de membros estão disponíveis para todos, especialmente programadores de clientes que usam bibliotecas de classe.
3. Private: você não pode acessá -lo
A palavra -chave privada indica que nenhuma outra classe além da classe que contém o membro não pode acessar o membro. Outras classes no mesmo pacote não podem acessar os membros privados desta classe, portanto, isso é equivalente a se isolar.
Essa função da palavra -chave privada tem muitos usos, como controlar como os objetos são criados e impedindo que outras pessoas acessem diretamente um construtor específico (ou todos os construtores). olhar
O exemplo a seguir:
classe sundae {private sundae () {} sundae estático makeasundae () {return new sundae (); }} classe pública IceCream {public static void main (string [] args) {sundae x = sundae.makeasundae (); }}Neste exemplo, podemos criar objetos Sundae chamando o método makeasundae (), mas não podemos criá -los através do construtor.
Isso também se aplica a campos privados na classe.
No entanto, uma coisa a observar é que você não pode pensar que outros objetos não podem ter referências públicas ao objeto apenas porque a referência a um objeto na classe é privada.
4. Protegido: Permissões de acesso herdador
Se um novo pacote for criado e herdar a classe a partir de outro pacote, o único membro que pode ser acessado é o membro público do pacote de origem.
Às vezes, o criador de uma classe base deseja atribuir acesso a um membro específico à classe derivada, em vez de todas as classes, o que requer a palavra -chave protegida.
Observe que o Protected também fornece acesso ao pacote, ou seja, outras classes dentro do mesmo pacote também podem acessar elementos protegidos dessa classe.
2. Interface e implementação
O controle dos direitos de acesso é frequentemente referido como oculto em implementações concretas.
Os dados e métodos de embalagem nas classes, e ocultar implementações específicas são frequentemente chamadas de encapsulamento coletivamente.
Por dois motivos importantes, o controle de permissão de acesso reside os limites das permissões dentro do tipo de dados:
1. Defina os limites que os programadores de clientes podem usar e não podem usar. Você pode estabelecer seu próprio mecanismo interno na estrutura, sem se preocupar com o fato de os programadores de clientes tratarem acidentalmente o mecanismo interno como parte da interface que eles usam.
2. Separe a interface e a implementação específica.
3. Permissões de acesso aulas
Em Java, os modificadores de acesso também podem ser usados para determinar quais classes na biblioteca estão disponíveis para o usuário da biblioteca.
Os modificadores devem ser colocados antes da classe de palavra -chave. Por exemplo:
Widget da classe pública {......} ou
melhorar o access.widget;
Você deve saber que uma classe não pode ser privada (se a classe for privada, nenhuma outra classe pode acessá -la, exceto a classe), nem pode ser protegida (de fato, uma classe interna pode ser privada ou protegida, mas esse é um caso especial, conforme descrito em artigos subsequentes) e pode ser apenas permissões de acesso ao pacote ou público.
Se você não deseja que outras pessoas acessem a classe, poderá especificar todos os construtores da classe como privados, impedindo que alguém crie objetos da classe. Mas há exceções a isso, o que não pode impedir que você crie a classe dentro do membro estático da classe. Vejamos o exemplo a seguir:
classe SOPE1 {private SOPE1 () {} public static geep1 makeoup () {// Crie um objeto usando um método estático retornar nova sopa1 (); }} classe SOP2 {private sopa2 () {} Sopa estática privada 2 ps1 = new Soup2 (); // Crie um objeto usando o modo Singleton Public Static Soup2 Access () {return ps1; } public void f () {}} public class Lunch {void testPrivate () {// SOPE1 SOPE = new Soup1; Não pode ser executado} void testsingleton () {sop2.access (). F (); }}Podemos ver que os construtores de Sope1 e Soup2 são privados e ninguém pode usar diretamente o construtor para criar objetos dessa classe. Mas também podemos usar essas duas classes: criar um método estático no SOPE1, usar o construtor para criar um objeto SOPE1 e retornar sua referência; A criação do SOPE2 usa o padrão de singleton no padrão de design e só pode criar um de seus objetos. O objeto da classe SOPE2 é criado como um membro privado estático do SOPE2, então existe apenas um e não pode ser acessado, a menos que seja acessado através do método público.
Além disso, vale a pena notar algumas limitações:
1. Cada unidade de compilação pode ter apenas uma classe pública.
2. O nome da classe pública deve corresponder exatamente ao nome do arquivo que contém a unidade de compilação, incluindo superior e inferior.
3. Se não houver classe pública na unidade de compilação, você poderá nomear o arquivo à vontade.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.