Modificador de acesso Java "protegido"

1. Visão geral

Na linguagem de programação Java, campos, construtores, métodos e classes podem ser marcados com modificadores de acesso. In this tutorial, we’ll look at protected access.

2. A palavra-chaveprotected

While elements declared as private can be accessed only by the class in which they’re declared, a palavra-chaveprotected permite acesso de subclasses e membros do mesmo pacote.

Usando a palavra-chaveprotected, tomamos decisões sobre quais métodos e campos devem ser considerados internos de um pacote ou hierarquia de classes e quais são expostos a código externo.

3. Declarando campos, métodos e construtores deprotected

Primeiro, vamos criar um_ class named _FirstClass contendo um campoprotected, método e construtor:

public class FirstClass {

    protected String name;

    protected FirstClass(String name) {
        this.name = name;
    }

    protected String getName() {
        return name;
    }
}

Com este exemplo, usando a palavra-chaveprotected, concedemos acesso a esses campos para classes no mesmo pacote queFirstClasse para subclasses deFirstClass.

4. Acessando campos, métodos e construtores deprotected

4.1 From the Same Package

Agora, vamos ver como podemos acessar os camposprotected criando um novoGenericClass declarado no mesmo pacote queFirstClass:

public class GenericClass {

    public static void main(String[] args) {
        FirstClass first = new FirstClass("random name");
        System.out.println("FirstClass name is " + first.getName());
        first.name = "new name";
    }
}

Como esta classe de chamada está no mesmo pacote queFirstClass,, é permitido ver e interagir com todos os campos, métodos e construtoresprotected.

4.2. De um pacote diferente

Vamos agora tentar interagir com esses campos de uma classe declarada em um pacote diferente deFirstClass:

public class SecondGenericClass {

    public static void main(String[] args) {
        FirstClass first = new FirstClass("random name");
        System.out.println("FirstClass name is "+ first.getName());
        first.name = "new name";
    }
}

Como podemos ver,we get compilation errors:

The constructor FirstClass(String) is not visible
The method getName() from the type FirstClass is not visible
The field FirstClass.name is not visible

Isso é exatamente o que esperávamos ao usar a palavra-chaveprotected. Isso ocorre porqueSecondGenericClass não está no mesmo pacote queFirstClasse não o subclasse.

4.3 From a Sub-Class

Vamos agora ver o que acontece quando declaramosa class extending FirstClass but declared in a different package:

public class SecondClass extends FirstClass {

    public SecondClass(String name) {
        super(name);
        System.out.println("SecondClass name is " + this.getName());
        this.name = "new name";
    }
}

Como esperado, podemos acessar todos os campos, métodos e construtores protegidos. Isso ocorre porqueSecondClass é uma subclasse deFirstClass.

5. protected Classe Interna

Nos exemplos anteriores, vimos campos, métodos e construtoresprotected em ação. Existe mais um caso particular - uma classe internaprotected.

Vamos criar esta classe interna vazia dentro de nossoFirstClass:

package com.example.core.modifiers;

public class FirstClass {

    // ...

    protected static class InnerClass {

    }
}

Como podemos ver, esta é uma classe interna estática e, portanto, pode ser construída de fora de uma instância deFirstClass. No entanto, como éprotected,we can only instantiate it from code in the same package as FirstClass.

5.1 From the Same Package

Para testar isso, vamos editar nossoGenericClass:

public class GenericClass {

    public static void main(String[] args) {
        // ...
        FirstClass.InnerClass innerClass = new FirstClass.InnerClass();
    }
}

Como podemos ver, podemos instanciarInnerClass sem nenhum problema porqueGenericClass está no mesmo pacote queFirstClass.

5.2. De um pacote diferente

Vamos tentar instanciar umInnerClass de nossoSecondGenericClass que, como lembramos, está fora do pacoteFirstClass':

public class SecondGenericClass {

    public static void main(String[] args) {
        // ...

        FirstClass.InnerClass innerClass = new FirstClass.InnerClass();
    }
}

Como esperado,we get a compilation error:

The type FirstClass.InnerClass is not visible

5.3. De uma subclasse

Vamos tentar fazer o mesmo com nossoSecondClass:

public class SecondClass extends FirstClass {

    public SecondClass(String name) {
        // ...

        FirstClass.InnerClass innerClass = new FirstClass.InnerClass();
    }
}

Esperávamos instanciar nossoInnerClass com facilidade. No entanto, também estamos recebendo um erro de compilação aqui:

The constructor FirstClass.InnerClass() is not visible

Vamos dar uma olhada em nossa declaraçãoInnerClass:

protected static class InnerClass {
}

O principal motivo de estarmos recebendo esse erro é quethe default constructor of a protected class is implicitly*protected*. Além disso,SecondClassis a sub-class of FirstClass but is not a sub-class of InnerClass. Finalmente,we also declaredSecondClass outside FirstClass' package.

Por todas essas razões,SecondClass não pode acessar o construtorprotectedInnerClass.

Se quisermosto solve this issuee permitir que nossoSecondClass instancie um objetoInnerClass,we could explicitly declare a public constructor:

protected static class InnerClass {
    public InnerClass() {
    }
}

Fazendo isso, não obtemos mais um erro de compilação e agora podemos instanciar umInnerClass deSecondClass.

6. Conclusão

Neste tutorial rápido, discutimos o modificador de acessoprotected em Java. Com isso, podemos garantir a exposição apenas dos dados e métodos necessários para subclasses e classes no mesmo pacote.

Como sempre, o código de exemplo está disponívelover on GitHub.

TOC

Modificador de acesso Java "protegido"