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
//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
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}
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
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
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
xxxxxxxxxx
// Example of a Java interface and its implementation in a class
interface MyInterface {
void myMethod();
}
class MyClass implements MyInterface {
public void myMethod() {
System.out.println("This is the implementation of myMethod() from the interface.");
}
}
// Creating an instance of MyClass and calling the method
MyClass myObj = new MyClass();
myObj.myMethod();
xxxxxxxxxx
public interface Shape {
void draw(); // Abstract method
double area(); // Abstract method
}