java - tipo - uma subclasse não tem acesso a campos privados de sua superclasse




Qual é a diferença entre public, protected, package-private e private em Java? (16)

Em Java, existem regras claras sobre quando usar cada um dos modificadores de acesso, ou seja, o padrão (pacote privado), public , protected e private , enquanto faz class e interface e lida com herança?


Privado

  • Métodos, Variáveis ​​e Construtores

Métodos, Variáveis ​​e Construtores que são declarados como privados só podem ser acessados ​​dentro da própria classe declarada.

  • Classe e Interface

O modificador de acesso privado é o nível de acesso mais restritivo. Classe e interfaces não podem ser privadas.

Nota

Variáveis ​​declaradas como privadas podem ser acessadas fora da classe se métodos getter públicos estiverem presentes na classe. Variáveis, métodos e construtores que são declarados protegidos em uma superclasse podem ser acessados ​​apenas pelas subclasses em outro pacote ou em qualquer classe dentro do pacote da classe dos membros protegidos.

Protegido

  • Classe e Interface

O modificador de acesso protegido não pode ser aplicado a classes e interfaces.

Métodos, os campos podem ser declarados protegidos, no entanto métodos e campos em uma interface não podem ser declarados protegidos.

Nota

O acesso protegido dá à subclasse a chance de usar o método auxiliar ou a variável, enquanto impede que uma classe não relacionada tente usá-la.

Público

Uma classe, método, construtor, interface etc declarada public pode ser acessada de qualquer outra classe.

Portanto, campos, métodos, blocos declarados dentro de uma classe pública podem ser acessados ​​de qualquer classe pertencente ao Java Universe.

  • Pacotes diferentes

No entanto, se a classe pública que estamos tentando acessar estiver em um pacote diferente, a classe pública ainda precisará ser importada.

Por causa da herança de classes, todos os métodos e variáveis ​​públicos de uma classe são herdados por suas subclasses.

Padrão - sem palavra-chave:

Modificador de acesso padrão significa que não declaramos explicitamente um modificador de acesso para uma classe, campo, método, etc.

  • Dentro dos mesmos pacotes

Uma variável ou método declarado sem qualquer modificador de controle de acesso está disponível para qualquer outra classe no mesmo pacote. Os campos em uma interface são implicitamente públicos como final estático e os métodos em uma interface são públicos por padrão.

Nota

Nós não podemos substituir os campos estáticos. Se você tentar substituí-lo não mostra nenhum erro, mas ele não funciona o que nós exceto.

Respostas Relacionadas

Referências links

http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html http://www.tutorialspoint.com/java/java_access_modifiers.htm


(Advertência: Eu não sou um programador Java, eu sou um programador Perl. O Perl não tem proteções formais, e é talvez por isso que eu entendo o problema tão bem :))

Privado

Como você pensa, apenas a classe em que é declarada pode vê-lo.

Pacote Privado

Só pode ser visto e usado pelo pacote em que foi declarado. Este é o padrão em Java (que alguns vêem como um erro).

Protegido

O pacote Private + pode ser visto por subclasses ou membros do pacote.

Público

Todos podem ver isso.

Published

Visível fora do código que controlo. (Embora não seja sintaxe Java, é importante para esta discussão).

C ++ define um nível adicional chamado "amigo" e quanto menos você souber sobre isso, melhor.

Quando você deve usar o que? A ideia é encapsulamento para ocultar informações. Tanto quanto possível, você deseja ocultar os detalhes de como algo é feito pelos usuários. Por quê? Porque então você pode mudá-las mais tarde e não quebrar o código de ninguém. Isso permite que você otimize, refatorie, redesenhe e corrija bugs sem se preocupar que alguém esteja usando o código que você acabou de revisar.

Portanto, regra geral é tornar as coisas apenas tão visíveis quanto elas devem ser. Comece com privado e adicione apenas mais visibilidade, conforme necessário. Apenas torne público o que é absolutamente necessário para o usuário saber, todos os detalhes que você tornar públicos enfraquecem sua capacidade de reprojetar o sistema.

Se você quiser que os usuários personalizem os comportamentos, em vez de torná-los públicos para que possam anulá-los, geralmente é uma boa ideia colocar essas entranhas em um objeto e tornar essa interface pública. Dessa forma, eles podem simplesmente conectar um novo objeto. Por exemplo, se você estivesse escrevendo um CD player e quisesse que o bit "encontre informações sobre este CD" fosse personalizável, em vez de torná-los públicos, você colocaria toda essa funcionalidade em seu próprio objeto e tornaria seu objeto getter / setter public . Desta forma, ser mesquinho sobre expor suas entranhas incentiva a boa composição e separação de preocupações

Pessoalmente, fico com apenas "privado" e "público". Muitas linguagens OO só tem isso. "Protegido" pode ser útil, mas é realmente uma fraude. Uma vez que uma interface é mais do que privada, ela está fora do seu controle e você precisa procurar código de outras pessoas para encontrar usos.

É aí que entra a ideia de "publicado". Mudar uma interface (refatorá-la) requer que você encontre todo o código que a está usando e mude isso também. Se a interface é privada, bem, não há problema. Se estiver protegido, você terá que encontrar todas as suas subclasses. Se é público, você precisa encontrar todo o código que usa seu código. Às vezes isso é possível, por exemplo, se você está trabalhando em código corporativo que é apenas para uso interno, não importa se uma interface é pública. Você pode pegar todo o código do repositório corporativo. Mas se uma interface for "publicada", se houver código usando-a fora de seu controle, você será escolhido. Você deve suportar essa interface ou arriscar quebrar o código. Mesmo interfaces protegidas podem ser consideradas publicadas (é por isso que não me incomodo com proteção).

Muitas línguas acham que a natureza hierárquica do público / protegido / privado é muito limitada e não está alinhada com a realidade. Para esse fim, existe o conceito de uma classe de características , mas isso é outro show.


Aqui está uma versão melhor da tabela. (Prova futura com uma coluna para módulos.)

Explicações

  • Um membro privado ( i ) é acessível dentro da mesma classe em que é declarado.

  • Um membro sem modificador de acesso ( j ) só é acessível dentro de classes no mesmo pacote.

  • Um membro protegido ( k ) é acessível dentro de todas as classes no mesmo pacote e dentro de subclasses em outros pacotes.

  • Um membro público ( l ) é acessível a todas as classes (a menos que resida em um module que não exporte o pacote no qual ele está declarado).

Qual modificador escolher?

Os modificadores de acesso são uma ferramenta para ajudá-lo a evitar o encapsulamento por quebra acidental (*) . Pergunte a si mesmo se você pretende que o membro seja algo que seja interno à classe, pacote, hierarquia de classes ou não interno, e escolha o nível de acesso de acordo.

Exemplos:

  • Um campo long internalCounter provavelmente deve ser privado, uma vez que é mutável e um detalhe de implementação.
  • Uma classe que só deve ser instanciada em uma classe de fábrica (no mesmo pacote) deve ter um construtor de pacote restrito, uma vez que não deve ser possível chamá-lo diretamente de fora do pacote.
  • Um método before void beforeRender() interno void beforeRender() chamado antes de renderizar e usado como um gancho em subclasses deve ser protegido.
  • Um void saveGame(File dst) que é chamado a partir do código GUI deve ser público.

(*) O que é o encapsulamento exatamente?


Como um princípio básico:

  • private : escopo de classe.
  • padrão (ou pacote-privado ): escopo do pacote.
  • protected : package scope + child (como o pacote, mas podemos subclassificá-lo de pacotes diferentes). O modificador protegido sempre mantém o relacionamento "pai-filho".
  • público : em todos os lugares.

Como resultado, se dividirmos o acesso em três direitos:

  • (D) ireto (invocar de um método dentro da mesma classe).
  • (Eferência) (invoca um método usando uma referência para a classe, ou via sintaxe "ponto").
  • (I) herança (via subclassificação).

então temos essa tabela simples:

+—-———————————————+————————————+———————————+
|                 |    Same    | Different |
|                 |   Package  | Packages  |
+—————————————————+————————————+———————————+
| private         |   D        |           |
+—————————————————+————————————+———————————+
| package-private |            |           |
| (no modifier)   |   D R I    |           |
+—————————————————+————————————+———————————+
| protected       |   D R I    |       I   |
+—————————————————+————————————+———————————+
| public          |   D R I    |    R  I   |
+—————————————————+————————————+———————————+

Na verdade, é um pouco mais complicado do que uma simples grade mostra. A grade informa se um acesso é permitido, mas o que exatamente constitui um acesso? Além disso, os níveis de acesso interagem com classes aninhadas e herança de formas complexas.

O acesso "padrão" (especificado pela ausência de uma palavra-chave) também é chamado de package-private . Exceção: em uma interface, nenhum modificador significa acesso público; modificadores que não sejam públicos são proibidos. As constantes de enumeração são sempre públicas.

Resumo

Um acesso a um membro com este especificador de acesso é permitido?

  • Membro é private : somente se membro estiver definido na mesma classe que o código de chamada.
  • O membro é um pacote privado: somente se o código de chamada estiver no pacote de fechamento imediato do membro.
  • Member is protected : O mesmo pacote, ou se o membro estiver definido em uma superclasse da classe que contém o código de chamada.
  • O membro é public : sim.

Quais especificadores de acesso se aplicam a

Variáveis ​​locais e parâmetros formais não podem receber especificadores de acesso. Uma vez que são inerentemente inacessíveis para o exterior de acordo com as regras de escopo, elas são efetivamente privadas.

Para classes no escopo superior, somente public e pacote-private são permitidos. Essa escolha de design é presumivelmente porque protected e private seriam redundantes no nível do pacote (não há herança de pacotes).

Todos os especificadores de acesso são possíveis em membros da classe (construtores, métodos e funções de membros estáticos, classes aninhadas).

Relacionado: Acessibilidade de Classe Java

Ordem

Os especificadores de acesso podem ser rigorosamente ordenados

public> protected> package-private> privado

o que significa que o public fornece o maior acesso, o private o menor. Qualquer referência possível em um membro privado também é válida para um membro privado do pacote; qualquer referência a um membro privado do pacote é válida em um membro protegido e assim por diante. (Dar acesso a membros protegidos para outras classes no mesmo pacote foi considerado um erro.)

Notas

  • Os métodos de uma classe têm permissão para acessar membros privados de outros objetos da mesma classe. Mais precisamente, um método da classe C pode acessar membros privados de C em objetos de qualquer subclasse de C. O Java não suporta a restrição de acesso por instância, somente por classe. (Compare com o Scala, que o suporta usando private[this] .)
  • Você precisa acessar um construtor para construir um objeto. Portanto, se todos os construtores forem privados, a classe só poderá ser construída pelo código que estiver dentro da classe (geralmente, métodos de fábrica estáticos ou inicializadores de variáveis ​​estáticas). Da mesma forma, para construtores privados ou protegidos por pacotes.
    • Somente ter construtores privados também significa que a classe não pode ser subclassificada externamente, uma vez que Java requer que os construtores de uma subclasse chame implícita ou explicitamente um construtor de superclasse. (Ele pode, no entanto, conter uma classe aninhada que a subclasse).

Classes internas

Você também deve considerar os escopos aninhados , como classes internas. Um exemplo da complexidade é que classes internas possuem membros, que podem ter modificadores de acesso. Então você pode ter uma classe interna privada com um membro público; o membro pode ser acessado? (Veja a seguir). A regra geral é examinar o escopo e pensar recursivamente para ver se você pode acessar cada nível.

No entanto, isso é bastante complicado e, para obter detalhes completos, consulte a Especificação da linguagem Java . (Sim, houve erros no compilador no passado).

Para um gostinho de como estes interagem, considere este exemplo. É possível "vazar" classes internas privadas; isso geralmente é um aviso:

class Test {
    public static void main(final String ... args) {
        System.out.println(Example.leakPrivateClass()); // OK
        Example.leakPrivateClass().secretMethod(); // error
    }
}

class Example {
    private static class NestedClass {
        public void secretMethod() {
            System.out.println("Hello");
        }
    }
    public static NestedClass leakPrivateClass() {
        return new NestedClass();
    }
}

Saída do compilador:

Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
        Example.leakPrivateClass().secretMethod(); // error
                                  ^
1 error

Algumas questões relacionadas:


O modificador de acesso mais incompreendido em Java é protected . Sabemos que é semelhante ao modificador padrão com uma exceção na qual as subclasses podem vê-lo. Mas como? Aqui está um exemplo que, esperamos, esclarece a confusão:

  • Suponha que tenhamos duas classes; Father e Son , cada um em seu próprio pacote:

    package fatherpackage;
    
    public class Father
    {
    
    }
    
    -------------------------------------------
    
    package sonpackage;
    
    public class Son extends Father
    {
    
    }
    
  • Vamos adicionar um método protegido foo() ao Father .

    package fatherpackage;
    
    public class Father
    {
        protected void foo(){}
    }
    
  • O método foo() pode ser chamado em 4 contextos:

    1. Dentro de uma classe que está localizada no mesmo pacote onde foo() é definido ( fatherpackage ):

      package fatherpackage;
      
      public class SomeClass
      {
          public void someMethod(Father f, Son s)
          {
              f.foo();
              s.foo();
          }
      }
      
    2. Dentro de uma subclasse, na instância atual via this ou super :

      package sonpackage;
      
      public class Son extends Father
      {
          public void sonMethod()
          {
              this.foo();
              super.foo();
          }
      }
      
    3. Em uma referência cujo tipo é a mesma classe:

      package fatherpackage;
      
      public class Father
      {
          public void fatherMethod(Father f)
          {
              f.foo(); // valid even if foo() is private
          }
      }
      
      -------------------------------------------
      
      package sonpackage;
      
      public class Son extends Father
      {
          public void sonMethod(Son s)
          {
              s.foo();
          }
      }
      
    4. Em uma referência cujo tipo é a classe pai e está dentro do pacote onde foo() é definido ( fatherpackage ) [Isso pode ser incluído dentro do contexto no. 1]:

      package fatherpackage;
      
      public class Son extends Father
      {
          public void sonMethod(Father f)
          {
              f.foo();
          }
      }
      
  • As situações a seguir não são válidas.

    1. Em uma referência cujo tipo é a classe pai e está fora do pacote em que foo() está definido ( fatherpackage ):

      package sonpackage;
      
      public class Son extends Father
      {
          public void sonMethod(Father f)
          {
              f.foo(); // compilation error
          }
      }
      
    2. Uma não-subclasse dentro de um pacote de uma subclasse (Uma subclasse herda os membros protegidos de seu pai e os torna privados para não-subclasses):

      package sonpackage;
      
      public class SomeClass
      {
          public void someMethod(Son s) throws Exception
          {
              s.foo(); // compilation error
          }
      }
      

O tutorial oficial pode ser útil para você.

            │ Class │ Package │ Subclass │ Subclass │ World
            │       │         │(same pkg)│(diff pkg)│ 
────────────┼───────┼─────────┼──────────┼──────────┼────────
public      │   +   │    +    │    +     │     +    │   +     
────────────┼───────┼─────────┼──────────┼──────────┼────────
protected   │   +   │    +    │    +     │     +    │         
────────────┼───────┼─────────┼──────────┼──────────┼────────
no modifier │   +   │    +    │    +     │          │    
────────────┼───────┼─────────┼──────────┼──────────┼────────
private     │   +   │         │          │          │    

+ : accessible
blank : not accessible

Esta página escreve bem sobre o modificador de acesso protegido e padrão

.... Protected: modificador de acesso protegido é um pouco complicado e você pode dizer que é um superconjunto do modificador de acesso padrão. Os membros protegidos são os mesmos que os membros padrão no que diz respeito ao acesso no mesmo pacote. A diferença é que os membros protegidos também são acessíveis às subclasses da classe na qual o membro está declarado, que estão fora do pacote no qual a classe pai está presente.

Mas esses membros protegidos são “acessíveis fora do pacote apenas por herança”. isto é, você pode acessar um membro protegido de uma classe em sua subclasse presente em algum outro pacote diretamente, como se o membro estivesse presente na própria subclasse. Mas esse membro protegido não estará acessível na subclasse fora do pacote usando a referência da classe pai. ....


Privado : acesso limitado à turma apenas

Padrão (sem modificador) : acesso limitado à classe e ao pacote

Protegido : Acesso limitado à classe, pacote e subclasses (dentro e fora do pacote)

Público : acessível para classe, pacote (todos) e subclasses ... Em suma, em todos os lugares.


Modificadores de acesso estão lá para restringir o acesso em vários níveis.

Público: É basicamente tão simples quanto você pode acessar de qualquer classe, seja no mesmo pacote ou não.

Para acessar se você está no mesmo pacote, você pode acessar diretamente, mas se você estiver em outro pacote, então você pode criar um objeto da classe.

Padrão: está acessível no mesmo pacote de qualquer classe de pacote.

Para acessar você pode criar um objeto da classe. Mas você não pode acessar essa variável fora do pacote.

Protegido: você pode acessar variáveis ​​no mesmo pacote, bem como subclasse em qualquer outro pacote. Então, basicamente, é padrão + comportamento herdado .

Para acessar o campo protegido definido na classe base, você pode criar um objeto da classe filha.

Privado: pode ser acessado na mesma aula.

Em métodos não estáticos, você pode acessar diretamente por causa dessa referência (também em construtores), mas para acessar métodos estáticos, é necessário criar um objeto da classe.


É tudo sobre encapsulamento (ou como Joe Phillips declarou, menos conhecimento ).

Comece com o mais restritivo (privado) e veja se você precisa de modificadores menos restritivos mais tarde.

Todos usamos métodos e modificadores de membros como private, public, ... mas uma coisa que poucos desenvolvedores fazem é usar pacotes para organizar o código logicamente.

Por exemplo: você pode colocar métodos de segurança confidenciais em um pacote de 'segurança'. Em seguida, coloque uma classe pública que acesse alguns dos códigos relacionados à segurança neste pacote, mas mantenha o pacote de outras classes de segurança privado . Assim, outros desenvolvedores só poderão usar a classe publicamente disponível de fora deste pacote (a menos que eles modifiquem o modificador). Este não é um recurso de segurança, mas orientará o uso.

Outside world -> Package (SecurityEntryClass ---> Package private classes)

Outra coisa é que as classes que dependem muito umas das outras podem acabar no mesmo pacote e eventualmente ser refatoradas ou mescladas se a dependência for muito forte.

Se pelo contrário você definir tudo como público , não ficará claro o que deve ou não ser acessado, o que pode levar a escrever muito javadoc (que não impõe nada através do compilador ...).


A resposta de Davi fornece o significado de cada modificador de acesso. Quanto a quando usar cada um, sugiro tornar públicas todas as classes e os métodos de cada classe que são destinados ao uso externo (sua API) e todo o resto privado.

Com o tempo, você desenvolverá um senso de quando tornar algumas classes privadas de pacotes e quando declarar certos métodos protegidos para uso em subclasses.


Muitas vezes eu percebi que lembrar os conceitos básicos de qualquer idioma pode ser possível através da criação de analogias do mundo real. Aqui está minha analogia para entender os modificadores de acesso em Java:

Vamos supor que você é um estudante em uma universidade e você tem um amigo que vem visitá-lo no fim de semana. Suponha que exista uma grande estátua do fundador da universidade no meio do campus.

  • Quando você o leva para o campus, a primeira coisa que você e sua amiga vê é essa estátua. Isso significa que qualquer pessoa que passeia no campus pode ver a estátua sem a permissão da universidade. Isso torna a estátua como PÚBLICA .

  • Em seguida, você quer levar seu amigo para o seu dormitório, mas para isso você precisa registrá-lo como visitante. Isso significa que ele recebe um passe de acesso (que é o mesmo que o seu) para entrar em vários prédios no campus. Isso tornaria seu cartão de acesso como PROTECTED .

  • Seu amigo quer fazer o login no WiFi do campus, mas não tem as credenciais para isso. A única maneira que ele pode ficar on-line é se você compartilhar seu login com ele. (Lembre-se, todos os alunos que vão para a universidade também possuem essas credenciais de login). Isso tornaria suas credenciais de login como NO MODIFIER .

  • Finalmente, o seu amigo quer ler o seu relatório de progresso para o semestre que é publicado no site. No entanto, cada aluno tem seu próprio login pessoal para acessar esta seção do site do campus. Isso tornaria essas credenciais como PRIVADAS .

Espero que isto ajude!


Nota: Este é apenas um suplemento para a resposta aceita.

Isso está relacionado aos Modificadores do Java Access .

De Modificadores de Acesso Java :

Um modificador de acesso Java especifica quais classes podem acessar uma determinada classe e seus campos, construtores e métodos. Os modificadores de acesso podem ser especificados separadamente para uma classe, seus construtores, campos e métodos. Os modificadores de acesso Java também são, às vezes, mencionados na fala diária como especificadores de acesso Java, mas o nome correto é modificadores de acesso Java. Classes, campos, construtores e métodos podem ter um dos quatro modificadores de acesso Java diferentes:

  • Item de lista
  • privado
  • padrão (pacote)
  • protegido
  • público

Do controle de acesso aos membros de uma classe tutoriais:

Os modificadores de nível de acesso determinam se outras classes podem usar um determinado campo ou invocar um método específico. Existem dois níveis de controle de acesso:

  • No nível superior - público ou pacote privado (sem modificador explícito).
  • No nível de membro - público, privado, protegido ou pacote privado (sem modificador explícito).

Uma classe pode ser declarada com o modificador public, caso em que essa classe é visível para todas as classes em todos os lugares. Se uma classe não tem modificador (o padrão, também conhecido como pacote-privado), é visível apenas dentro de seu próprio pacote

A tabela a seguir mostra o acesso aos membros permitido por cada modificador.

╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ Modifier    ║ Class ║ Package ║ Subclass ║ World ║
╠═════════════╬═══════╬═════════╬══════════╬═══════╣
║ public      ║ Y     ║ Y       ║ Y        ║ Y     ║
║ protected   ║ Y     ║ Y       ║ Y        ║ N     ║
║ no modifier ║ Y     ║ Y       ║ N        ║ N     ║
║ private     ║ Y     ║ N       ║ N        ║ N     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝

A primeira coluna de dados indica se a classe em si tem acesso ao membro definido pelo nível de acesso. Como você pode ver, uma classe sempre tem acesso a seus próprios membros. A segunda coluna indica se as classes no mesmo pacote da classe (independentemente de sua origem) têm acesso ao membro. A terceira coluna indica se as subclasses da classe declarada fora deste pacote têm acesso ao membro. A quarta coluna indica se todas as classes têm acesso ao membro.

Os níveis de acesso afetam você de duas maneiras. Primeiro, quando você usa classes que vêm de outra fonte, como as classes na plataforma Java, os níveis de acesso determinam quais membros dessas classes suas próprias classes podem usar. Segundo, quando você escreve uma classe, você precisa decidir qual o nível de acesso que cada variável de membro e cada método em sua classe devem ter.


Visível para o pacote. O padrão. Nenhum modificador é necessário.

Visível apenas para a turma ( privado ).

Visível para o mundo ( público ).

Visível para o pacote e todas as subclasses ( protegidas ).

Variáveis ​​e métodos podem ser declarados sem nenhum modificador chamado. Exemplos padrão:

String name = "john";

public int age(){
    return age;
}

Modificador de acesso privado - privado:

Métodos, variáveis ​​e construtores declarados como privados só podem ser acessados ​​dentro da própria classe declarada. O modificador de acesso privado é o nível de acesso mais restritivo. Classe e interfaces não podem ser privadas.

Variáveis ​​declaradas como privadas podem ser acessadas fora da classe se métodos getter públicos estiverem presentes na classe.

Usar o modificador privado é a principal maneira pela qual um objeto se encapsula e oculta dados do mundo externo.

Exemplos:

Public class Details{

    private String name;

    public void setName(String n){
        this.name = n;
    }

    public String getName(){
        return this.name;
    }
}

Modificador de acesso público - público:

Uma classe, método, construtor, interface, etc. declarados public podem ser acessados ​​de qualquer outra classe. Portanto, campos, métodos, blocos declarados dentro de uma classe pública podem ser acessados ​​de qualquer classe pertencente ao universo Java.

No entanto, se a classe pública que estamos tentando acessar estiver em um pacote diferente, a classe pública ainda precisará ser importada.

Por causa da herança de classes, todos os métodos e variáveis ​​públicos de uma classe são herdados por suas subclasses.

Exemplo:

public void cal(){

}

Modificador de acesso protegido - protegido:

Variáveis, métodos e construtores que são declarados protegidos em uma superclasse podem ser acessados ​​apenas pelas subclasses em outro pacote ou em qualquer classe dentro do pacote da classe dos membros protegidos.

O modificador de acesso protegido não pode ser aplicado a classes e interfaces. Métodos, os campos podem ser declarados protegidos, no entanto métodos e campos em uma interface não podem ser declarados protegidos.

O acesso protegido dá à subclasse a chance de usar o método auxiliar ou a variável, enquanto impede que uma classe não relacionada tente usá-la.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

                | highest precedence <---------> lowest precedence
*———————————————+———————————————+———————————+———————————————+———————
 \ xCanBeSeenBy | this          | any class | this subclass | any
  \__________   | class         | in same   | in another    | class
             \  | nonsubbed     | package   | package       |    
Modifier of x \ |               |           |               |       
————————————————*———————————————+———————————+———————————————+———————
public          |       ✔       |     ✔     |       ✔       |   ✔   
————————————————+———————————————+———————————+———————————————+———————
protected       |       ✔       |     ✔     |       ✔       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
package-private |               |           |               |
(no modifier)   |       ✔       |     ✔     |       ✘       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
private         |       ✔       |     ✘     |       ✘       |   ✘    




access-modifiers