Interface In Java

Java Functions And Methods

Java Foundation

Java Flow Control

Java Inner Classes

Java 8 Features

Java File I/o

Java Multithreading

Java Arrays And Strings

Java Exception Handling

Java Classes

Java OOP's

Java Collections Framework

In Java, an interface is a reference type similar to a class. It can contain:

Constants: Variables that are public, static, and final by default.
Abstract methods: Methods that must be implemented by any class that implements the interface.
Default methods: Methods with a default implementation (from Java 8 onwards).
Static methods: Methods that belong to the interface itself and cannot be overridden (also from Java 8 onwards).
Private methods: Used internally by default or static methods to provide code reuse (from Java 9 onwards).

NOTE:

An interface is used to achieve abstraction and multiple inheritance in Java.

Key Characteristics of an Interface

Abstract methods: All methods in an interface are abstract (unless declared as default or static). This means that they don’t have any body and must be implemented by the classes that implement the interface.
Public methods: All methods in an interface are implicitly public, meaning you don't have to specify the public modifier. For example:
```
interface MyInterface {
	// This is implicitly public and abstract
    void myMethod();  
}
```
Constants: All variables declared in an interface are implicitly public, static, and final. This means you can’t change their value after initialization.
```
interface MyInterface {
	// This is implicitly public static final
    int MY_CONSTANT = 10;  
}
```
No instance fields or constructors: An interface cannot have instance fields or constructors because it is not meant to represent a specific object’s state. It's more like a contract for other classes to follow.
Multiple inheritance: A class can implement multiple interfaces, allowing a class to inherit behavior from multiple sources. This is one of the key benefits of interfaces.

Syntax of Interface

Here's a basic example of an interface:

public interface Drawable {
	// Abstract method
    void draw();
    
    // Abstract method
    int getColor();
}

Code Example

​x
 
import java.util.*;​interface Drawable {    void draw();  // Abstract method    String getColor();  // Abstract method}​class Circle implements Drawable {    private String color = "Green";​    @Override    public void draw() {        System.out.println("Drawing a circle");    }​    @Override    public String getColor() {        return this.color;    }}​public class Test{    public static void main(String[] args)    {        Drawable d = new Circle();        d.draw();        System.out.println(d.getColor());    }}

Output

Drawing a circle
Green

In this example, the Circle class implements the Drawable interface by providing concrete implementations for the abstract methods draw() and getColor().

Why Use Interfaces?

Abstraction: Interfaces help to define a contract that implementing classes must adhere to, without specifying how the behavior should be implemented. This allows classes to be written in a more general way.
Multiple inheritance: Java allows a class to extend only one class, but it can implement multiple interfaces. This provides a way to achieve multiple inheritance of behavior in Java.
Polymorphism: Interfaces can be used polymorphically. A class that implements an interface can be referred to by a reference variable of the interface type.
```
Drawable drawable = new Circle();  // Polymorphism
drawable.draw();  // Calls the draw() method of Circle
```

Code Example

xxxxxxxxxx
 
// Multiple inheritanceinterface A {    void methodA();}​interface B {    void methodB();}​public class MyClass implements A, B {    public void methodA() {        System.out.println("Implementing methodA");    }​    public void methodB() {        System.out.println("Implementing methodB");    }}

Methods in Interfaces (Pre and Post Java 8)

Pre-Java 8:

Interfaces could contain only abstract methods (i.e., method declarations without any implementation).
```
public interface Animal {
    void sound();
}
```

Post-Java 8

Java 8 introduced default methods and static methods in interfaces, enhancing their capabilities.

Default methods: These are methods with an actual implementation inside an interface. Classes that implement the interface are not forced to override default methods, but they can if needed.
Static methods: Interfaces can also have static methods, which are called on the interface itself rather than on an instance of a class.

xxxxxxxxxx
 
public interface MyInterface {    default void start() {        System.out.println("Vehicle is starting");    }        static int add(int a, int b) {        return a + b;    }}​// If a class implements this interface, it inherits the start() method unless you chooses to override it.public class MyClass implements MyInterface {    // Inherits the default start() method    MyInterface i = new MyClass();    i.start();        // Usage    int result = MyInterface.add(5, 3); // Calls static method of interface}

Post-Java 9

Private methods: Java 9 introduced private methods in interfaces. These are used to share common code between default and static methods within the same interface.

xxxxxxxxxx
 
public interface Logger {    default void logInfo(String message) {        log(message, "INFO");    }​    default void logError(String message) {        log(message, "ERROR");    }​    private void log(String message, String level) {        System.out.println(level + ": " + message);    }}

Inheritance in Interfaces

Interfaces support multiple inheritance, allowing an interface to extend multiple interfaces:

Code Example

xxxxxxxxxx
 
interface X {    void methodX();}​interface Y {    void methodY();}​interface Z extends X, Y {    void methodZ();}​class MyClass implements Z {    public void methodX() { System.out.println("Method X"); }    public void methodY() { System.out.println("Method Y"); }    public void methodZ() { System.out.println("Method Z"); }}

In this case, MyClass must implement methods from all the interfaces it extends (X, Y, and Z).

Interface Naming Conflicts

Method Naming Conflicts: If two interfaces have methods with the same signature, a class implementing both interfaces only needs to provide one implementation.
Variable Naming Conflicts: If two interfaces define variables with the same name, a class can distinguish them using the interface name.

Code Example

xxxxxxxxxx
 
interface A {    int x = 10;  // public static final    void m1();}​interface B {    int x = 20;  // public static final    void m1();}​class C implements A, B {    public void m1() {        System.out.println("Implementing m1 from both interfaces");    }    System.out.println(A.x);  // Refers to A's x    System.out.println(B.x);  // Refers to B's x}