JAVA

interface java

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

Java Interface

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

functional interface java

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

creating the functional interface in java

package com.concretepage;

@FunctionalInterface
public interface Calculator {
   long calculate(long num1, long num2);
} 

interface in java

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.

how to declare a interface in java

// Assume we have the simple interface:
interface Appendable {
	void append(string content);
}
// We can implement it like that:
class SimplePrinter implements Appendable {
 	public void append(string content) {
   		System.out.println(content); 
    }
}
// ... and maybe like that:
class FileWriter implements Appendable {
 	public void append(string content) {
   		// Appends content into a file 
    }
}
// Both classes are Appendable.
0
how to implement a interface in java

Interface declaration in java

Public abstract interface Multi{ //Interface declaration
Public abstract void multi();//method declaration
public abstract void subtract();
}

interface in java

the main idea of an interface is declaring functionality.
Suppose you program a game that has several types of characters.
These characters are able to move within a map. That is represented by Movable
interface

interface in java

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!

java define interface

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

interface in java

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