What Is the Default Access Specifier in Java

What is the default access specifier in Java?

The default visibility is known as “package-private” (though you can't use this explicitly), which means the field will be accessible from inside the same package to which the class belongs.

As mdma pointed out, it isn't true for interface members though, for which the default is "public".

See Java's Access Specifiers

What is the default access modifier in Java?

From Java documentation

If a class has no modifier (the default, also known as package-private), it is visible only within its own package (packages are named groups of related classes — you will learn about them in a later lesson.)

At the member level, you can also use the public modifier or no modifier (package-private) just as with top-level classes, and with the same meaning.

Full story you can read here (_{Which I wrote recently}):

http://codeinventions.blogspot.com/2014/09/default-access-modifier-in-java-or-no.html

Can we changed the access specifier of a method from private to default just for the sake of method level unit testing

'default', i.e., the absence of a modifier, means package private in Java. Only classes in the same package can access it. Sometimes it is desirable to test an internal method meant for private use of that class in a unit test separate from the rest of that class in order to cover all code paths with clear, concise, and simple tests. When you do this (and the result is cleaner test code that can be maintained with more ease) it is fine to mark that method as package private.

This is not an uncommon strategy. Because the only classes who can use this method must reside in the same package, you still have plenty of control over its use.

Personally I would recommend only doing this for static utility methods that do not depend on the state of their parent class. It is also a very useful technique for testing static methods in abstract classes.

Note that in some cases the need to test private methods may point to the need to break out that part of the class into a separate class instead. This discussion shows some of the common standpoints varying from strict OOP adherence to pragmatism. You often have the possibility to break out that method and make it into a proper public static utility, but that doesn't always make sense, and it doesn't necessarily lead to easier maintained code.

Why can't we specify default access modifier for a class

The default access modifier in Java can be used by just omitting any access modifier. Java 8 introduced a new default keyword used to provide a default implementation for an interface's method but, despite its confusing name and location in the method's declaration, it has nothing to do with access modifiers.

Difference between the default access specifier and protected access specifier in java

The protected specifier allows access by all subclasses of the class in question, whatever package they reside in, as well as to other code in the same package. The default specifier allows access by other code in the same package, but not by code that is in subclasses residing in different packages. See Java Language Specification Section 6.6.

EDIT: Per request of Michael Schmeißer (so others don't have to read through the comments or follow a link to find this): all members of interfaces are implicitly public. It is, in fact, a compile-time error to specify any access specifier for an interface member other than public (although no access specifier at all defaults to public access). Here's the full set of rules from the JLS for class members (see the above link for the rules for packages, top-level classes and interfaces, and arrays):

A member (class, interface, field, or method) of a reference (class, interface, or array) type or a constructor of a class type is accessible only if the type is accessible and the member or constructor is declared to permit access:

• If the member or constructor is declared public, then access is permitted.

• All members of interfaces are implicitly public.

• Otherwise, if the member or constructor is declared protected, then access is permitted only when one of the following is true:

• Access to the member or constructor occurs from within the package containing the class in which the protected member or constructor is declared.

• Access is correct as described in §6.6.2. (This clause refers to the rules that allow derived classes to access protected members of superclasses; §6.6.2 starts: "A protected member or constructor of an object may be accessed from outside the package in which it is declared only by code that is responsible for the implementation of that object." It then elaborates on that.)

• Otherwise, if the member or constructor is declared private, then access is permitted if and only if it occurs within the body of the top level class (§7.6) that encloses the declaration of the member or constructor.

• Otherwise, we say there is default access, which is permitted only when the access occurs from within the package in which the type is declared.

Default access modifier for a Java constructor

Constructors are the same as methods in this respect - if you don't give an explicit public, private or protected then the constructor gets the default "package private" visibility. It can be called from within the same class or from any other class in the same package, but not from subclasses in a different package (so if a class has only package-visible constructors then any subclasses must be in the same package).

A private constructor prevents any other class from instantiating this one, but you can have a public static factory method within the class that calls its own private constructor. This is a common pattern for things like singletons.

Default access modifier for interface methods in Java 9?

The Java 9 Language Specification says in §9.4::

A method in the body of an interface may be declared public or private (§6.6). If no access modifier is given, the method is implicitly public. It is permitted, but discouraged as a matter of style, to redundantly specify the public modifier for a method declaration in an interface.

Unfortunately, I can't find a link that does not lead to a PDF, diffing the old and new JLS.

Protected and default modifier Java

Default access modifier (no keyword) is more restrictive than the protected access modifier, meaning when a method has a protected access modifier it's only visible to classes in the same package and sub-classes.
On the other hand, (no keyword) access modifier is accessible only for classes in the same package.
Another thing that you have to know, is one of the overriding rules is that the overridden method must have the same or less-restrictive access modifier.

Rules of overriding a method:

1. Only inherited methods are overridden
2. Method in child must have the same signature as the method in the parent
3. Final, private and static methods cannot be overridden
4. Must have the same return type or sub-type
5. Access-modifier must be less-restrictive than the one in the parent
6. Must not throw new or broader checked exceptions

What is the default access level for methods in a public abstract class in Java?

False, let's see with a quick example:

package apackage;

public abstract class AbstractFoo {

  //A method with default visibility
  abstract void bar();

}

A quick implementation :

public class Foo extends AbstractFoo {

  @Override
  void bar() {}
}

Now, in another package :

public static void main(String[] args) throws Exception{

  AbstractFoo something=new Foo();
  something.bar();//Compiler complains here

Compiler complains about visibility. So the default visibility for methods is package protected, even if the class is public abstract.

---

Related Topics