This question already has answers here:
What is the difference between public, protected, package-private and private in Java?
(30 answers)
Closed 9 years ago.
Edited to fix being marked as duplicate or to be more clear on why it appears to be a duplicate. At the time I did not know that package and default where the same thus reason for this post.
now I going through exam questions in preparation for my Java exam and I have a question asking me to explain access modifiers and its asking me about a Package modifier.
I can find info on private, Protected, public and default but can't find anything on Package.
can someone please give me an answer or link me to an article about it?
package-private is not a real modifier. You can't type package-private and get the system to recognize it as an access modifier. It's really the default, made by not including any other modifiers.
It means that the given members can only be accessed in the same package.
For example, com.hexafraction.Cow can access a member with default modifiers(none actually) in com.hexafraction.Dog, but com.foo.Crow can't access that member as it's not in the same pacakge.
In this example, the following makes up Cow:
pacakge com.hexafraction;
class Cow{
void moo(){ //no public, protected, or private modifier
System.out.println("moo!");
}
}
Edit for the future: In Java 8, package will supposedly be the modifier needed for this. Literally typing default will still not apply here.
The so-called "package-private" access level is what occurs without a modifier such as private, protected, or public.
Example:
public class Test {
int test; // package-private
}
Anything in the same package, even an unrelated class, can access it, but other classes (even subclasses of the class) outside of the package cannot access it.
This link to the Java tutorial on the subject should help.
Related
This question already has answers here:
What does "Can be package local" mean? (IDEA Inspection)
(5 answers)
Closed 6 years ago.
In IDE Some public methods are marked with a warning as Access can be package local and if I remove public form the method no warning will be shown.
Is it a good practice to do so? Should I keep them public anyways ?
If the method is only accessed within the package, the best practice is to use the "default" access modifier (by not specifying any access modifier). Further more briefly here are the four access modifiers used in Java and there accessibility levels.
default- Visible to the package. No modifiers are needed.
private- Visible to the class only.
public- Visible to the world.
protected- Visible to the package and all subclasses.
This question already has answers here:
What is the difference between public, protected, package-private and private in Java?
(30 answers)
Closed 7 years ago.
I just though about it:
if you have class like this:
public class a
{
int x = 5;
//setter & getter
}
you can't access to x from another class unless it is public.
so, that i know, but if it is like that, why do i need to use private?
the x variable cannot be accessed outside of the class without public or in other cases static reserved words.
so, the question(s):
what do i need the private for?
do i have to use the private or it doesn't really matter?
No access specifier is not the same as private.
When you have no access specifier, as in your example, the variable x is accessible in class a, but also in all other classes that are in the same package as class a.
When it is private, it is only accessible in class a, and not in any other class.
See Controlling Access to Members of a Class in Oracle's Java Tutorials.
By leaving out the access modifier, you are relying on the language's default.
For example, in C# class variables default to private.
The most used access modifiers are undoubtedly public and private.
public means you expose your field or method to every other class. This is useful for methods that are necessary to let the class perform its major function(s) and, in some cases, for constants that need to be visible.
private means you hide the member from every other class. This is useful for internal state and functions which other classes must not know about. This enforces the concept of information hiding.
The other modifiers protected and default (when no modifier is mentioned) are intermediate levels of access which can be useful in specific cases.
For example when sub classes need access to a method in the parent (or base) class and you don't want other classes to be able to access it, you can make it protected.
The default access modifier is more restricting than protected and can be used to allow access only from within the same package. This can be useful if a package contains a group of tightly related classes which need to interact among each other via methods which you don't want to expose elsewhere, not even to sub classes outside this package.
Maybe you will also benefit from this article.
this question is already answered in stackoverflow in this link.
There is 4 types of access restrictions in java:
public: the attribute is accessible for all clients
private: the attribute is only accessible from the class, not subclasses.
protected: the attribute is accessible from package and subclasses.
no modifier: the attribute is accessible from the class and package.
It's necessary to declare the scope of accessibility to encapsulate the functionality correctly.
This question already has answers here:
What is the difference between public, protected, package-private and private in Java?
(30 answers)
Closed 7 years ago.
When should one use Public over Protected in Java when creating Superclasses, if a program runs without any problems with a Protected access modifier set is there any need to change it to Public?
You should follow the Principle of Least Privilege.
This means that members should be assigned the minimum accessibility needed for the program to work.
If an unrelated class needs access, make it public. Typically this is done only for methods that provide managed access to data.
If the subclass is to be completely trusted in manipulating the data, and it needs it to work properly, you can make the member protected.
Else, make it private, so no other class can access it (without going through other more accessible methods that help encapsulate the data).
If your program works well when it's protected, then do not make it public. Consider making it private, with protected methods that access it, to encapsulate the data better.
Use protected in a superclass only if you want your variable or method to be accessed or overridden by a subclass of that superclass but you do not want that variable or method to be accessed outside of the superclass or subclass (i.e. publicly).
Use public when you want your variable or method to be accessed by any class. Note that you should rarely have public non-final variables or public mutable variables.
if a program runs without any problems with a Protected access
modifier set is there any need to change it to Public?
No, use the least accessible access modifiers for your variables and methods. Therefore if they are not required as public, do not make them public and only make them protected if they are required to be protected (i.e. required by subclasses). Otherwise make them private.
For the reasoning behind this, see the section "Item 13: Minimize the accessibility of classes and members" in Effective Java by Joshua Bloch: http://uet.vnu.edu.vn/~chauttm/e-books/java/Effective.Java.2nd.Edition.May.2008.3000th.Release.pdf
Recall what those access modifiers are doing.
public fields are fields that any class that uses this class can modify.
protected fields are fields that the class, its child classes, and classes in the same package can access.
There is greater risk involved in changing the visibility of those fields, depending on what it is your data is encapsulating. I would strongly recommend against those sorts of declarations.
This question already has answers here:
Why does the "protected" modifier in Java allow access to other classes in same package?
(6 answers)
Closed 8 years ago.
I had to shorten the title a bit. Here's the full question:
In Java which access modifier allows a member to be accessed only by the subclasses in other package or any class within the package of that member's class?
I am thinking protected but my office mate says the answer is private.
In Java which access modifier allows a member to be accessed only by the subclasses in other package or any class within the package of that member's class?
see this might help..you ! this is the scope of all access modifiers in java.
Visibility of the properties of class for different access modifiers
——————————————————————————————————————
1) From the same class
Public , Protected, Private and Default
2) From any class in same package
Public, Protected and Default
3) From a subclass in same package
Public, Protected and Default
4) From subclass outside the same package
Public and Protected (by inheritance)
5) From any non-subclass or class outside the package
Public only
It can't be private because private member methods are accessible only within the same class.
protected does not mean that a member will be accessed only by a subclass it specifically means that the classes are accessible within a package.
Your question is either wrong or you missed something on the way of asking your doubt.
Please have a look at the following :
http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
This question already has answers here:
What is the difference between public, protected, package-private and private in Java?
(30 answers)
Closed 4 years ago.
What is the difference in the accessibility of the following variables in Java?
public class Joe {
public int a;
protected int b;
private int b;
int c;
}
I'm most interested in what the last one is doing.
public: read/writable for anyone
protected: read/writable for
instances of subclasses and from within the enclosing package
private: read/writable for any instance of the class
and inner or outer (enclosing) instance
int c:
package-private, read/writable for
all classes inside same package
See the JLS for more details
EDIT: Added the comment for protected stating that access is granted from inside same package, you guys are totally right. Also added comment for private. I remember now... ;-)
Sorry for answering corrections to one previous answer but I don't have enough reputation to modify directly...
public - read/writable for anyone
protected - read/writable for
instances subclasses and all classes
inside same package
int c : package-private,
read/writable for all classes inside
same package
private - read/writable for any member of that class itself and inner classes (if any)
It is better to order the access modifiers this way, from the broadest access (public) to the narrowest (private), knowing that when going from narrow to broad, you don't lose any possibilities.
That's particularly important for "protected", where it is often misunderstood that classes in the same package can also access protected members of a class (not only its subclasses).
I try to avoid package level access completely (the last access you mention).
I like to keep classes self-contained. If another class needs access to something in my class it should be public (and it should by a method, not an attribute). Otherwise I feel you've broken encapsulation, as explained in Abstraction VS Information Hiding VS Encapsulation.
And all of these are compile time protections, they can be readily overridden through reflection at runtime.