What are theaccess modifiersallowed formethodsin aninterface?

Related Concepts: Interface Members, Access Modifiers, Implicit Public Access, Design Principles, Contracts

Direct Answer

Interface methods are implicitly public; no other access modifiers are allowed. This design promotes loose coupling and ensures well-defined contracts.

Key Concepts Explained

Interfaces Define Contracts

Interfaces establish a contract that any class implementing the interface must adhere to. This contract needs to be publicly accessible so any class, regardless of its location or relationship to the interface, can understand and utilize it. Making interface members public ensures this universal accessibility. Hiding interface members would defeat the purpose of a public agreement between classes.

Explicit `public` Keyword is Redundant

While you can explicitly add the public keyword to interface methods, it’s unnecessary. The public accessibility is already implied. Most style guides recommend omitting the redundant public keyword for cleaner and more concise code.

Only Public is Allowed

The compiler will reject any attempt to apply non-public access modifiers (such as private, protected, or internal) to interface methods. This is because the core purpose of an interface is to define a publicly accessible contract. Restricting visibility with these modifiers would contradict this fundamental principle.

Focus on “What,” Not “How”

This design reinforces the idea that interfaces define what an object can do, not how it does it (which is the role of the implementing class). Interfaces focus on defining capabilities, not implementation details. The how is left to the individual classes that implement the interface. This separation promotes flexibility and allows for multiple, diverse implementations of the same interface.

Practical Application and Interview Insights

Emphasize the “Contract” Nature

When discussing this topic, emphasize the “contract” nature of interfaces. Explain that hiding interface members would defeat the purpose of a public agreement between classes. Mention how this differs from abstract classes, where different access modifiers can control the visibility of methods within an inheritance hierarchy. Briefly touch upon how the implicit public access simplifies implementation and usage of interfaces across different assemblies.

Example Scenario:

“In one of my previous projects, we were developing a plugin system for a data analysis application. We used interfaces to define the contract between the core application and the plugins. For example, we had an IDataSource interface with a GetData() method. This interface acted as the agreement: any plugin wanting to provide data had to implement this interface and make its GetData() method publicly available. If we had used private or protected, the core application wouldn’t be able to access the data from the plugins, breaking the entire integration. This is different from abstract classes, which we used for defining some common base functionality within our core application. In those cases, we used protected members to provide some methods only to derived classes within our application’s internal structure. Because our plugin interfaces were implicitly public, we could easily distribute them across different assemblies without worrying about visibility issues, making plugin development incredibly smooth.”

Code Sample (C#)

// Define an interface
interface IExample
{
    // Implicitly public method
    void DoSomething();

    // Explicitly public (redundant but allowed)
    public void DoSomethingElse();

    // This will cause a compile-time error - invalid access modifier
    // private void DoSomethingSecret();
}