Access modifiers

{{Short description|Keywords in object-oriented programming languages}} {{refimprove|date=March 2013}}

'''Access modifiers''' (or '''access specifiers''') are reserved keywords in object-oriented languages that set the accessibility of classes, methods, and other members. Access modifiers are a specific part of programming language syntax used to facilitate the encapsulation of components.{{sfn|Mayo|2002|pp=199}}

In C++, there are only three access modifiers. C# extends the number of them to six,<ref>{{Cite web|url=https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers|title=Access Modifiers - C# Programming Guide|last=Wagner|first=Bill|authorlink=Bill Wagner (software)|date=|website=docs.microsoft.com|language=en-us|archive-url=|archive-date=|access-date=2020-01-13}}</ref> while Java has four access modifiers, but three keywords for this purpose. In Java, having no keyword before defaults to the package-private modifier.

When the class is declared as public, it is accessible to other classes defined in the same package as well as those defined in other packages. This is the most commonly used specifier for classes. However, a class itself cannot be declared as private. If no access specifier is stated, the default access restrictions will be applied. The class will be accessible to other classes in the same package but will be inaccessible to classes outside the package. When we say that a class is inaccessible, it simply means that we cannot create an object of that class or declare a variable of that class type. The protected access specifier too cannot be applied to a class.

UML class diagram with access modifiers.svg

== Names of keywords == C++ uses the three modifiers called ''<code>public</code>'', ''<code>protected</code>'', and ''<code>private</code>''.<ref>{{Cite web|url=https://en.cppreference.com/w/cpp/language/access|title=Access specifiers|last=|first=|date=|website=en.cppreference.com|archive-url=|archive-date=|access-date=2020-01-13}}</ref> C# has the modifiers ''<code>public</code>'', ''<code>protected</code> '',''<code>internal</code>'', ''<code>private</code>'', ''<code>protected internal</code>'', ''<code>private protected</code>'', and ''<code>file</code>''.<ref>{{cite web |title=Access Modifiers (C# Reference) |url=https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/access-modifiers |website=learn.microsoft.com |publisher=Microsoft |access-date=2023-02-08 |date=2022-09-27}}</ref> Java has ''<code>public</code>'', ''<code>package</code>'', ''<code>protected</code>'', and ''<code>private</code>''; ''<code>package</code>'' is the default, used if no other access modifier keyword is specified. The meaning of these modifiers may differ from one language to another. A comparison of the keywords, ordered from the most restrictive to the most open, and their meaning in these three languages follows. Their visibility ranges from the same class to the package where the class is defined to a general access permission. Below, the maximal access is written into the table.

In Swift, there are five different access levels relative to both the source file in which the entity is defined and the module containing that source file.<ref>{{Cite web|title=Access Control — The Swift Programming Language (Swift 5.3)|url=https://docs.swift.org/swift-book/LanguageGuide/AccessControl.html|access-date=2021-02-08|website=docs.swift.org}}</ref>

{| class="wikitable" |- ! Keyword !! C# !! C++ !! Java !! Swift |- | '''<code>private</code>''' || class || class ''and/or'' friend classes || class || enclosing declaration only + extensions of declaration in same file |- | '''<code>fileprivate</code>''' || - || - || - || same file |- | '''<code>file</code>''' || same file || - || - || - |- | '''<code>private protected</code>''' || derived classes in the same assembly || - || - || - |- | '''<code>protected internal</code>''' || same assembly ''and/or'' derived classes || - || - || - |- | '''<code>protected</code>''' || derived classes || derived classes ''and/or'' friend classes || derived classes ''and/or'' within same package || - |- | '''<code>package</code>''' || - || - || within its package || - |- | '''<code>internal</code>''' || same assembly || - || - || same module |- | '''<code>public</code>''' || everybody || everybody || everybody || everybody |- | '''<code>open</code>''' || - || - || - || everybody + subclass outside module + override outside module |}

== Example == === C++ === <syntaxhighlight lang="cpp"> import std;

// default access modifier inside struct is public // default access modifier inside class is private struct Base { private: int x; protected: // Base::m, Base::n are protected int m; int n; public: void set_n(int v) noexcept { n = v; }

void f() { std::println("calling Base::f()"); } }; // Derived extends Base with public inheritance struct Derived : public Base { private: using Base::f; // Derived::f is private public: using Base::m; // Derived::m is public

// Base::n is accessible here, but not outside nodiscard int get_n() const noexcept { return n; }

// ERROR, Base::x is inaccessible here // int get_x() const noexcept { // return x; // } }; int main(int argc, char* argv[]) { Derived d;

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

d.set_n(2); // calls Base::set_n(int) std::println("{}", d.get_n()); // output: 2

// d.f(); // ERROR, Base::f is inaccessible as Derived::f

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

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

b.set_n(3); // calls Base::set_n(int) // std::println("{}", b.get_n()); // ERROR, 'struct Base' has no member named 'get_n'

b.f(); // calls Base::f() return 0; } </syntaxhighlight>

== References ==

=== Notes === {{Reflist}}

=== Bibliography === *{{citation|url=https://books.google.com/books?id=XdHYaE-Il9gC|title=C Sharp Unleashed|first=Joseph|last=Mayo|publisher=Sams publishing|year=2002|isbn=9780672321221}}

Category:Programming constructs