Modificadores de acesso em Java
Modificadores de acesso em Java
Esta seção fornece uma visão profunda dos modificadores de acesso em Java. Você obteria uma descrição detalhada de cada modificador demonstrado por um exemplo que ilustra a funcionalidade de cada modificador de acesso.
Modificador de acesso público
Como o nome do modificador sugere, é menos seguro e as classes, métodos e instâncias declaradas usando palavras -chave públicas têm as seguintes opções de acessibilidade:
- Eles podem ser acessados dentro do pacote/classe, fora do pacote/classe
Exemplo
pacote newpack;Acesso de classe pública
Public Void Show ()
Sistema.fora.println ("Bem -vindo ao Linuxhint!");
O código escrito acima tem a seguinte descrição:
- Uma aula pública e um método público é declarado que contém uma instrução LINE PRIMA.
A imagem do código é fornecida aqui:
O método de classe nomeado mostrar No código acima é chamado na segunda classe, como mostrado abaixo:
mod de pacote;importar newpack.*;
classe accessm
public static void main (string args [])
AccessMod obj = new AccessMod ();
obj.mostrar();
O código é descrito abaixo
- o nome do pacote newpack da classe é importada
- um objeto da classe AccessMod (classe que reside no pacote nomeado newpack) é criado
A imagem do código e saída é mostrada abaixo:
Na saída acima, conclui -se que os modificadores de acesso público podem acessar os objetos de uma classe que está fora dessa classe e pacote também.
Modificador de acesso privado
Ao contrário da classe pública, métodos/varibalas privados podem ser acessados apenas dentro da classe. Métodos/variáveis privados não podem ser acessados:
- fora do pacote
- dentro do pacote (mas fora da classe)
Exemplo 1: Fora do pacote
pacote newpack;Acesso de classe
Show de Void Private ()
Sistema.fora.println ("linuxhint!");
A descrição do código é fornecida abaixo:
- O método de show é declarado com um modificador privado
Agora, o código a seguir tenta executar o método de show do AccessMod aula.
mod de pacote;importar newpack.*;
classe accessm
public static void Main (String Argos [])
AccessMod obj = new AccessMod ();
obj.mostrar();
Uma nova classe chamada Accesm é criada no pacote mod. O newpack O pacote é importado neste pacote, pois precisamos criar um objeto da classe nomeado AccessMod (que reside em Newpack's aula).
Fica claro na saída que o AccessMod e os objetos associados não puderam ser acessados fora do pacote.
Exemplo: fora da classe (mesmo pacote)
pacote lh;classe Prim
private void pvt ()
Sistema.fora.println ("linuxhint");
O código é descrito como,
- uma aula chamada prim é criado em LH pacote. O prim A classe contém um método privado nomeado Pvt.
Agora, para verificar o modificador de acesso privado, o código fornecido abaixo é usado.
pacote lh;classe Second
public static void main (string [] main)
Prim OBJ = novo prim ();
obj.pvt ();
O pacote de ambas as classes é o mesmo, mas a classe chamada Second tenta criar um objeto de Pvt (). O PVT () é um método em prim aula.
É observado da saída que, pvt () O método não pode ser acessado devido ao seu modificador de acesso privado.
Modificador de acesso padrão
Os membros dos dados declarados usando palavras -chave padrão estão acessíveis apenas no mesmo pacote. Ele se enquadra entre modificadores de acesso privados e protegidos e, portanto, é mais seguro do que protegido e menos seguro do que o privado.
Exemplo 1: fora do pacote
pacote newpack;classe def
estático void main (string [] args)
Sistema.fora.println ("uma classe padrão");
A descrição do código é a seguinte,
- Uma classe padrão é criada chamada Def e contém o método principal
- Uma instrução da linha de impressão é executada dentro do método principal
Para testar a acessibilidade da classe padrão, as seguintes linhas de código são usadas.
pacote lh;importar newpack.*;
classe Deft
estático void main (string [] args)
Def test = new def ();
teste.principal();
O código é descrito como,
- importou o pacote nomeado newpack
- criou uma nova classe hábil
- criou um objeto da classe Def no método principal do hábil aula
A saída mostra que a acessibilidade do Def A classe deve ser alterada para o público para ser acessado em uma classe de outros pacotes.
Exemplo 2: Fora da aula (dentro do mesmo pacote)
O código a seguir cria um método padrão para uma classe nomeada prim.
pacote lh;classe Prim
Void Pub ()
Sistema.fora.println ("modificador de acesso padrão");
Um método padrão nomeado bar() é definido na classe prim.
Para verificar sua acessibilidade, vamos dar uma olhada no seguinte código.
pacote lh;classe Second
public static void main (string [] main)
Prim OBJ = novo prim ();
obj.bar();
Um objeto do bar() O método é criado em outra classe (que reside no mesmo pacote).
É observado a partir da saída que o objeto do bar() O método é executado com sucesso e, portanto, conclui -se que os métodos declarados usando modificadores de acesso padrão podem ser usados no mesmo pacote, mas em classe diferente.
Modificador de acesso protegido
Os métodos ou membros de dados que são declarados usando palavras -chave protegidas são acessíveis na classe ou nas outras classes no mesmo pacote. Não pode ser acessado fora do pacote, mas uma subclasse dos outros pacotes pode acessar os métodos protegidos.
Exemplo: usando a subclasse do mesmo pacote
pacote newpack;Acesso de classe
Protected Void Show ()
Sistema.fora.println ("linuxhint!");
O método show () é declarado com privilégios protegidos:
O método é acessado no Accessm (subclasse do mesmo pacote em que o AccessMod mentiras) e o processo é realizado usando o seguinte código:
pacote newpack;classe accessm estende o accessMod
public static void main (string args [])
AccessMod obj = new AccessMod ();
obj.mostrar();
A imagem de saída do código é fornecida abaixo:
Agora, vamos elaborar a diferença entre modificadores de acesso padrão e protegidos usando o exemplo a seguir. Os modificadores de acesso padrão não podem ser acessados por subclasses (fora do pacote), no entanto, acessaremos um método protegido usando uma subclasse.
Exemplo 2: Usando a subclasse de outros pacotes
pacote lh;classe pública prot
Void Display protegido ()
Sistema.fora.println ("Bem -vindo ao Linuxhint!");
No código acima, um método protegido é declarado dentro de uma classe que contém uma instrução simples da linha de impressão.
O código escrito abaixo criará e acessará o objeto do método protegido mostrado na imagem acima.
pacote newpack;importar lh.*;
classe Protmod estende prot
public static void main (string args [])
protmod obj = new protmod ();
obj.mostrar();
Você observaria isso,
- o pacote LH está sendo importado para o pacote newpack
- uma subclasse (de Pro classe) nomeado Protmod é declarado
- objeto da classe Protmod nomeada obj é usado para obter o conteúdo do mostrar() método de Pro aula).
A saída mostra que o mostrar() método contido dentro do Pro A classe é usada na subclasse do Pro aula.
Conclusão
Os modificadores de acesso de Java permitem determinar o nível de acessibilidade de métodos, classes, variáveis e construtores. Este artigo fornece a funcionalidade dos modificadores de acesso que podem ser usados em java. Os modificadores de acesso como privado, público, protegido e inadimplência são exercidos usando vários exemplos. Por fim, conclui -se que os modificadores privados definem a plataforma mais segura, enquanto os modificadores públicos são considerados os menos seguros.