xxxxxxxxxx
An interface can contain:
public constants;
abstract methods without an implementation (the keyword abstract is not required here);
default methods with implementation (the keyword default is required);
static methods with implementation (the keyword static is required);
private methods with implementation.
Java 9 onwards, you can include private methods in interfaces. Before Java 9
it was not possible.
An interface can't contain fields (only constants), constructors,
or non-public abstract methods.
The keyword abstract before a method means that the method does not have a
body, it just declares a signature.
xxxxxxxxxx
//Since Java9, Interface now has methods:
//public abstract, public default, public static, private, private static
//default methods have body (implementation), is inherited by subclasses.
//static methods is the same as regular static methods.
//private methods and private static methods are helper methods.
public interface CustomInterface {
public abstract void method1();
public default void method2() {
method4(); //private method inside default method
method5(); //static method inside other non-static method
System.out.println("default method");
}
public static void method3() {
method5(); //static method inside other static method
System.out.println("static method");
}
private void method4(){
System.out.println("private method");
}
private static void method5(){
System.out.println("private static method");
}
}
public class CustomClass implements CustomInterface {
@Override
public void method1() {
System.out.println("abstract method");
}
public static void main(String[] args){
CustomInterface instance = new CustomClass();
instance.method1();
instance.method2();
CustomInterface.method3();
}
}
/* Output:
abstract method
private method
private static method
default method
private static method
static method
*/
// Another example of default and private methods
import java.util.function.IntPredicate;
import java.util.stream.IntStream;
public interface CustomCalculator
{
default int addEvenNumbers(int nums) {
return add(n -> n % 2 == 0, nums);
}
default int addOddNumbers(int nums) {
return add(n -> n % 2 != 0, nums);
}
private int add(IntPredicate predicate, int nums) {
return IntStream.of(nums)
.filter(predicate)
.sum();
}
}
public class Main implements CustomCalculator {
public static void main(String[] args) {
CustomCalculator demo = new Main();
int sumOfEvens = demo.addEvenNumbers(1,2,3,4,5,6,7,8,9);
System.out.println(sumOfEvens);
int sumOfOdds = demo.addOddNumbers(1,2,3,4,5,6,7,8,9);
System.out.println(sumOfOdds);
}
}
/* output:
20
25
*/
xxxxxxxxxx
public interface SomeInterface{
default void test(){
//this will be done when the method is called by default
}
public void newTest();
}
public interface OtherInterface extends SomeInterface{
// test() is available
// newTest() is available
public void otherTest();
}
public class SomeInterfaceImpl implements SomeInterface{
//has test method from SomeInterface, can be overwritten
@Override
public void newTest() {
// must override the non-default method
}
}
public class SomeClass{
public void test(){
//do something else
}
}
public class SomeOtherClass extends SomeClass implements OtherInterface{
//uses the test method from SomeClass instead of SomeInterface
@Override
public void newTest() {
// must override the non-default method inherited in OtherInterface
}
public void otherTest() {
// must override the non-default new method in OtherInterface
}
}
xxxxxxxxxx
// Java program to demonstrate working of
// interface
import java.io.*;
// A simple interface
interface In1 {
// public, static and final
final int a = 10;
// public and abstract
void display();
}
// A class that implements the interface.
class TestClass implements In1 {
// Implementing the capabilities of
// interface.
public void display(){
System.out.println("Geek");
}
// Driver Code
public static void main(String[] args)
{
TestClass t = new TestClass();
t.display();
System.out.println(a);
}
}
xxxxxxxxxx
A functional interface is an interface that contains only one abstract method. They can have only one functionality to exhibit.
xxxxxxxxxx
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}
xxxxxxxxxx
import java.util.function.Function;
public class FunctionalProgrammingExample {
public static void main(String[] args) {
// Functional interfaces are interfaces designed for a single function and provide ways for specific functional behaviors
// Example 1 : Consumer functional interface (a void function, to be fair)
Consumer<String> myConsumer = (message) -> {System.out.println("Consumer: " + message)}; //Takes input as String, produces no output
myConsumer.accept("Hello, Consumer!"); // Calling the consumer
// Example 2 : Runable concurrent functional interface
Runnable myRunnable = () -> {
for (int i = 0; i < 5; i++) {
System.out.println("Runnable: " + i);
}
};
Thread myThread = new Thread(myRunnable);
myThread.start(); // calling the runnable
// Example 3 : Chaining functional interfaces
Function<Integer, Integer> first = x -> x + 2; // Takes input as Integers, generates output as Integers
Function<Integer, Integer> second = x -> x * 3; // Takes input as Integers, generates output as Integers
// valid as long as the first functions output can be accepted as the second function's input
// Also valid for method reference in .andThen
Function<Integer, Integer> firstThenSecond = first.andThen(second); // Using andThen to compose a pipeline of functions
int result = firstThenSecond.apply(5); // Calling the composed function
first.andThen(System.out::println);// Calling with method reference
}
}
xxxxxxxxxx
Public abstract interface Multi{ //Interface declaration
Public abstract void multi();//method declaration
public abstract void subtract();
}
xxxxxxxxxx
// Java program to demonstrate the
// real-world example of Interfaces
import java.io.*;
interface Vehicle {
// all are the abstract methods.
void changeGear(int a);
void speedUp(int a);
void applyBrakes(int a);
}
class Bicycle implements Vehicle{
int speed;
int gear;
// to change gear
@Override
public void changeGear(int newGear){
gear = newGear;
}
// to increase speed
@Override
public void speedUp(int increment){
speed = speed + increment;
}
// to decrease speed
@Override
public void applyBrakes(int decrement){
speed = speed - decrement;
}
public void printStates() {
System.out.println("speed: " + speed
+ " gear: " + gear);
}
}
class Bike implements Vehicle {
int speed;
int gear;
// to change gear
@Override
public void changeGear(int newGear){
gear = newGear;
}
// to increase speed
@Override
public void speedUp(int increment){
speed = speed + increment;
}
// to decrease speed
@Override
public void applyBrakes(int decrement){
speed = speed - decrement;
}
public void printStates() {
System.out.println("speed: " + speed
+ " gear: " + gear);
}
}
class GFG {
public static void main (String[] args) {
// creating an inatance of Bicycle
// doing some operations
Bicycle bicycle = new Bicycle();
bicycle.changeGear(2);
bicycle.speedUp(3);
bicycle.applyBrakes(1);
System.out.println("Bicycle present state :");
bicycle.printStates();
// creating instance of the bike.
Bike bike = new Bike();
bike.changeGear(1);
bike.speedUp(4);
bike.applyBrakes(3);
System.out.println("Bike present state :");
bike.printStates();
}
}
xxxxxxxxxx
In many cases, it is more important to know what an object can do,instead of
how it does what it does. This is a reason why interfaces are commonly used for
declaring a type of variable.
interface : DrawingTool : a tool can draw
interface DrawingTool {
void draw(Curve curve);
}
DrawingTool pencil = new Pencil();
DrawingTool brush = new Brush();
Both Pencil and brush class should implement draw method