Qual é a diferença entre público, Protegido, pacote-privado e privado em Java?

(Caveat: eu não sou um programador Java, eu sou um programador Perl. Perl não tem proteções formais, e talvez seja por isso que eu entendo o problema tão bem:)

Privado

Como se pensa, só a classe em que é declarada a pode ver.

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

Pacote Privado + pode ser visto por subclasses ou membro do pacote.

Público

Todos podem ver.

Publicado

Visível fora do Código I. (Embora não sintaxe Java, é importante para esta discussão).

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

Quando deves usar o quê? Toda a ideia é encapsular para esconder informação. O mais possível você quer esconder o detalhe de como algo é feito de seus usuários. Por quê? Porque depois podes mudá-los e não quebrar o código de ninguém. Isso permite que você otimize, refactor, redesenhe e conserte bugs sem se preocupar que alguém estava usando o código que você acabou de revisar.

Então, a regra de ouro é tornar as coisas tão visíveis como têm de ser. Comece com Privado e só adicione mais visibilidade conforme necessário. Apenas torne público o que é absolutamente necessário para o usuário saber, cada detalhe que você torna pública cólicas sua capacidade de redesenhar o sistema. Se você quer que os usuários sejam capazes de personalizar comportamentos, em vez de tornar os internos públicos para que eles possam sobrepô-los, muitas vezes é uma idéia melhor enfiar essas entranhas em um objeto e tornar essa interface pública. Assim podem simplesmente ligar um objecto novo. Por exemplo, se você estava escrevendo um leitor de CD e queria a "go find info sobre este CD" bit personalizável, em vez de tornar esses métodos públicos você iria colocar toda essa funcionalidade em seu próprio objeto e fazer apenas o seu objecto getter / setter público. Desta forma, ser mesquinho em expor suas entranhas incentiva uma boa composição e separação de preocupações Pessoalmente, fico - me apenas por "privado" e "público". Muitas línguas têm isso. "Protegido" pode ser útil, mas é uma fraude. Uma vez que uma interface é mais do que privada, está fora do seu controle e você tem que ir procurar no código de outras pessoas para encontrar usos. É aqui que entra a ideia de "publicado". Alteracao uma interface (refactoring it) requer que você encontre todo o código que o está usando e altere isso também. Se a interface é privada, não há problema. Se está protegido, tens de ir procurar todas as tuas subclasses. Se é público, tens de encontrar o código que usa o teu código. Às vezes isso é possível, por exemplo, se você está trabalhando em código corporativo que é para uso interno, só que não importa se uma interface é pública. Você pode pegar todo o código do repositório corporativo. Mas se uma interface é "publicada", se há um código usando-a fora de seu controle, então você está preso. Você deve apoiar essa interface ou arriscar quebrar o código. Até mesmo as interfaces protegidas podem ser consideradas publicadas (razão pela qual não me preocupo com as protegidas).

Muitas línguas consideram a natureza hierárquica do público/Protegido/privado demasiado limitativa e não conforme com a realidade. Para isso existe o conceito de uma classe de traços, mas isso é outro show.

Aqui está uma versão melhor da mesa. (Future proof with a column for modules.)

Explicações

• A private member is only accessible within the same class as it is declared.

• Um membro com sem modificador de acesso só está acessível dentro das classes do mesmo pacote.

• Um membro protegido está acessível dentro de todos classes no mesmo pacote e dentro de subclasses noutras embalagens.

• Apublic member is accessible to all classes (unless it resides in a module that does not export the package it is declared in).

---

Qual modificador escolher?

Os modificadores de acesso são uma ferramenta para o ajudar a evitar que quebre acidentalmente a encapsulação^(*). Pergunte a si mesmo se você pretende que o membro seja algo que é interno para a classe, pacote, hierarquia de classe ou não interno em tudo, e escolher o nível de acesso em conformidade.

Exemplos:

• um campo {[[0]} 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 interno void beforeRender() chamado imediatamente antes de renderização e usado como um gancho em subclasses deve ser protegido.
• O Método void saveGame(File dst) que é chamado a partir do Código GUI deve ser público.

^{(*) o que é encapsulamento exatamente?}

                | 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         |       ✔       |     ✘     |       ✘       |   ✘    

Regra fácil. Começa por declarar tudo privado. E depois avançamos para o público à medida que as necessidades surgem e o design o justifica.

Ao expor os membros, pergunte-se se está a expor opções de representação ou opções de abstracção. O primeiro é algo que você quer evitar, pois ele irá introduzir muitas dependências da representação real, em vez de seu comportamento observável.

Como regra geral, tento evitar implementações de métodos superiores por subclassificação; é muito fácil estragar a lógica. Declare métodos protegidos abstratos se você pretende que ele seja sobreposto.

Também, use a anotação @Override ao sobrepor-se para evitar que as coisas se quebrem quando você refacora.

Na verdade, é um pouco mais complicado do que uma simples grelha mostra. A grelha diz-lhe Se é permitido um acesso, mas o que constitui exactamente um acesso? Além disso, os níveis de acesso interagem com classes aninhadas e herança de formas complexas.

O acesso " predefinido "(especificado pela ausência de uma palavra-chave) também é chamado Pacote-privado. Excepção: numa interface, nenhum modificador significa acesso público; modificadores que não sejam públicos são proibidos. Constantes de Enum são sempre públicos.

Resumo

É permitido um acesso a um membro com este especificador de acesso?

• o Membro é private: apenas se o membro estiver definido na mesma classe que o código de chamada.
• Membro é pacote privado: só se o código de chamada estiver dentro do pacote imediatamente envolvente do membro.
• o Membro é protected: o mesmo pacote, ou se o Membro é definido numa superclasse da classe que contém o código de chamada.
• Membro é public: Sim.

Que especificações de acesso se aplicam a

As variáveis locais e os parâmetros formais não podem aceitar os especificadores de acesso. Uma vez que eles são inerentemente inacessíveis ao exterior de acordo com as regras de escopo, eles são efetivamente privados.

Para As classes de Topo, Apenas public e package-private são permitidas. Esta escolha de design é presumivelmente porque protected e private seriam redundantes ao nível do pacote (não há herança de pacotes).

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

Relacionado: Acessibilidade De Classe Java

Ordem

Os especificadores de acesso podem ser estritamente ordenados

Público > Protegido > pacote-privado > privado

Significa que public dá mais acesso, private o mínimo. Qualquer referência possível a um membro privado também é válida para um membro package-private member; a referência a um pacote-membro privado é válida em um membro protegido, e assim por diante. (Dar acesso a membros protegidos a outras classes no mesmo pacote foi considerado um erro.)

Notas

• os métodos de uma classe são autorizados a aceder a membros privados de outros objectos da mesma classe. mais precisamente, um método de Classe C pode acessar membros privados de C em objetos de qualquer subclasse de C. Java não suporta restringir o acesso por exemplo, apenas por classe. (Compare com o Scala,que o suporta usando private[this].)
Precisas de acesso a um construtor para construir um objecto. Assim, se todos os construtores são privados, a classe só pode ser construída por código vivendo dentro da classe (tipicamente métodos de fábrica estáticos ou inicializadores de variáveis estáticos). Do mesmo modo, para os construtores privados ou protegidos.
• ter apenas construtores privados também significa que a classe não pode ser subclassificada externamente, uma vez que Java requer um os construtores da subclasse para implicitamente ou explicitamente chamar um construtor de superclasse. (It can, however, contain a nested class that subclasses it.)

Classes internas

Você também tem que considerar âmbitos aninhados, tais como classes internas. Um exemplo da complexidade é que classes internas têm membros, que eles mesmos podem ter modificadores de acesso. Então você pode ter uma classe interna privada com um membro público; o Membro pode ser acessado? (Abaixar.) A regra geral é olhar para o escopo e pensar recursivamente para ver se você pode acessar cada nível.

No entanto, isto é bastante complicado, e para mais detalhes, consulte a especificação da linguagem Java . (Yes, there have been compiler bugs in the past.)

Para provar como estes interagem, considere este exemplo. É possível" vazar " classes internas privadas; isto 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

Alguns relacionados perguntas:

• Java-Method accessibility inside package-private class?

Como regra geral:

• privado : âmbito da classe.
• default (ou package-private ): package scope.
• protected : package scope + child (like package, but we can subclass it from different packages). O modificador protegido mantém sempre a relação pai-filho.
• público : em todo o lado.

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

• (D) irect (invocar a partir de um método dentro da mesma classe).
• (R) eference (invoque um método usando uma referência à classe, ou através de sintaxe "ponto").
• (I) herança (via subclassificação).

Então temos esta 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   |
+—————————————————+————————————+———————————+

Em muito curto

• public: Acessível a partir de todo o lado.
• protected: acessível pelas classes do mesmo pacote e as subclasses que residem em qualquer pacote.
• predefinição (sem modificador especificado): acessível pelas classes do mesmo pacote.
• private: acessível apenas na mesma classe.

O modificador de acesso mais mal compreendido em Java é protected. Sabemos que é semelhante ao modificador padrão com uma exceção em que subclasses podem vê-lo. Mas como? Aqui está um exemplo que espero clarifique a confusão:

• Suponha que temos 2 classes; Father e Son, cada uma no seu próprio pacote:

  package fatherpackage;
  
  public class Father
  {
  
  }
  
  -------------------------------------------
  
  package sonpackage;
  
  public class Son extends Father
  {
  
  }
  

• Vamos adicionar um método protegido foo() a 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() está 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 actual via this ou super:

     package sonpackage;
     
     public class Son extends Father
     {
         public void sonMethod()
         {
             this.foo();
             super.foo();
         }
     }
     

  3. Numa referência cujo tipo é da 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. Numa referência cujo tipo é a classe-mãe e é dentro {[53] } do pacote onde foo() está definido (fatherpackage) [isto pode ser incluído no contexto no. 1]:

     package fatherpackage;
     
     public class Son extends Father
     {
         public void sonMethod(Father f)
         {
             f.foo();
         }
     }
     

• As seguintes situações não são válidas.

  1. Numa referência cujo tipo é a classe-mãe e que está fora {[53] } da embalagem onde 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 do seu pai, e torna-os privados a não-subclasses):

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

Privado

• métodos, variáveis e construtores

métodos, variáveis e construtores declarados 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. A classe e as interfaces não podem ser privadas.

Nota

as variáveis declaradas privadas podem ser acessado fora da classe se os métodos de getter públicos estão presentes na classe. Variáveis, métodos e construtores que são declarados protegidos em uma superclasse só podem ser acessados pelas subclasses em outro pacote ou qualquer classe dentro do pacote da classe dos membros protegidos.

---

Protegido

• classe e Interface

o modificador de acesso protegido não pode ser aplicado à classe e interface.

métodos, 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 uma chance de usar o método auxiliar ou variável, ao mesmo tempo que impede uma classe não relacionada de tentar usá-lo.

---

Público

uma classe, método, construtor, interface, etc., declarada pública pode ser acessado a partir de qualquer outra classe.

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

• Pacotes Diferentes

no entanto, se a classe pública a que estamos a tentar aceder está num pacote diferente, então a classe pública ainda precisa de ser importada.

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

---

Predefinição - nenhuma 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 numa interface são implicitamente estáticos públicos final e os métodos em uma interface são por padrão público.

Nota

Não podemos anular os campos estáticos.se você tentar sobrepô-lo não mostra nenhum erro mas não funciona como nós, excepto.

Respostas Relacionadas

• a sobrepor os métodos estáticos em java

Referências links

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

A diferença pode ser encontrada nos links já fornecidos, mas qual a usar geralmente se resume ao "princípio do menor conhecimento". Apenas permitir a menor visibilidade necessária.

Privado : acesso limitado apenas à classe

Por omissão (sem modificador) : acesso limitado à classe e pacote

Protegido : acesso limitado às classes, pacotes e subclasses (dentro e fora da embalagem)

Público : acessível à classe, pacote (todos) e subclasses... Em suma, em todo o lado.

Modificadores de acesso em Java.

Modificadores de acesso Java são usados para fornecer controle de acesso em Java.

1. Predefinição:

Acessível apenas às classes do mesmo pacote.

Por exemplo,

// Saved in file A.java
package pack;

class A{
  void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B{
  public static void main(String args[]){
   A obj = new A(); // Compile Time Error
   obj.msg(); // Compile Time Error
  }
}

Este acesso é mais restrito do que o público e protegido, mas menos restrito do que o privado.

2. Público

Pode ser acessado de qualquer lugar. (Acesso Global)

Por exemplo,

// Saved in file A.java

package pack;
public class A{
  public void msg(){System.out.println("Hello");}
}

// Saved in file B.java

package mypack;
import pack.*;

class B{
  public static void main(String args[]){
    A obj = new A();
    obj.msg();
  }
}

Saída: Olá

3. Privado

Acessível apenas dentro da mesma classe.

Se você tentar acessar membros privados em uma classe em outra irá lançar erro de compilação. Por exemplo,

class A{
  private int data = 40;
  private void msg(){System.out.println("Hello java");}
}

public class Simple{
  public static void main(String args[]){
    A obj = new A();
    System.out.println(obj.data); // Compile Time Error
    obj.msg(); // Compile Time Error
  }
}

4. Protegido

Acessível apenas às classes do mesmo pacote e às subclasses

Por exemplo,

// Saved in file A.java
package pack;
public class A{
  protected void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B extends A{
  public static void main(String args[]){
    B obj = new B();
    obj.msg();
  }
}

Saída: Olá

Os modificadores de acesso existem para restringir o acesso a vários níveis.

Público: é basicamente tão simples quanto você pode acessar a partir de qualquer classe, quer isso esteja no mesmo pacote ou não.

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

Por omissão: está acessível no mesmo pacote a partir de qualquer uma das classes de pacotes.

Para aceder pode criar um objecto da turma. Mas você não pode acessar esta variável fora do pacote.

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

Para aceder ao campo protegido definido na classe base, pode criar um objecto da classe infantil.

Privado: {[5] pode ser Acesso na mesma classe.

Em métodos não-estáticos pode aceder directamente por causa distoisto referência (também em construtores), mas para acessar em métodos estáticos você precisa criar objeto da classe.

Visível para a embalagem. Padrao. Não são necessários modificadores.

Visível apenas para a classe (privado ).

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

Visível para a embalagem e todas as subclasses (protegidas ).

Variáveis e métodos podem ser declarados sem quaisquer modificadores que são chamados. Exemplos predefinidos:

String name = "john";

public int age(){
    return age;
}

Modificador de acesso privado-privado:

Métodos, variáveis e construtores declarados privados apenas ser acessado dentro da própria classe declarada. O modificador de acesso privado é o nível de acesso mais restritivo. A classe e as interfaces não podem ser privadas.

As variáveis declaradas privadas podem ser acessadas fora da classe se os métodos de getter públicos estiverem presentes na classe.

Usar o modificador privado é a forma principal de um objecto se encapsular e esconder dados do mundo exterior.

Exemplos:

Public class Details{

    private String name;

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

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

Modificador do acesso público - público:

Uma classe, método, construtor, interface, etc. o público declarado pode ser acessado a partir de qualquer outra classe. Portanto campos, métodos, blocos declarados dentro de uma classe pública podem ser acessados a partir de qualquer classe pertencente ao universo Java.

No entanto, se a classe pública a que estamos a tentar aceder está num pacote diferente, então a classe pública ainda precisa de ser importada. Por causa da herança de classe, todos os métodos e variáveis públicos de uma classe são herdados por sua herança. subclasses.

Exemplo:

public void cal(){

}

Acesso protegido com modificador:

As variáveis, métodos e construtores declarados protegidos numa superclasse só podem ser acedidos pelas subclasses de outro pacote ou por qualquer classe do pacote da classe dos membros protegidos.

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

O acesso protegido dá à subclasse a oportunidade de usar o método auxiliar ou variável, impedindo uma classe não relacionada de tentar usá-lo.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

• Público - Acessível a partir de qualquer ponto do pedido.

• Por omissão - Acessível a partir do pacote.

• Protegido - Acessível a partir de embalagens e subclasses de outras embalagens. bem

• Private - acessível apenas a partir da sua classe.

Eu só quero abordar um detalhe que é extremamente comumente errado, incluindo pela maioria das respostas nesta página. o acesso "predefinido" (quando não está presente nenhum modificador de acesso) nem sempre é o mesmo que package-private. Depende do que se passa.

• Os tipos não-membros (isto é, classes, enums, interfaces e tipos de anotação não declarados dentro de outro tipo) são pacotes privados por padrão. ([8]}JLS §6.6.1)

• Membros da classe e os construtores são package-private by default. ([8]}JLS §6.6.1)

• Os construtores de Enum são privados por defeito . (De fato, enum contructors deve ser privado, e é um erro tentar torná-los públicos ou protegidos). As constantes Enum são públicas, e não permitem qualquer especificação de acesso. Outros membros do enums são package-private by default. ([24]}JLS §8.9)

• Todos os membros das interfaces e tipos de anotações são públicos por predefinição. (De fato, os membros de interfaces e tipos de anotação devem ser públicos, e é um erro tentar torná-los privados ou protegidos.) (JLS §9.3 a 9.5)

Esta página escreve bem sobre o modificador de acesso protegido por omissão

.... Protegido: o 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 em que o Membro é declarado que estão fora do pacote em que a classe dos Pais está presente.

Mas estes membros protegidos são "acessíveis fora do pacote apenas por herança". I. e 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 será acessível na subclasse fora do pacote usando a referência da classe pai. ....

A resposta de David fornece o Significado de cada modificador de acesso. Quanto a quando usar cada um, eu sugiro tornar público todas as classes e os métodos de cada classe que são destinados para uso externo (sua API), e tudo o resto privado. Ao longo do tempo você vai desenvolver um sentido para quando fazer algumas classes pacote-privado e quando declarar certos métodos protegidos para uso em subclasses.

• visível para a embalagem. o valor por omissão . Não são necessários modificadores.
• visível apenas para a classe; privado.
• visível para o mundo; público .
• visível para a embalagem e todas as subclasses; protegido.

Então vamos falar sobre controle de acesso e herança. As seguintes regras para métodos herdados são:

• Os métodos declarados {[[0]} numa superclasse também devem ser públicos em todos os subclasses.
• Os métodos declarados protected numa superclasse devem ser protected ou {[[0]} em subclasses; eles não podem ser privados.
• Os métodos declarados sem controlo de acesso (não foi utilizado nenhum modificador) podem ser declarado mais privado em subclasses.
• Os métodos declarados private não são herdados. governa para eles.

Nota: Isto é apenas umsuplemento para a resposta aceite.

Isto está relacionado com os modificadores de acesso Java .

De Modificadores De Acesso Java:

Um modificador de acesso Java especifica quais as classes que podem aceder a um dado classe e seus campos, construtores e métodos. Os modificadores de acesso podem ser especificados separadamente para uma classe, seus construtores, campos e meios. Modificadores de acesso Java também são algumas vezes referidos em diario speech as Java access specifiers, but the correct name is Java access modificador. Classes, campos, construtores e métodos podem ter um quatro modificadores de acesso Java diferentes:

• rubrica da lista
• privado
• predefinição (pacote)
• protegido
• Público

De controlar o acesso a membros de uma classe tutoriais:

Os modificadores do nível de acesso determinam se outras classes podem utilizar a campo particular ou invocar um método particular. Existem dois níveis de controlo de acesso:

• no nível superior-público, ou pacote-privado (sem modificador explícito).
A nível dos Estados-Membros-público, privado, protegido ou package-privado (sem modificador explícito).

Uma classe pode ser declarada junto do público modificador, caso em que: a classe é visível para todas as classes em todos os lugares. Se uma classe não tiver modificador (o padrão, também conhecido como package-private), é apenas visível dentro do seu próprio pacote

O quadro seguinte 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 própria classe tem acesso a o membro definido pelo nível de acesso. Como podes ver, uma aula sempre tem acesso aos seus próprios membros. A segunda coluna indica se: classes no mesmo pacote que a classe (independentemente do seu filiação) tem acesso ao Membro. O a terceira coluna indica se as subclasses da classe declaradas fora da presente Embalagem têm acesso ao Membro. A quarta coluna indica se todas as classes ter acesso ao Membro.

Os níveis de acesso afectam-te de duas maneiras. Primeiro, quando você usa aulas que vêm de outra fonte, como as classes na plataforma Java, os níveis de acesso determinam quais os membros dessas classes que você tem as aulas podem ser úteis. Segundo, quando escreves uma aula, tens de decidir. que Acesso nivelar cada variável de membro e cada método em sua classe devia.

Os Default públicos protegidos e privados são modificadores de acesso.

São para encapsulamento, ou para esconder e mostrar o conteúdo da classe.

1. A classe pode ser pública ou por defeito
2. Os membros da classe podem ser públicos, protegidos, por omissão ou privados.

Privado não é acessível fora da classe O padrão é acessível apenas no Pacote. Protegido na embalagem, bem como em qualquer classe que a amplie. O público está aberto para todos.

([1]}Normalmente, os as variáveis são definidas como privadas, mas os métodos dos membros são públicos.

Muitas vezes eu percebi que lembrar os conceitos básicos de qualquer linguagem pode tornar possível criando analogias do mundo real. Aqui está minha analogia para entender modificadores de acesso em Java: Vamos assumir que és estudante numa universidade e tens um amigo que vem visitar-te no fim-de-semana. Suponha que existe uma grande estátua do fundador da universidade no meio do campus.

• Quando o trouxeres para o campus, a primeira coisa que tu e o teu amigo vejam é esta estátua. Isto significa que qualquer um que entra no campus pode olhar para a estátua sem a permissão da Universidade. Isto torna a estátua pública.

• A seguir, queres levar o teu amigo para o teu dormitório, mas para isso tens de o registar como visitante. Isto significa que ele recebe um passe de acesso (que é o mesmo que o seu) para entrar em vários edifícios no campus. Isso faria com que o seu cartão de acesso como protegido .

• O teu amigo quer entrar na Wi-Fi do campus, mas não tem credenciais para o fazer. A única forma de ele ficar online é se partilhares o teu login com ele. (Lembre-se, cada estudante que vai para a universidade também possui essas credenciais de login). Isto faria as suas credenciais de login como sem modificador .

• Finalmente, seu amigo quer ler seu relatório de progresso para o semestre que é publicado no site. Entanto, cada aluno tem seu próprio login pessoal para acessar esta seção do site do campus. Isto faria com que estas credenciais fossem privadas.

Espero que isto ajude!

Quando se está a pensar em modificadores de acesso, basta pensar nisso desta forma (aplica-se a ambas as variáveis e métodos):

public --> Acessível a partir de onde
private --> acessível apenas na mesma classe em que é declarado

Agora surge a confusão quando se trata de default e protected

default --> não está presente nenhuma palavra-chave modificadora de acesso. Isto significa que está disponível estritamente dentro do pacote da classe. Em lado nenhum lá fora esse pacote pode ser acedido.

protected --> um pouco menos rigoroso do que default e, para além das mesmas classes de pacotes, pode ser acedido por subclasses fora do Pacote é declarado.

{[[2]}é tudo sobre encapsulação {[[4]} (ou como Joe Phillips afirmou, menos conhecimento ).

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

Todos usamos métodos e modificadores de membros como privados, públicos ,.. 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 sensíveis em um pacote de 'segurança'. Em seguida, colocar uma classe pública que acede a algum do código de segurança deste pacote, mas mantém outras classes de segurança pacote privado . Assim, outros desenvolvedores só serão capazes de usar a classe disponível publicamente fora deste pacote (a menos que eles mudem o modificador). Este não é um recurso de segurança, mas Will Guia 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 podem eventualmente ser refactored ou mescladas se o a dependência é demasiado forte.

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