Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/access-modifiers-for-classes-or-interfaces-in-java/ below:

Access Modifiers for Classes or Interfaces in Java

Last Updated : 07 Aug, 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.

// Package-private interface 
interface Display {

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

    // Default method Accessible to any class that implements the interface
    default void showDefault() {
        System.out.println("Method in the private interface.");
    }
}

// Package-private 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.");
    }

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

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

        // Accessible within the class
        showProtected(); 

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

// Public class (file must be named Geeks.java)
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();
    }
}

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

Explanation:

• Only one top-level class (Geeks) is declared public to match the file name Geeks.java, while Display and AccessModifiers remain package-private, which is valid in Java.
• The program demonstrates all access modifiers: public, protected, private and default (package-private) within the AccessModifiers class.
• Display interface uses a default method, introduced in Java 8, allowing interfaces to contain method implementations.
• The demonstrateAccess() method showcases internal access to private, protected and package-private methods from within the same class.
• AccessModifiers implements the Display interface and the main() method uses polymorphism to call interface and class methods.

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.

import java.io.*;

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

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.

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();
    }
}

This is the protected method.

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.

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();
    }
}

Private variable having message: Hello Geeks

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

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();
    }
}

This method having defualt modifier.

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.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4