Qual é a diferença entre public, protected, package-privados e privados em Java?

https://stackoverflow.com/questions/215497

03-07-2019
|

Pergunta

Em Java, existem regras claras sobre quando usar cada um dos modificadores de acesso, nomeadamente o padrão (pacote privada), public, protected e private, enquanto class e interface e como lidar com a herança?

Solução

O tutorial oficial pode ser de alguma utilidade para você .

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

 + : accessible         blank : not accessible

Outras dicas

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

Privado

Como você acha que, apenas o class em que é declarado 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

Pacote Privada + pode ser visto por subclasses ou membro de embalagem.

Público

Todos podem vê-lo.

Publicado

visível fora do controle de código I. (Embora não seja sintaxe Java, é importante para esta discussão).

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

Quando você deve usar o que? A idéia é encapsulamento para esconder informações. Tanto quanto possível, você quer esconder os detalhes de como algo é feito a partir de seus usuários. Por quê? Porque então você pode alterá-las posteriormente e não quebrar o código de ninguém. Isso permite que você otimizar, refatorar, reformular e corrigir bugs, sem preocupação de que alguém estava usando esse código você apenas revisto.

Assim, regra de ouro é fazer com que as coisas só tão visível como eles têm de ser. Comece com privado e só adicionar mais visibilidade, conforme necessário. Apenas tornar público aquilo que é absolutamente necessário para o usuário saber, cada detalhe que você tornar pública cãibras sua capacidade de redesenhar o sistema.

Se você quiser que os usuários possam personalizar comportamentos, ao invés de fazer internos pública para que possam substituí-los, muitas vezes é uma idéia melhor para empurrar essas tripas em um objeto e tornar pública essa interface. Dessa forma, eles podem simplesmente ligar um novo objeto. Por exemplo, se você estivesse escrevendo um CD player e queria que o personalizável pouco "Vá encontrar informações sobre esta CD", ao invés de fazer esses métodos públicos você colocaria tudo o que funcionalidade em seu próprio objeto e fazer apenas o seu objeto getter / setter público . Desta forma ser mesquinho sobre expor suas entranhas incentiva a boa composição e separação de interesses

Pessoalmente, eu ficar 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 está fora de seu controle e você tem que ir à procura no código de outras pessoas para encontrar usos.

Este é o lugar onde a idéia de "publicado" entra. Mudando uma interface (refatoração-lo) requer que você encontrar todo o código que está a usá-lo e mudar isso também. Se a interface é privado, bem não há problema. Se ele está protegido você tem que ir encontrar todas as suas subclasses. Se é público, você tem que ir encontrar todo o código que utiliza o seu código. Às vezes isso é possível, por exemplo, se você está trabalhando em código corporativo que é para uso interno não importa se uma interface é público. Você pode pegar todo o código fora do repositório corporativo. Mas se uma interface é "publicado", se não houver código de usá-lo fora de seu controle, então você está hosed. Você deve suportar esse código de interface ou o risco de ruptura. interfaces de até mesmo protegidas pode ser considerada publicada (que é por isso que eu não me incomodo com protegido).

Muitas línguas encontrar a natureza hierárquica do público / protegido / privado a ser muito limitante e não em linha com a realidade. Para esse fim, há o conceito de um traço classe , mas isso é outra show.

Aqui está uma versão melhor da mesa. (À prova de futuro, com uma coluna de módulos).

Explicações

A privada membro (i) é única acessível dentro da mesma classe que é declarada.
Um membro com não tem acesso modificador (j) só é acessível dentro de classes no mesmo pacote.
A protegido membro (k) é acessível dentro de todas as classes no mesmo pacote e dentro de subclasses em outros pacotes.
A público membro (l) é acessível a todas as classes (a menos que ele reside em uma módulo que não exportar o pacote é declarado in).

Qual modificador de escolher?

modificadores de acesso é uma ferramenta para ajudá-lo a evitar acidentalmente quebrar encapsulamento ^(*). Pergunte a si mesmo se você pretende o membro a ser algo que é interno para a classe, pacote, hierarquia de classes ou não interna em tudo, e escolha o nível de acesso em conformidade.

Exemplos:

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

^{(*) 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. Comece com declarar tudo privado. E, em seguida, avançar para o público como surgem as necessidades e design justifique.

Quando os membros expondo pergunte-se se você está expondo opções de representação ou escolhas de abstração. O primeiro é algo que você quer evitar, uma vez que irá introduzir muitas dependências sobre a representação real em vez de em seu comportamento observável.

Como regra geral eu tento evitar substituir implementações de métodos por subclasse; é muito fácil de estragar a lógica. Declare métodos protegidos resumo, se você pretende para que seja substituído.

Além disso, use a anotação @Override ao substituir para manter as coisas de quebrar quando você refatorar.

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

O acesso "default" (especificado pela ausência de uma palavra-chave) também é chamado pacote -Privada . Exceção: em uma interface, nenhum modificador significa acesso público; além público modificadores são proibidos. constantes enum são sempre públicas.

Resumo

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

Membro é private:. Só se membro é definido dentro da mesma classe como chamar código
Membro pacote privada:. Só se o código de chamada está dentro do membro é imediatamente colocando pacote
Membro é protected:. O mesmo pacote, ou se membro é definido em uma superclasse da classe que contém o código de chamada
Membro é public: Sim.

O que especificadores de acesso aplicam-se

As variáveis ??locais e parâmetros formais não pode tomar especificadores de acesso. Uma vez que eles são inerentemente inacessíveis para o exterior de acordo com o escopo regras, eles são efetivamente privado.

Para as classes no âmbito Top, Só public e pacote-privadas são permitidas. Esta escolha design é presumivelmente porque protected e private seria redundante no nível do pacote (não há herança de pacotes).

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

relacionadas: Java Class acessibilidade

Ordem

Os especificadores de acesso pode ser estritamente ordenou

público> protegido> pacote-privadas> privada

o que significa que public fornece mais acesso, private o mínimo. Qualquer referência possível em um membro privado também é válido para um membro do pacote-privadas; qualquer referência a um membro de embalagem-privada é válido em um membro protegido, e assim por diante. (Que dão acesso a membros protegidos para outras classes no mesmo pacote foi considerado um erro.)

Notas

métodos de uma classe são permissão para acessar os membros privados de outros objetos do 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 a restrição de acesso por exemplo, apenas por classe. (Compare com Scala, que suporta-lo usando private[this].)
Você precisa ter acesso a um construtor para construir um objeto. Assim, se todos os construtores são privados, a classe só pode ser construído por código de estar dentro da classe (métodos de fábrica normalmente estáticas ou initializers variável estática). Da mesma forma para o pacote-privadas ou construtores protegidas.
- Apenas tendo construtores privados também significa que a classe não pode ser uma subclasse externamente, desde Java requer construtores de uma subclasse para chamar implícita ou explicitamente um construtor da superclasse. (Ele pode, no entanto, conter uma classe aninhada que subclasses ele.)

Classes internas

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

No entanto, isso é bastante complicado, e para obter mais detalhes, consultar o linguagem Java Specification. (Sim, houve erros de compilador no passado.)

Para ter um gostinho de como estes interagem, considere este exemplo. É possível "vazar" classes internas privadas; este é 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 perguntas relacionadas:

Java - acessibilidade método dentro da classe pacote-privadas

Como uma regra de ouro:

private: escopo de classe
default (ou package-private):. Âmbito pacote
protected: package scope + child (como pacote, mas podemos subclasse-lo a partir de diferentes pacotes). Protegida modificador sempre mantém o relacionamento "pai-filho".
public:. Em todos os lugares

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

(D) espirre (invocação de um método dentro da mesma classe, ou através de "este" sintaxe).
(R) eferência (invocação de um método que utiliza uma referência para a classe, ou através de "dot" sintaxe).
(I) nheritance (via subclasse).

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 todos os lugares.
protected:. Acessível pelas classes do mesmo pacote e as subclasses que residem em qualquer pacote
padrão (sem modificador especificado):. Acessível pelas classes do mesmo pacote
private:. Acessível dentro da mesma classe única

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

Suponha que temos 2 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 uma foo() método protegido para Father.

package fatherpackage;

public class Father
{
    protected void foo(){}
}

O foo() método pode ser chamado em 4 contextos:

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

package fatherpackage;

public class SomeClass
{
    public void someMethod(Father f, Son s)
    {
        f.foo();
        s.foo();
    }
}

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();
    }
}

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();
    }
}

Em uma referência cujo tipo é a classe principal e é dentro o pacote onde foo() é definida (fatherpackage) [Este pode ser incluído dentro do contexto não. 1]:
```
package fatherpackage;

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

As seguintes situações não são válidos.
1. Em uma referência cujo tipo é a classe principal e é fora o pacote onde foo() é definida (fatherpackage):
```
package sonpackage;

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

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

Privada

Métodos,Variáveis e Construtores

Métodos, Variáveis e os Construtores que são declaradas privado só pode ser acessado dentro da declarado própria classe.

Classe e Interface

Privado modificador de acesso é a mais restritiva nível de acesso.Classe e interfaces não pode ser privado.

Nota

As variáveis que são declaradas privado, podem ser acessados de fora da classe, se o público getter métodos presentes na classe.Variáveis, métodos e construtores, que são declaradas protegido em uma superclasse pode ser acessado somente por subclasses em outro pacote ou qualquer classe dentro do pacote de membros protegidos da classe'.

Protegida

Classe e Interface

O modificador de acesso protected não pode ser aplicado à classe e interfaces.

Métodos, campos pode ser declarada protegida, no entanto, métodos e campos em uma interface não pode ser declarada protegida.

Nota

Acesso protegido dá a subclasse de uma chance para utilizar o gestor de método ou variável, ao impedir que um nonrelated classe de tentar usá-lo.

Público

Uma classe, método, construtor, interface, etc declarado como public podem ser acessados a partir de qualquer outra classe.

Portanto, campos, métodos, blocos declarada dentro de uma classe pública pode ser acessado a partir de qualquer classe pertencentes ao Universo Java.

Pacotes Diferentes

No entanto, se o público de classe que estamos tentando acessar está em um pacote diferente, então o público de classe que ainda precisam ser importados.

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

Padrão -Nenhuma palavra-chave:

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

Dentro de Pacotes para o mesmos

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

Nota

Não podemos Substituir a campos Estáticos.se você tentar substituir ele não mostra qualquer erro mas ele não funcionar o que nós, exceto.

Respostas Relacionadas

Substituindo métodos estáticos em java

Links de referência

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

privada : O acesso limitado à classe somente

Padrão (nenhum modificador) : O acesso limitado à classe e pacote

Protegido : O acesso limitado à classe, pacote e subclasses (tanto dentro como fora do pacote)

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

A diferença pode ser encontrada nos links já fornecidos, mas qual deles usar normalmente se resume ao "princípio do menor conhecimento". Só permitem a menos visibilidade que é necessário.

modificadores de acesso são lá para restringir o acesso a vários níveis.

Público:. É basicamente tão simples como você pode acessar de qualquer classe se que está em mesmo pacote ou não

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

Padrão:. É acessível no mesmo pacote a partir de qualquer da classe de pacote

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

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

Para acesso protegido campo definido na classe base você pode criar objeto da classe infantil.

privada:. pode ser acesso na mesma classe

Nos métodos não-estáticos que você pode acessar diretamente por causa de este de referência (também em construtores), mas para o acesso em métodos estáticos que você precisa para criar o objeto da classe.

modificadores de acesso em Java.

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

1. Padrão:

acessível às classes no mesmo pacote somente.

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 outro jogará 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 para as classes no 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á

Eu só quero abordar um detalhe que é extremamente comumente errou, inclusive a maioria das respostas nesta página. Acesso "Default" (quando nenhum modificador de acesso está presente) nem sempre é o mesmo que pacote-privadas . Depende do que a coisa é.

tipos terceiros (isto é, classes, enums, interfaces e tipos de anotação não declaradas dentro de outro tipo) são pacote-privadas por padrão. ( JLS §6.6.1 )
Os membros da classe e construtores estão pacote-privadas por padrão. ( JLS §6.6.1 )
construtores enum são privado por padrão . (Na verdade, contructors enum deve ser privado, e é um erro para tentar torná-los públicos ou protegidos). constantes enum são públicos, e não permitem qualquer especificador de acesso. Outros membros da enums são pacote-privadas por padrão. ( JLS §8.9 )
Todos os membros de interfaces e tipos de anotação são pública por padrão . (De fato, membros de interfaces e tipos de anotação deve ser público, e é um erro para tentar fazê-los privados ou protegidos.) (JLS §9.3 a 9.5 )

público -. Acessível a partir de qualquer lugar do aplicativo
padrão -. Acessível a partir pacote
protegido - acessível a partir do pacote e sub-classes em outro pacote. assim
privada -. Acessíveis a partir de sua classe única

Visível para o pacote. O padrão. Não são necessários quaisquer modificadores.

Visível para a classe única ( privada ).

visível para o mundo ( public ).

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

As variáveis ??e métodos podem ser declarada sem quaisquer modificadores que são chamados. exemplos padrão:

String name = "john";

public int age(){
    return age;
}

modificador de acesso privado - privado:

Métodos, variáveis ??e construtores que são declaradas lata privada só pode ser acessada dentro da própria classe declarada. O modificador de acesso privado é o nível de acesso mais restritivo. Classe e interfaces não pode ser privado.

As variáveis ??que são declaradas privado pode ser acessado fora da classe, se os métodos getter públicas estão presentes na classe.

Usando o modificador privado é a principal forma que um objeto encapsula em si e se esconde de 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;
    }
}

O acesso público modificador - público:

A classe, método, construtor, interface, etc. declarada pública pode ser acessado de qualquer outra classe. Portanto campos, métodos, blocos declarada dentro de uma classe pública pode ser acessado de qualquer classe pertencente ao universo Java.

No entanto, se a classe pública que está tentando acessar está em um pacote diferente, então a classe pública ainda precisam ser importados.

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

Exemplo:

public void cal(){

}

protegido modificador de acesso - protegida:

As variáveis, métodos e construtores que são declaradas protegidas em uma superclasse pode ser acessado apenas pelos subclasses em outro pacote ou qualquer classe dentro do pacote de classe dos membros protegidos.

O modificador de acesso protegido não pode ser aplicada a classe e interfaces. Métodos, campos podem ser declarada protegida, no entanto métodos e campos em uma interface não pode ser declarada protegida.

Acesso protegido dá a subclasse a chance de usar o método auxiliar ou variável, evitando uma classe não relacionada com a tentativa de usá-lo.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

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

.... Protegido: modificador de acesso protegido é o um pouco complicado e você pode dizer que é um super do modificador de acesso padrão. Membros protegidos são os mesmos que os membros padrão, tanto quanto o acesso no mesmo pacote está em causa. A diferença é que, os membros protegidas também são acessíveis às subclasses da classe em que o membro é declarado que estão fora do pacote no qual a classe pai está presente.

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

A resposta de David fornece o significado de cada modificador de acesso. Quanto quando usar cada um, eu sugiro tornando pública todas as classes e os métodos de cada classe que são destinados para uso externo (sua API), e tudo o mais privado.

Com o tempo você vai desenvolver um sentido para quando fazer algumas aulas de pacote-privadas e quando a declarar certos métodos protegidos para uso em subclasses.

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

Isso está relacionado ao Java acesso modificadores .

A partir Modificadores de Acesso Java :

A Java especifica o acesso modificador quais classes podem acessar um determinado classe e seus campos, construtores e métodos. modificadores de acesso pode ser especificado separadamente para uma classe, os seus construtores, campos e métodos. modificadores de acesso Java também são por vezes referido no diário discurso como especificadores de acesso Java, mas o nome correto é o acesso Java modificadores. Classes, campos, construtores e métodos podem ter uma de quatro diferentes modificadores de acesso Java:

item da lista
privada

padrão (pacote)

protegido

public

A partir Controlando Acesso aos membros do tutoriais uma classe :

modificadores de nível de acesso determinar se outras classes podem usar uma nomeadamente campo ou invocação de um método particular. Existem dois níveis de controle de acesso:

No topo de nível público, ou pacote-privadas (sem modificador explícito).

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

A classe pode ser declarada com o público modificador, caso em que classe é visível para todas as classes em todos os lugares. Se uma classe tem nenhum modificador (O padrão, também conhecido como pacote-privadas), que só é visível dentro de seu próprio pacote

A tabela seguinte mostra o acesso a 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 você pode ver, uma classe sempre tem acesso a seus próprios membros. A segunda coluna indica se classes no mesmo pacote que a classe (independentemente da sua parentesco) tem acesso ao membro. A terceira coluna indica se subclasses da classe declarada fora deste pacote tem acesso ao membro. A quarta coluna indica se todas as classes tem acesso ao membro.
níveis
Acesso afetá-lo de duas maneiras. Primeiro, quando você usa classes que vir de outra fonte, como as classes na plataforma Java, níveis de acesso determinar quais os membros dessas classes seu próprio classes podem usar. Segundo, quando você escrever uma classe, você precisa decidir o nível de acesso a cada variável de membro e cada método em sua classe deveria ter.

Público protegido padrão e privado, são modificadores de acesso.

Eles são destinados para encapsulamento, ou ocultar e mostrar conteúdo da classe.

Class podem ser públicas ou padrão

Os membros da classe pode ser público, protegido, padrão ou privada.

Privada não é acessível fora da classe O padrão é acessível apenas no pacote. Protegido em pacote, bem como qualquer classe, que se estende ela. Pública está aberta para todos.

Normalmente, membro variáveis ??são definidas privada, mas os métodos de membros são públicos.

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

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

Quando você trazê-lo para o campus, a primeira coisa que você e seu amigo vê é esta estátua. Isto significa que qualquer um que anda no campus pode olhar para a estátua sem a permissão da universidade. Isso faz com que a estátua como PÚBLICO .

Em seguida, você quer levar seu amigo para seu dormitório, mas para isso você precisa de registar-lo como um visitante. Isso significa que ele recebe um passe de acesso (que é o mesmo que o seu) para entrar em vários edifícios no campus. Isto faria com que o seu cartão de acesso como protegido .

Seu amigo quer para acessar o WiFi campus, mas não tem os quaisquer credenciais para o fazer. A única maneira que ele pode obter on-line é se você compartilhar o seu login com ele. (Lembre-se, a cada estudante que vai para a universidade também possui essas credenciais de login). Isto faria com que suas credenciais de login como nenhum modificador .

Finalmente, o seu amigo quer ler o seu relatório de progresso para o semestre que está publicado no site. No entanto, cada aluno tem seu próprio login pessoal para aceder a esta secção do site do campus. Isto faria com que essas credenciais como PRIVATE .

Espero que isso ajude!

Quando você está pensando em modificadores de acesso basta pensar nisso desta maneira (aplica-se tanto variáveis ?? e métodos ):

public -> acessível a partir de todos os lugares
private -> acessíveis apenas dentro da mesma classe onde é declarado

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

default -> Sem palavra-chave de acesso modificador está presente. Isso significa que ele está disponível estritamente dentro do pacote da classe. Nowhere fora do pacote pode ser acessado.

protected -> Um pouco menos rigorosas do que default e para além das mesmas classes de pacotes que podem ser acessados ??por subclasses fora do pacote é declarada.

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

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

Nós todos método e Membro Use modificadores como privadas, públicas ... mas uma coisa muito poucos desenvolvedores fazer é pacotes de uso para organizar código logicamente.

Por exemplo: Você pode colocar métodos de segurança sensíveis em um pacote 'segurança'. Em seguida, coloque uma classe pública que acessa alguns dos códigos relacionados a segurança neste pacote, mas manter outras classes de segurança Pacote privada . Assim outros desenvolvedores só será capaz de usar a classe à disposição do público de fora deste pacote (a menos que alterar o modificador). Este não é um recurso de segurança, mas vai guia uso.

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

Outra coisa é que as classes que dependem muito uns sobre os outros pode acabar no mesmo pacote e poderia, eventualmente, ser reformulado ou se fundir se a dependência é muito forte.

Se, pelo contrário, definir tudo como public não será claro o que deve ou não ser acessado, o que pode levar a escrever um monte de javadoc (que não impõe nada via o compilador ...).

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow