modificateurs d'accès

Les modificateurs d'accès (ou spécificateurs d'accès ) sont des mots-clés réservés dans les langages orientés objet qui définissent l'accessibilité des classes , des méthodes et autres membres. Les modificateurs d'accès constituent une partie spécifique de la syntaxe des langages de programmation et servent à faciliter l' encapsulation des composants.

En C++ , il n'existe que trois modificateurs d'accès. C# en propose six , tandis que Java dispose de quatre modificateurs d'accès, mais de trois mots-clés à cet effet. En Java, l'absence de mot-clé `private` entraîne par défaut l'utilisation du modificateur `package-private`.

Lorsqu'une classe est déclarée publique, elle est accessible aux autres classes définies dans le même package, ainsi qu'à celles définies dans d'autres packages. C'est le spécificateur le plus couramment utilisé pour les classes. Cependant, une classe ne peut pas être déclarée privée. Si aucun spécificateur d'accès n'est spécifié, les restrictions d'accès par défaut sont appliquées. La classe est accessible aux autres classes du même package, mais inaccessible aux classes extérieures à ce package. Lorsqu'une classe est dite inaccessible, cela signifie simplement qu'il est impossible de créer un objet de cette classe ou de déclarer une variable de ce type. Le spécificateur d'accès protégé ne peut pas non plus être appliqué à une classe.

Noms des mots-clés

C++ utilise trois modificateurs : `private` public, protected`private` et private`allow`. C# possède les modificateurs public`private`, protected` internalprivate`, ` allow` private, protected internal`allow`, private protected`allow` et ` fileallow`. Java possède public`private`, package`allow` protected, `allow` et private`allow` ; package`allow` est le modificateur par défaut, utilisé si aucun autre modificateur d'accès n'est spécifié. La signification de ces modificateurs peut varier d'un langage à l'autre. Le tableau ci-dessous compare ces mots-clés, classés du plus restrictif au plus permissif, et leur signification dans ces trois langages. Leur visibilité s'étend de la classe elle-même au package où la classe est définie, jusqu'à une autorisation d'accès générale. Le niveau d'accès maximal est indiqué dans le tableau ci-dessous.

En Swift, il existe cinq niveaux d'accès différents, relatifs à la fois au fichier source dans lequel l'entité est définie et au module contenant ce fichier source.

Mot-clé	C#	C++	Java	Rapide
`private`	classe	cours et/ou cours entre amis	classe	déclaration englobante uniquement + extensions de déclaration dans le même fichier
`fileprivate`	-	-	-	même fichier
`file`	même fichier	-	-	-
`private protected`	classes dérivées dans le même assemblage	-	-	-
`protected internal`	classes d'assemblage et/ou dérivées identiques	-	-	-
`protected`	classes dérivées	classes dérivées et/ou classes amies	classes dérivées et/ou au sein du même package	-
`package`	-	-	dans son emballage	-
`internal`	même assemblage	-	-	même module
`public`	tout le monde	tout le monde	tout le monde	tout le monde
`open`	-	-	-	tout le monde + sous-classe en dehors du module + surcharge en dehors du module

Exemple

C++

); } }; // Derived étend Base avec l'héritage public struct Derived : public Base { private : using Base :: f ; // Derived::f est privé public : using Base :: m ; // Derived::m est public// Base::n est accessible ici, mais pas en dehors de [[ nodiscard ]] int get_n () const noexcept { return n ; }// ERREUR, Base::x est inaccessible ici // int get_x() const noexcept { // return x; // } }; int main ( int argc , char * argv []) { Derived d ;// dx = 2; // ERREUR, privé // dn = 2; // ERREUR, protégé d . m = 2 ; // protégé Base::m est accessible en tant que Derived::md.set_n ( 2 ) ; // appelle Base::set_n(int) std :: println ( "{}" , d.get_n ( ) ) ; // sortie : 2// df(); // ERREUR, Base::f est inaccessible en tant que Derived::fBase & b = d ; // b fait référence à d et le « considère » comme étant de type Base// bx = 3 ; // ERREUR, privé // bn = 3 ; // ERREUR, protégé // bm = 3 ; // ERREUR, Base::m est protégéb.set_n ( 3 ); // appelle Base::set_n(int) // std::println("{}", b.get_n()); // ERREUR, 'struct Base' ne possède pas de membre nommé 'get_n 'b.f ( ); // appelle Base::f( ) return 0 ; }