Java Interface
An interface is a fully abstract class. It includes a group of
abstract methods (methods without a body).
We use the interface keyword to create an interface in Java.
interface Language {
public void getType();
public void getVersion();
}
Implementing an Interface
Like abstract classes, we cannot create objects of
interfaces.
To use an interface, other classes must implement
it. We use the implements keyword to implement
an interface.
interface Polygon {
void getArea(int length, int breadth);
}
// implement the Polygon interface
class Rectangle implements Polygon {
// implementation of abstract method
public void getArea(int length, int breadth) {
System.out.println("The area of the rectangle is " + (length
* breadth));
}
}
class Main {
public static void main(String[] args) {
Rectangle r1 = new Rectangle();
r1.getArea(5, 6);
}
} The area of the rectangle is 30
// create an interface
interface Language {
void getName(String name);
}
// class implements interface
class ProgrammingLanguage implements Language {
// implementation of abstract method
public void getName(String name) {
System.out.println("Programming Language: " + name);
} }
class Main {
public static void main(String[] args) {
ProgrammingLanguage language = new
ProgrammingLanguage();
language.getName("Java");
}
}
Implementing Multiple Interfaces
In Java, a class can also implement multiple interfaces. For
example,
interface A {
// members of A
}
interface B {
// members of B
}
class C implements A, B {
// abstract members of A
// abstract members of B
}
Extending an Interface
interface Line {
// members of Line interface
}
// extending interface
interface Polygon extends Line {
// members of Polygon interface
// members of Line interface
}
Extending Multiple Interfaces
interface A {
...
}
interface B {
...
}
interface C extends A, B {
...
}
Interfaces are also used to achieve multiple inheritance in
Java.
interface Line {
…
}
interface Polygon {
…
}
class Rectangle implements Line, Polygon {
…
}
interface Language {
// by default public static final
String type = "programming language";
// by default public
void getName();
}
All the methods inside an interface are implicitly public and
all fields are implicitly public static final
default methods in Java Interfaces
With the release of Java 8, we can now add methods with
implementation inside an interface. These methods are
called default methods.
To declare default methods inside interfaces, we use the
default keyword. For example,
public default void getSides() {
// body of getSides()
}
interface Polygon { // implements the interface
void getArea(); class Square implements Polygon {
// default method
public void getArea() {
int length = 5;
default void getSides() {
int area = length * length;
System.out.println("I can get sides
of a polygon."); System.out.println("The area of
}}
the square is " + area);
// implements the interface
}
}
class Rectangle implements Polygon
{ class Main {
public void getArea() { public static void main(String[]
int length = 6;
args) {
// create an object of Rectangle
int breadth = 5;
Rectangle r1 = new Rectangle();
int area = length * breadth;
r1.getArea();
System.out.println("The area of the
rectangle is " + area);
r1.getSides();
}
// create an object of Square
// overrides the getSides()
Square s1 = new Square();
public void getSides() {
s1.getArea();
System.out.println("I have 4
s1.getSides(); The area of the rectangle is 30
sides."); I have 4 sides.
}
} The area of the square is 25
} I can get sides of a polygon.
}
interface FirstInterface {
public void myMethod(); // interface method
}
interface SecondInterface {
public void myOtherMethod(); // interface method
}
class DemoClass implements FirstInterface, SecondInterface {
public void myMethod() {
System.out.println("Some text..");
}
public void myOtherMethod() {
System.out.println("Some other text...");
}
}
class Main {
public static void main(String[] args) {
DemoClass myObj = new DemoClass();
myObj.myMethod();
myObj.myOtherMethod();
}
}
Java Varargs
Varargs is a short name for variable arguments.
In Java, an argument of a method can accept arbitrary
number of values. This argument that can accept variable
number of values is called varargs.
accessModifier methodName(datatype… arg) {
// method body
}
… can take any number of arguments
class NoVararg {
public int sumNumber(int a, int b){
return a+b;
}
public int sumNumber(int a, int b, int c){
return a+b+c;
}
public static void main( String[] args ) {
NoVararg obj = new NoVararg();
System.out.println(obj.sumNumber(1, 2));
System.out.println(obj.sumNumber(1, 2, 3));
}
}
// To use the sqrt function // calculate the area of a triangle
import java.lang.Math; public void getArea() {
interface Polygon {
s = (double) (a + b + c)/2;
void getArea();
area = Math.sqrt(s*(s-a)*(s-
// calculate the perimeter of a Polygon
default void getPerimeter(int... sides) {
b)*(s-c));
int perimeter = 0; System.out.println("Area: " +
for (int side: sides) { area);
perimeter += side; }
} }
System.out.println("Perimeter: " + class MainInterface {
perimeter);
public static void main(String[]
}
args) {
}
class Triangle implements Polygon {
Triangle t1 = new Triangle(2, 3,
private int a, b, c; 4);
private double s, area; // calls the method of the Triangle
// initializing sides of a triangle class
Triangle(int a, int b, int c) { t1.getArea();
this.a = a; // calls the method of Polygon
this.b = b; t1.getPerimeter(2, 3, 4);
this.c = c; }
s = 0;
}
}
