Olá Pessoal, tudo bom?
O artigo de hoje será uma continuação do artigo iniciado a um mês atrás explicando sobre orientação a objeto através do Java. No artigo de hoje iremos descrever sobre os modificadores de acesso que existem para classes, interfaces, enums, variáveis e métodos na linguagem Java. Confira na continuação:
Existe um conceito muito importante na orientação a objetos que se chama Encapsulamento. Nesse momento pense, como a própria palavra induz a entender, em uma cápsula. Pense em uma cápsula de remédio, nós acreditamos que o conteúdo existente ali é realmente um medicamento e não um placebo. Para permitir que possamos ter essa mesma confiança na linguagem Java existem alguns modificadores de acesso que nos auxiliam na proteção de algumas características.
Como visto no ultimo artigo foi criado várias características para a classe Casa, senão não lembra aqui está o que criamos:
|
1 2 3 4 5 6 7 8 |
public class Casa { private String localizacao; private int qtdQuartos; private int qtdBanheiros; private String dadosProprietarioAtual; private String tipoNegocio; private int qtdVeiculosGaragem; } |
Se você perceber nossa classe Casa é pública (public), mas as características criadas são privadas (private). Essas palavras chave, reservadas da linguagem Java são os Modificadores de acesso.
Modificadores de Acesso
Eles são palavras chave que permitem o acesso, dependendo de alguns níveis a atributos, métodos e classes e derivados. São essenciais para utilizar o conceito de Encapsulamento. Na linguagem Java existem quatro níveis de encapsulamento conforme mostra a Figura 01:
-
Figura 01 – Modificadores de acesso da linguagem Java
Modificador de acesso private
O modificador que mais restringe a visibilidade do item marcado deixando-o visível somente para a classe que o definiu. Em uma herança a restrição de acesso atinge também as classes filhas, impedindo-as de acessarem o item sob o modificador private. Esse modificador pode ser aplicado sobre os seguintes itens:
- Classes Internas
- Interfaces Internas
- Annotations Internas
- Enums Internos
- Métodos
- Atributos
O código abaixo exemplifica essa aplicação dos modificadores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package br.com.mauda.projetoBase.modificadores; //private class ModificadorPrivate { //ERRO DE COMPILACAO apenas Public e Default public class ModificadorPrivate { //OK atributos podem ser declarados como private private String nome; //OK métodos podem ser declarados como private private String obtemNome() { return nome; } //OK classes internas podem ser declaradas como private private class ClasseInternaPrivate { //Alguma implementação aqui } //OK enums internos podem ser declarados como private private enum EnumInternoPrivate{ //Alguma implementação aqui } //OK interfaces internas podem ser declaradas como private private interface InterfaceInternaPrivate{ //Alguma implementação aqui } //OK annotations internas podem ser declaradas como private private @interface AnnotationInternaPrivate{ //Alguma implementação aqui } } |
Como é possível verificar não dá pra declarar uma classe básica como private, ocorre um erro de compilação, mas as outras coisas podem ser declaradas sem problemas de compilar.
Modificador de acesso default
Restringe o acesso ao item sob o modificador deixando-o visível somente para as classes que se encontram sob o mesmo pacote da classe que possui o item. Em uma herança a restrição de acesso atinge também as classes filhas que não estejam no mesmo pacote, impedindo-as de acessarem o item sob o modificador default.
Para esse modificador não há uma palavra chave definida para o uso aqui. O modificador aqui é a omissão dos outros modificadores. Existe uma palavra-chave ‘default’ na Linguagem Java, mas essa palavra é utilizada em switches e interfaces. Esse modificador pode ser aplicado sobre os itens:
- Classes
- Classes Internas
- Interfaces Internas
- Annotations Internas
- Enums Internos
- Métodos
- Atributos
O código abaixo exemplifica essa aplicação dos modificadores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package br.com.mauda.projetoBase.modificadores; //OK classes podem ser declaradas como default class ModificadorDefault { //OK atributos podem ser declarados como default String nome; //OK métodos podem ser declarados como default String obtemNome() { return nome; } //OK classes internas podem ser declaradas como default class ClasseInternaDefault { //Alguma implementação aqui } //OK enums internos podem ser declarados como default enum EnumInternoDefault{ //Alguma implementação aqui } //OK interfaces internas podem ser declaradas como default interface InterfaceInternaDefault{ //Alguma implementação aqui } //OK annotations internas podem ser declaradas como default @interface AnnotationInternaDefault{ //Alguma implementação aqui } } |
Modificador de acesso protected
Restringe o acesso ao item sob o modificador deixando-o visível somente para as Classes filhas da classe que possui o item E para Classes que se encontram sob o mesmo pacote da classe que possui o item. Esse modificador pode ser aplicado sobre os itens:
- Classes Internas
- Interfaces Internas
- Annotations Internas
- Enums Internos
- Métodos
- Atributos
O código abaixo exemplifica essa aplicação dos modificadores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
package br.com.mauda.projetoBase.modificadores; //protected class ModificadorProtected { //ERRO DE COMPILACAO somente public e default public class ModificadorProtected { //OK atributos podem ser declarados como protected protected String nome; //OK métodos podem ser declarados como protected protected String obtemNome() { return nome; } //OK classes internas podem ser declaradas como protected protected class ClasseInternaProtected { //Alguma implementação aqui } //OK enums internos podem ser declarados como protected protected enum EnumInternoProtected{ //Alguma implementação aqui } //OK interfaces internas podem ser declaradas como protected protected interface InterfaceInternaProtected{ //Alguma implementação aqui } //OK annotations internas podem ser declaradas como protected protected @interface AnnotationInternaProtected{ //Alguma implementação aqui } } |
Modificador de acesso public
Não impõe restrições de acesso ao item, deixando-o visível para todo e qualquer classe. Esse modificador pode ser aplicado sobre todos os itens:
- Classes
- Classes Internas
- Interfaces
- Interfaces Internas
- Annotations
- Annotations Internas
- Enum
- Enums Internos
- Métodos
- Atributos
O código abaixo exemplifica essa aplicação dos modificadores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
package br.com.mauda.projetoBase.modificadores; public class ModificadorPublic { //OK classes podem ser declaradas como public //OK atributos podem ser declarados como public public String nome; //OK métodos podem ser declarados como public public String obtemNome() { return nome; } //OK classes internas podem ser declaradas como public public class ClasseInternaPublic { //Alguma implementação aqui } //OK enums internos podem ser declarados como public public enum EnumInternoPublic{ //Alguma implementação aqui } //OK interfaces internas podem ser declaradas como public public interface InterfaceInternaPublic{ //Alguma implementação aqui } //OK annotations internas podem ser declaradas como public public @interface AnnotationInternaPublic{ //Alguma implementação aqui } } |
Visibilidade de um item com o modificador de acesso
Para testar a visibilidade de um item com o seu modificador de acesso há 5 cenários diferentes:
- A partir da mesma classe
- Qualquer classe no mesmo package
- Qualquer classe filha no mesmo package
- Qualquer classe filha em package diferente
- Qualquer classe em package diferente
Para testar a visibilidade sempre você deve tentar acessar direto o item. Por exemplo no código abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public static void main(String[] args) { //Se o código estiver na mesma classe ModificadorPrivate não ocorrerá erro de compilação System.out.println(new ModificadorPrivate().nome); //Se a classe que contém o código estiver no mesmo package da classe ModificadorDefault não ocorrerá erro de compilação System.out.println(new ModificadorDefault().nome); //Se a classe que contém o código estiver no mesmo package ou for filha da classe ModificadorProtected não ocorrerá erro de compilação System.out.println(new ModificadorProtected().nome); //Não ocorrerá erro de compilação System.out.println(new ModificadorPublic().nome); } |
Assim combinando o método main acima mais um dos cenários temos a seguinte tabela de visibilidade, Figura 02, onde as figuras verdes indicam que não houve erro de compilação e as figuras vermelhas indicam que houve erro de compilação.
finally{
Com isso nós descrevemos um pouco sobre os modificadores de acesso.
Duvidas ou sugestões? Deixe seu feedback! Isso ajuda a saber a sua opinião sobre os artigos e melhorá-los para o futuro! Isso é muito importante!
Até um próximo post!
Leave a Reply