How can you access the class if it is declared without any access modifiers?

Java provides a number of access modifiers to set access levels for classes, variables, methods, and constructors. The four access levels are −

• Visible to the package, the default. No modifiers are needed.
• Visible to the class only (private).
• Visible to the world (public).
• Visible to the package and all subclasses (protected).

Default Access Modifier - No Keyword

Default access modifier means we do not explicitly declare an access modifier for a class, field, method, etc.

A variable or method declared without any access control modifier is available to any other class in the same package. The fields in an interface are implicitly public static final and the methods in an interface are by default public.

Example

Variables and methods can be declared without any modifiers, as in the following examples −

String version = "1.5.1";

boolean processOrder() {
   return true;
}

Private Access Modifier - Private

Methods, variables, and constructors that are declared private can only be accessed within the declared class itself.

Private access modifier is the most restrictive access level. Class and interfaces cannot be private.

Variables that are declared private can be accessed outside the class, if public getter methods are present in the class.

Using the private modifier is the main way that an object encapsulates itself and hides data from the outside world.

Example

The following class uses private access control −

public class Logger {
   private String format;

   public String getFormat() {
      return this.format;
   }

   public void setFormat(String format) {
      this.format = format;
   }
}

Here, the format variable of the Logger class is private, so there's no way for other classes to retrieve or set its value directly.

So, to make this variable available to the outside world, we defined two public methods: getFormat(), which returns the value of format, and setFormat(String), which sets its value.

Public Access Modifier - Public

A class, method, constructor, interface, etc. declared public can be accessed from any other class. Therefore, fields, methods, blocks declared inside a public class can be accessed from any class belonging to the Java Universe.

However, if the public class we are trying to access is in a different package, then the public class still needs to be imported. Because of class inheritance, all public methods and variables of a class are inherited by its subclasses.

Example

The following function uses public access control −

public static void main(String[] arguments) {
   // ...
}

The main() method of an application has to be public. Otherwise, it could not be called by a Java interpreter (such as java) to run the class.

Protected Access Modifier - Protected

Variables, methods, and constructors, which are declared protected in a superclass can be accessed only by the subclasses in other package or any class within the package of the protected members' class.

The protected access modifier cannot be applied to class and interfaces. Methods, fields can be declared protected, however methods and fields in a interface cannot be declared protected.

Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it.

Example

The following parent class uses protected access control, to allow its child class override openSpeaker() method −

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // implementation details
   }
}

class StreamingAudioPlayer extends AudioPlayer {
   boolean openSpeaker(Speaker sp) {
      // implementation details
   }
}

Here, if we define openSpeaker() method as private, then it would not be accessible from any other class other than AudioPlayer. If we define it as public, then it would become accessible to all the outside world. But our intention is to expose this method to its subclass only, that’s why we have used protected modifier.

Access Control and Inheritance

The following rules for inherited methods are enforced −

• Methods declared public in a superclass also must be public in all subclasses.

• Methods declared protected in a superclass must either be protected or public in subclasses; they cannot be private.

  When we do not mention any access modifier, it is called default access modifier. The scope of this modifier is limited to the package only. This means that if we have a class with the default access modifier in a package, only those classes that are in this package can access this class. No other class outside this package can access this class. Similarly, if we have a default method or data member in a class, it would not be visible in the class of another package. Lets see an example to understand this:

  Default Access Modifier Example in Java

  To understand this example, you must have the knowledge of packages in java.

  In this example we have two classes, Test class is trying to access the default method of Addition class, since class Test belongs to a different package, this program would throw compilation error, because the scope of default modifier is limited to the same package in which it is declared.
  Addition.java

  package abcpackage;
  
  public class Addition {
     /* Since we didn't mention any access modifier here, it would
      * be considered as default.
      */
     int addTwoNumbers(int a, int b){
  	return a+b;
     }
  }

  Test.java

  package xyzpackage;
  
  /* We are importing the abcpackage
   * but still we will get error because the
   * class we are trying to use has default access
   * modifier.
   */
  import abcpackage.*;
  public class Test {
     public static void main(String args[]){
  	Addition obj = new Addition();
          /* It will throw error because we are trying to access
           * the default method in another package
           */
  	obj.addTwoNumbers(10, 21);
     }
  }

  Output:

  Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
  The method addTwoNumbers(int, int) from the type Addition is not visible
  at xyzpackage.Test.main(Test.java:12)

  2. Private access modifier

  The scope of private modifier is limited to the class only.

  1. Private Data members and methods are only accessible within the class
  2. Class and Interface cannot be declared as private
  3. If a class has private constructor then you cannot create the object of that class from outside of the class.

  Let’s see an example to understand this:

  Private access modifier example in java

  This example throws compilation error because we are trying to access the private data member and method of class ABC in the class Example. The private data member and method are only accessible within the class.

  class ABC{  
     private double num = 100;
     private int square(int a){
  	return a*a;
     }
  }  
  public class Example{
     public static void main(String args[]){  
  	ABC obj = new ABC();  
  	System.out.println(obj.num); 
  	System.out.println(obj.square(10));
     }  
  }

  Output:

  Compile - time error

  3. Protected Access Modifier

  Protected data member and method are only accessible by the classes of the same package and the subclasses present in any package. You can also say that the protected access modifier is similar to default access modifier with one exception that it has visibility in sub classes.
  Classes cannot be declared protected. This access modifier is generally used in a parent child relationship.

  Protected access modifier example in Java

  In this example the class Test which is present in another package is able to call the

  package xyzpackage;
  
  /* We are importing the abcpackage
   * but still we will get error because the
   * class we are trying to use has default access
   * modifier.
   */
  import abcpackage.*;
  public class Test {
     public static void main(String args[]){
  	Addition obj = new Addition();
          /* It will throw error because we are trying to access
           * the default method in another package
           */
  	obj.addTwoNumbers(10, 21);
     }
  }

  2 method, which is declared protected. This is because the Test class extends class Addition and the protected modifier allows the access of protected members in subclasses (in any packages).
  Addition.java

  package abcpackage;
  public class Addition {
  
     protected int addTwoNumbers(int a, int b){
  	return a+b;
     }
  }

  Test.java

  package xyzpackage;
  import abcpackage.*;
  class Test extends Addition{
     public static void main(String args[]){
  	Test obj = new Test();
  	System.out.println(obj.addTwoNumbers(11, 22));
     }
  }

  Output:

  33

  4. Public access modifier

  The members, methods and classes that are declared public can be accessed from anywhere. This modifier doesn’t put any restriction on the access.

  What happens if you don't declare access modifiers?

  When no access modifier is used, then by default the member of a class is public within its own package, but cannot be accessed outside of its package. protected applies only when inheritance is involved.

  What access modifier is used when one is not declared for classes?

  Access specifiers define the visibility of the class. If no keyword is mentioned then that is default access modifier. Four modifiers in Java include public, private, protected and default.

  What is access modifiers for the method if you not given any access modifiers?

  If you don't use any modifier, it is treated as default by default. The default modifier is accessible only within package. It cannot be accessed from outside the package. It provides more accessibility than private.

  What access modifiers that the class is accessible by any other class?

  Access Modifiers.