Interfaces in Minitab Interfaces are abstract types that specify a set of methods that a class must implement.
import java.lang.Math ;
// Here's a basic interface for geometric shapes.
interface Geometry {
double area ();
double perim ();
}
// For our example we'll implement this interface on Rectangle and Circle classes.
class Rectangle implements Geometry {
double width , height ;
Rectangle ( double width , double height ) {
this . width = width ;
this . height = height ;
}
// To implement an interface in Java, we need to provide implementations
// for all the methods declared in the interface.
@Override
public double area () {
return width * height ;
}
@Override
public double perim () {
return 2 * width + 2 * height ;
}
@Override
public String toString () {
return "Rectangle{width=" + width + ", height=" + height + "}" ;
}
}
class Circle implements Geometry {
double radius ;
Circle ( double radius ) {
this . radius = radius ;
}
// The implementation for Circle.
@Override
public double area () {
return Math . PI * radius * radius ;
}
@Override
public double perim () {
return 2 * Math . PI * radius ;
}
@Override
public String toString () {
return "Circle{radius=" + radius + "}" ;
}
}
public class Interfaces {
// If a parameter has an interface type, then we can pass any object
// that implements that interface. Here's a generic measure method
// taking advantage of this to work on any Geometry.
public static void measure ( Geometry g ) {
System . out . println ( g );
System . out . println ( g . area ());
System . out . println ( g . perim ());
}
public static void main ( String [] args ) {
Rectangle r = new Rectangle ( 3 , 4 );
Circle c = new Circle ( 5 );
// The Rectangle and Circle classes both implement the Geometry
// interface, so we can use instances of these classes as arguments to measure.
measure ( r );
measure ( c );
}
}
To run the program, compile and execute it:
$ javac Interfaces.java
$ java Interfaces
Rectangle{ width = 3.0, height = 4.0}
12.0
14.0
Circle{ radius = 5.0}
78.53981633974483
31.41592653589793
In Java, interfaces are a fundamental part of the language and are widely used for achieving abstraction and enabling polymorphism. They allow you to define a contract that classes must adhere to, promoting loose coupling between different parts of your code.