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

syntax for java interfaces

  class  ClassName [ extends SuperClassName ]
		[ implements InterfaceName1 [, Interface Name2 �] )  {
			class body 
	}

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

Interfaces in Java

// 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);
    }
}

Interfaces in Java

// 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();
    }
}