Modificadores de acesso - Access modifiers

Modificadores de acesso (ou especificadores de acesso ) são palavras - chave em linguagens orientadas a objetos que definem a acessibilidade de classes, métodos e outros membros. Os modificadores de acesso são uma parte específica da sintaxe da linguagem de programação usada para facilitar o encapsulamento de componentes.

Em C ++ , existem apenas três modificadores de acesso. C # estende o número deles para seis, enquanto Java tem quatro modificadores de acesso, mas três palavras-chave para esse propósito. Em Java, não ter nenhuma palavra-chave antes é padronizado para o modificador de pacote privado.

Quando a classe é declarada como pública, ela é acessível a outras classes definidas no mesmo pacote, bem como àquelas definidas em outros pacotes. Este é o especificador mais comumente usado para classes. No entanto, uma classe em si não pode ser declarada como privada. Se nenhum especificador de acesso for declarado, as restrições de acesso padrão serão aplicadas. A classe estará acessível para outras classes no mesmo pacote, mas será inacessível para classes fora do pacote. Quando dizemos que uma classe está inacessível, significa simplesmente que não podemos criar um objeto dessa classe ou declarar uma variável desse tipo de classe. O especificador de acesso protegido também não pode ser aplicado a uma classe.

Nomes de palavras-chave

C ++ utiliza os três modificadores de chamadas public , protected e private . C # tem os modificadores public , protected , internal , private , protected internal , e private protected . Java tem public , package , protected , e private . O modificador de acesso package é o padrão e usado, se qualquer outra palavra-chave do modificador de acesso estiver faltando. O significado desses modificadores pode variar de um idioma para outro. Segue-se uma comparação das palavras-chave, ordenadas da mais restritiva à mais aberta, e seu significado nessas três línguas. Sua visibilidade varia da mesma classe ao pacote onde a classe é definida para uma permissão de acesso geral. Abaixo, o acesso máximo é escrito na tabela.

No Swift, existem cinco níveis de acesso diferentes relativos ao arquivo de origem no qual a entidade está definida e ao módulo que contém esse arquivo de origem.

Palavra-chave C # C ++ Java Rápido
private aula classe
e / ou
aulas de amigos
aula declaração anexa apenas
+ extensões de declaração no mesmo arquivo
fileprivate - - - mesmo arquivo
private protected classes derivadas na mesma montagem - - -
protected internal mesmo conjunto
e / ou
classes derivadas
- - -
protected classes derivadas classes derivadas
e / ou
classes amigas
classes derivadas
e / ou
dentro do mesmo pacote
-
package - - dentro de seu pacote -
internal mesma montagem - - mesmo módulo
public todo o mundo todo o mundo todo o mundo todo o mundo
open - - - todos
+ subclasse fora do módulo
+ substituir módulo externo

Exemplo em C ++

#include <iostream>
#include <conio.h>
using std::cout;
using std::endl;

struct B { // default access modifier inside struct is public
    void set_n(int v) { n = v; }
    void f()          { cout << "B::f" << endl; }
  protected:
    int m, n; // B::m, B::n are protected
  private:
    int x;
};
 
struct D : B {
    using B::m;               // D::m is public
    int get_n() { return n; } // B::n is accessible here, but not outside
//  int get_x() { return x; } // ERROR, B::x is inaccessible here
 private:
    using B::f;               // D::f is private
};
 
int main() {
    D d;

//  d.x = 2; // ERROR, private
//  d.n = 2; // ERROR, protected
    d.m = 2; // protected B::m is accessible as D::m

    d.set_n(2); // calls B::set_n(int)
    cout << d.get_n() << endl; // output: 2

//  d.f();   // ERROR, B::f is inaccessible as D::f


    B& b = d; // b references d and "views" it as being type B

//  b.x = 3; // ERROR, private
//  b.n = 3; // ERROR, protected
//  b.m = 3; // ERROR, B::m is protected

    b.set_n(3); // calls B::set_n(int)
//  cout << b.get_n(); // ERROR, 'struct B' has no member named 'get_n'

    b.f();   // calls B::f()
    return 0;
}

Referências

Notas

Bibliografia