Visão geral da palavra-chave protegida em Java
Palavras-chave protegidas são palavras-chave usadas para restringir o escopo no qual a variável, o método e os construtores podem ser acessados. É um dos tipos de modificadores de acesso em Java. Eles são usados para diferenciar o escopo de métodos, variáveis, construtores e classes. Existem 4 tipos de modificadores de acesso em Java e são:
- Palavra-chave padrão: eles podem ser acessados apenas dentro do pacote e não podem ser chamados fora dele. Como o nome sugere, quando nenhum especificador de acesso é mencionado, ele é automaticamente atribuído como padrão.
- Palavra-chave pública: eles podem ser acessados de qualquer lugar do programa. Isso significa que pode ser usado da mesma classe ou de uma classe diferente e do mesmo ou de um pacote diferente.
- Palavra-chave privada: elas restringem as palavras-chave a um nível superior, não permitindo que elas sejam acessadas de qualquer lugar fora da própria classe.
- Palavra-chave protegida: neste artigo, conheceremos mais sobre palavras-chave protegidas.
Depois que uma variável ou método é marcado como protegido, ele pode ser acessado apenas pelos métodos abaixo:
- Dentro da mesma classe em que é declarada.
- De outras classes que também estão no mesmo pacote que a classe declarada.
- Classes herdadas da declarada, independentemente de seu pacote.
Palavras-chave protegidas são como uma combinação de palavras-chave públicas e privadas, uma vez que foram introduzidas para poder acessar as variáveis fora da classe (o que não é possível no caso de palavras-chave privadas), mas também mantendo que apenas certos métodos podem herdar o mesmo.
Sintaxe
As palavras-chave protegidas são declaradas com a palavra-chave prefixada como "protegida". Primeiro, declaramos a palavra-chave protegida em uma classe chamada "MyClass", conforme abaixo:
class MyClass (
protected String name = "Katy";
protected int token= 55;
)
public class SubClass extends MyClass (
public static void main(String() args) (
SubClass obj = new SubClass();
System.out.println(obj.name + "'s token number is: " + obj.token);
)
)
Aqui a classe “SubClass” estende “MyClass” e, portanto, a palavra-chave protegida pode ser usada aqui, criando um objeto de SubClass e chamando as variáveis.
Resultado:
Palavras-chave protegidas podem ser usadas apenas no nível de membro, isto é, classes internas declaradas fora de uma função e que não são estáticas. A palavra-chave protegida é diferente da palavra-chave privada, pois pode ser acessada fora de uma classe e na subclasse de outro pacote.
Algumas das restrições ao uso de palavras-chave protegidas são:
- Eles não podem ser usados para declarar classes como protegidas.
- As interfaces não podem ser declaradas como protegidas.
- A acessibilidade fora do pacote é apenas por herança.
- Um construtor que é protegido não pode ser acessado fora do pacote, criando sua instância.
Exemplos
Vamos analisar alguns exemplos em que podemos entender melhor o conceito de palavras-chave protegidas.
1. Chamando a palavra-chave protegida sem estender a classe pai
Aqui tentamos chamar a palavra-chave da classe pai de "package1". "ProtectedExample2" é criado em "package2" e a palavra-chave "disp" é chamada aqui. Mas o código não poderá acessar a palavra-chave, pois a classe filho não herdou seu valor da classe principal e lançará uma exceção, como mostrado.
Código:
package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
//Create new package as com.package2
//Create new class as ProtectedExample2
package com.package2;
import com.package1.Example;
public class ProtectedExample2 (
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)
Resultado:
2. Acessando uma classe protegida
Neste exemplo, tentamos acessar a classe "ProtectedExample5" que está protegida. Isso causa um erro de compilação.
Código:
protected class ProtectedExample5 (
void display()
(
System.out.println("Try to access outer protected class");
)
public static void main(String() args) (
ProtectedExample5 p=new ProtectedExample5();
p.display();
)
)
Resultado:
3. Exibindo palavra-chave protegida do mesmo pacote, mas classe diferente
No exemplo abaixo, primeiro criamos um pacote chamado "com.package1" e criamos uma nova classe com o nome "Exemplo". Aqui declaramos que nossa palavra-chave "disp" está protegida. Vamos tentar exibir essa palavra-chave protegida usando a classe "Exemplo1". Para isso, primeiro é necessário criar um objeto da classe pai "Exemplo1" e depois imprimir o valor atribuído à palavra-chave "disp".
Código:
package com.package1;
public class Example (
protected String disp="Printing message from protected variable from package1";
)
class Example1 (
public static void main(String() args) (
Example obj=new Example();
System.out.println(obj.disp);
)
)
Resultado:
4. Exibindo palavras-chave protegidas de um pacote diferente
Usando o mesmo código acima, veremos como chamar a palavra-chave protegida criando um pacote diferente “package2”. Uma palavra-chave protegida pode ser acessada apenas por herança do pacote1, portanto, "ProtectedExample2" é estendido de "Exemplo". De maneira semelhante ao primeiro exemplo, precisamos criar um objeto da classe "ProtectedExample2" para acessar a palavra-chave protegida do pacote "com.package1".
Código:
package com.package2;
import com.package1.Example;
public class ProtectedExample2 extends Example(
public static void main(String() args) (
ProtectedExample2 a=new ProtectedExample2();
System.out.println(a.disp);
)
)
Resultado:
5. Acessando uma classe protegida substituindo a subclasse
Aqui a classe é declarada como protegida dentro da classe herdada "Example5". Além disso, uma classe protegida chamada “Exemplo” é declarada fora da função, mas no mesmo pacote. Quando um objeto do "Exemplo5" é criado e a classe protegida "disp ()" é chamada, podemos observar que o método substituído é chamado em vez da classe externa. Isso ocorre porque não poderemos importar "com.package1" e sua classe "Exemplo", pois não é visível e causa um erro de compilação.
Código:
//Create a file by Example.java
package com.package1;
class Example
(
protected void disp()
(
System.out.println("Printing from protected class in the outside function");
)
)
//Create a class by the name Example5.java
public class Example5 extends Example (
protected void disp()
(
System.out.println("Accessing the overriden function");
)
public static void main(String() args) (
Example5 exp=new Example5();
exp.disp();
)
)
Resultado:
Importância da palavra-chave protegida
- Essas palavras-chave permitem que as classes ou suas variáveis sejam herdadas de sua classe pai, o que não é possível com nenhuma outra palavra-chave restrita, como private.
- Palavra-chave protegida é a combinação da vantagem de uma palavra-chave privada e de uma palavra-chave pública. Elimina a desvantagem da palavra-chave pública de que a variável ou classe seja acessível de qualquer lugar do programa, restringindo o escopo.
Conclusão - Palavra-chave protegida em Java
Conforme mostrado nos exemplos acima, escolhemos palavras-chave protegidas, dependendo do nível de acesso exigido no nível do código. Eles ajudam muito nos casos em que a mesma variável ou classe precisa ser acessada a partir de outros métodos herdados no programa. Um relacionamento pai-filho está sempre presente entre a classe pai e suas subclasses que estão usando a palavra-chave protegida.
Artigos recomendados
Este é um guia para palavras-chave protegidas em Java. Aqui discutimos a visão geral, sintaxe e diferentes exemplos de palavras-chave protegidas em java. Você também pode consultar os seguintes artigos para saber mais -
- Encapsulamento em Java
- Construtor em Java
- Perguntas da entrevista sobre Java
- Substituindo em OOPs
- Palavras-chave Java
- Ferramentas de implantação Java
- Modificadores de acesso em PHP
- Substituindo em Java
- Encapsulamento em JavaScript