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

    }

}

//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

*/

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

    }

}

A functional interface is an interface that contains only one abstract method. They can have only one functionality to exhibit.

// interface

interface Animal {

  public void animalSound(); // interface method (does not have a body)

  public void run(); // interface method (does not have a body)

}

Public abstract interface Multi{ //Interface declaration

Public abstract void multi();//method declaration

public abstract void subtract();

}

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.

​

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

public interface Shape {

    void draw(); // Abstract method

    double area(); // Abstract method

}

interface Interface {

    int INT_CONSTANT = 0; // it's a constant, the same as public static final int INT_FIELD = 0

    void instanceMethod1();

    void instanceMethod2();

    static void staticMethod() {

        System.out.println("Interface: static method");

    }

    default void defaultMethod() {

        System.out.println("Interface: default method. It can be overridden");

    }

​

    private void privateMethod() {

        System.out.println("Interface: private methods in interfaces are acceptable but should have a body");

    }

}

Static, default, and private methods should have an implementation in the interface!