What is the difference between public, protected, package-private and private in Java?
The official tutorial may be of some use to you.
Class | Package | Subclass (same pkg) | Subclass (diff pkg) | World | |
---|---|---|---|---|---|
public | + | + | + | + | + |
protected | + | + | + | + | |
no modifier | + | + | + | ||
private | + |
What are public, private and protected in object oriented programming?
They are access modifiers and help us implement Encapsulation (or information hiding). They tell the compiler which other classes should have access to the field or method being defined.
private
- Only the current class will have access to the field or method.
protected
- Only the current class and subclasses (and sometimes also same-package classes) of this class will have access to the field or method.
public
- Any class can refer to the field or call the method.
This assumes these keywords are used as part of a field or method declaration within a class definition.
What is the difference between public, private, and protected?
You use:
public
scope to make that property/method available from anywhere, other classes and instances of the object.private
scope when you want your property/method to be visible in its own class only.protected
scope when you want to make your property/method visible in all classes that extend current class including the parent class.
If you don't use any visibility modifier, the property / method will be public.
More: (For comprehensive information)
- PHP Manual - Visibility
In C#, what is the difference between public, private, protected, and having no access modifier?
Access modifiers
From docs.microsoft.com:
public
The type or member can be accessed by any other code in the same assembly or another assembly that references it.
private
The type or member can only be accessed by code in the same class or struct.
protected
The type or member can only be accessed by code in the same class or struct, or in a derived class.
private protected
(added in C# 7.2)The type or member can only be accessed by code in the same class or struct, or in a derived class from the same assembly, but not from another assembly.
internal
The type or member can be accessed by any code in the same assembly, but not from another assembly.
protected internal
The type or member can be accessed by any code in the same assembly, or by any derived class in another assembly.
When no access modifier is set, a default access modifier is used. So there is always some form of access modifier even if it's not set.
static
modifier
The static modifier on a class means that the class cannot be instantiated, and that all of its members are static. A static member has one version regardless of how many instances of its enclosing type are created.
A static class is basically the same as a non-static class, but there is one difference: a static class cannot be externally instantiated. In other words, you cannot use the new keyword to create a variable of the class type. Because there is no instance variable, you access the members of a static class by using the class name itself.
However, there is a such thing as a static constructor. Any class can have one of these, including static classes. They cannot be called directly & cannot have parameters (other than any type parameters on the class itself). A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced. Looks like this:
static class Foo()
{
static Foo()
{
Bar = "fubar";
}
public static string Bar { get; set; }
}
Static classes are often used as services, you can use them like so:
MyStaticClass.ServiceMethod(...);
What is the difference between protected and private?
private
- only available to be accessed within the class that defines them.
protected
- accessible in the class that defines them and in other classes which inherit from that class.
What is the difference between public, private, and protected inheritance in C++?
To answer that question, I'd like to describe member's accessors first in my own words. If you already know this, skip to the heading "next:".
There are three accessors that I'm aware of: public
, protected
and private
.
Let:
class Base {
public:
int publicMember;
protected:
int protectedMember;
private:
int privateMember;
};
- Everything that is aware of
Base
is also aware thatBase
containspublicMember
. - Only the children (and their children) are aware that
Base
containsprotectedMember
. - No one but
Base
is aware ofprivateMember
.
By "is aware of", I mean "acknowledge the existence of, and thus be able to access".
next:
The same happens with public, private and protected inheritance. Let's consider a class Base
and a class Child
that inherits from Base
.
- If the inheritance is
public
, everything that is aware ofBase
andChild
is also aware thatChild
inherits fromBase
. - If the inheritance is
protected
, onlyChild
, and its children, are aware that they inherit fromBase
. - If the inheritance is
private
, no one other thanChild
is aware of the inheritance.
what is the difference between protected and private protected in c#?
It's about the acces modifier. More specific: inheritance and multiple assemblies. Consider the following:
For normal protected
(explained with along private
):
class Base
{
private bool X;
protected bool Y;
}
class A : Base
{
public void Foo()
{
X = false; //error: cannot access private member.
Y = true; //can access protected member, but only from classes with `: Base`
}
}
class B
{
public void Foo()
{
A a = new A();
a.X = false; //error: cannot access private member.
a.Y = false; //error: cannot access protected member.
}
}
Now the difference with private protected
is that it must live in the same assembly to be accessible:
So:
class A : Base
{
public void Foo()
{
X = false; //error: cannot access private member.
Y = true; //can access protected member, but only from classes with `: Base` AND
//they need to be defined in the same assembly as Base
}
}
Is valid, but only if both A
and Base
are compiled in the same assembly/dll/exe etc.
Now, since that clear, when would you use
an actual private protected
?
A lot can be said about this. Some (including me) would argue that the use of private protected
is an anti-pattern, because in my oppinion it's closly related to the friend keyword. And I must say, although in contradiction to friend
, private protected
keeps "the dirt" isolated, it still is arbitrary behavior, logic, depending on the location of it's definition.
Having said that the question remains, when to use it. You might be surprised I punctually used it once, and it was quite helpful.
Consider the following case:
- Having a conceptual, decorator pattern styled code base, for example some
graphical object
system. - All the objects will be "renderable", in various ways.
- Because you have a lot, it comes in handy to create a base class which only you are using for convinience.
- You don't want to let other user be using this functionality, since it's not well documented and really specifi to your implementation
- The classes themselves are public.
.... then I would use private protected
;-)
Related Topics
Check If PHP Session Has Already Started
Convert from MySQL Datetime to Another Format With PHP
PHP - Concatenate or Directly Insert Variables in String
How to Use PHP Serialize() and Unserialize()
How to Get a Variable Name as a String in PHP
Open_Basedir Restriction in Effect. File(/) Is Not Within the Allowed Path(S):
A Simple Program to Crud Node and Node Values of Xml File
How to Prevent Duplicate Usernames When People Register
Matching Unicode Letter Characters in Pcre/PHP
MySQL Query to Get Column Names
Can PHP Curl Retrieve Response Headers and Body in a Single Request
How to Make Asynchronous Http Requests in PHP
MySQL VS MySQLi When Using PHP
PHP - Floating Number Precision
How to Maintain a "Version For the Server" - With Only Config Files Changed, in Git
Filter/Remove Rows Where Column Value Is Found More Than Once in a Multidimensional Array