Access Modifiers for Classes or Interfaces in Java

Last Updated : 17 Apr, 2025

Access modifiers in Java are used to control the visibility of the variables, classes, and methods within a class or package. There are different types of access modifiers that are used to define the accessibility in different ways. The access modifiers strictly enforce the level of accessibility, and these are defined by different keywords.

Example: Access modifiers with interface and classes.

Java

// Java program demonstrating access modifiers 
// with a class and an interface

// Note: A .java file can have only one public top-level class or interface,
// and it must match the name of the file. Other classes or interfaces cannot be declared public.

// Public interface accessible anywhere
interface Display {

    // Public method accessible anywhere
    public void showPublic();

   
    // Default method (introduced in Java 8)
    // is accessible to any class that implements the interface, 
    // regardless of the package.
    default void showDefault() {
        System.out.println("Method in the interface.");
    }
}

// Public class implementing the interface
class AccessModifiers implements Display {

    // Public method implementation accessible anywhere
    public void showPublic() {
        System.out.println("This is a public method.");
    }

    // Protected method (accessible within the same package and subclasses)
    protected void showProtected() {
        System.out.println("This is a protected method.");
    }

    // Private method (accessible only within this class)
    private void showPrivate() {
        System.out.println("This is a private method.");
    }

    // Package-private default method (accessible within the same package)
    void showPackagePrivate() {
        System.out.println("This is a package-private method.");
    }

    // Public method to demonstrate calling private, 
    // protected, and package-private methods
    public void demonstrateAccess() {
        
        // Accessible within the class
        showPrivate(); 

        // Accessible within the class
        showProtected(); 

        // Accessible within the class
        showPackagePrivate(); 
    }
}

// Main class
public class Geeks 
{

    public static void main(String[] args) {
        
        // Create an instance of AccessModifiers
        AccessModifiers obj = new AccessModifiers();

        // Access public method
        obj.showPublic();

        // Access default method from the interface
        obj.showDefault();

        // Demonstrate access to private, protected, 
        // and package-private methods
        obj.demonstrateAccess();
    }
}

Output

This is a public method.
Method in the interface.
This is a private method.
This is a protected method.
This is a package-private method.

Explanation: In the above code, we have different classes and interfaces, and we can execute them in the local system to check their accessibility level one by one. For better understanding, refer to the table mentioned below explaining the accessibility level of modifiers with classes and interface.

Different Access Modifiers

1. public Access Modifier

The public modifier provides the highest access among all the modifiers. We can access it anywhere in the package. The public modifier allows to use the variable, methods and class to acess in the same package.

Example: Demonstration of public access modifier in Java.

Java

// Demonstrating the pubic access modifier in Java
import java.io.*;

// public class
public class Geeks
{
    // public method
    public static void main (String[] args) {
        
        System.out.println("Hello Geeks");
    }
}

Output

Hello Geeks

2. protected Access Modifier

The protected modifier in Java allows the class, method and variable to Accessible within the same package and subclasses.

Example: Demonstrating the protected modifier in Java.

Java

// Demonstrating the protected modifier in Java
class BaseClass {
    
    // prptected method 
    protected void Msg() {
        
        System.out.println("This is the protected method.");
    }
}

public class Geeks{
    
    public static void main(String []args){
      
      // Creating the object of BaseClass
      BaseClass obj = new BaseClass();
      
      // Calling the protected method from base class
      obj.Msg();
    }
        
}

Output

This is the protected method.

3. private Access Modifier

The private access modifier is used with method, class and variable and if the it can be only accessible in the class where it is defined.

Example: Demonstrating the private access modifier.

Java

// Demonstrating the private modifier in Java
class BaseClass {
    
    // Private variable
    private String msg = "Hello Geeks";
    
    // public method having private varialbe
    public void Msg() {
        
        System.out.println("Private variable having message: "+ msg);
    }
}

public class Geeks {
    
    public static void main(String []args){
      
      // Creating the object of BaseClass
      BaseClass obj = new BaseClass();
      
      //Calling the method from base class
      obj.Msg();
    }
        
}

Output

Private variable having message: Hello Geeks

4. default Access Modifier

When the modifier is not define then it automatically specified default method or package private. The default having the accessibility within the same package. If the the variable, method or class having no modifier then it considered as defualt modifier

Example: Demonstrating the default modifier in Java

Java

// Demonstrating the default modifier in Java
class BaseClass {
    
    // default method 
     void Msg() {
        
        System.out.println("This method having defualt modifier.");
    }
}

public class Geeks
{
    public static void main(String []args){
      
      // Creating the object of BaseClass
      BaseClass obj = new BaseClass();
      
      // Calling the method having defualt modifier from base class
      obj.Msg();
    }
        
}

Output

This method having defualt modifier.

Access Modifiers Accessibility Level For Classes And Interface

Modifier	Class	Interface
public	Accessible from anywhere from different classes.	Similar to Class, accessible anywhere from different classes.
default	It is only accessible within the same package.	Accessible within the same package.
protected	Accessible within the same package and subclasses.	Not applicable to top-level interfaces.
private	Accessible only in the class where it is defined	Not applicable to top-level interfaces and accessible in the same class or interface where it is defined.

Important Points:

The top-level classes and interface and nested classes have different accessibility levels, as the .java file cannot be directly declared private or protected.
The class and interface are accessible only within the same package.
The .java file can have only one public top-level class or interface, and it must have the same name as the file.
We cannot declare a class/interface with private or protected access modifiers.
The nested interface which are created inside a class or inside another interface can have different modifiers the top level interfaces have some limitations of the modifiers they use. But nested interface have flexibility to use.

Access Modifiers for Classes or Interfaces in Java

kartik

Improve

Article Tags :

Practice Tags :

Access Modifiers for Classes or Interfaces in Java

Different Access Modifiers

1. public Access Modifier

2. protected Access Modifier

3. private Access Modifier

4. default Access Modifier

Access Modifiers Accessibility Level For Classes And Interface

Similar Reads