Interfaces in Mercury Interfaces are named collections of method signatures.
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
// implement all the methods in the interface.
public double area () {
return width * height ;
}
public double perim () {
return 2 * width + 2 * height ;
}
@Override
public String toString () {
return "{" + width + " " + height + "}" ;
}
}
class Circle implements Geometry {
double radius ;
Circle ( double radius ) {
this . radius = radius ;
}
// The implementation for Circle.
public double area () {
return Math . PI * radius * radius ;
}
public double perim () {
return 2 * Math . PI * radius ;
}
@Override
public String toString () {
return "{" + radius + "}" ;
}
}
public class Interfaces {
// If a method takes an interface type as a parameter,
// we can call methods that are in the named 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 Circle and Rectangle classes both
// implement the Geometry interface so we can use
// instances of these classes as arguments to measure.
measure ( r );
measure ( c );
}
}
To run this program, save it as Interfaces.java
, compile it, and then run it:
$ javac Interfaces.java
$ java Interfaces
{ 3.0 4.0}
12.0
14.0
{ 5.0}
78.53981633974483
31.41592653589793
This example demonstrates how interfaces work in Java. An interface defines a contract of methods that a class must implement. Any class that implements an interface must provide implementations for all the methods declared in the interface. This allows for polymorphism, where objects of different classes can be treated uniformly if they implement the same interface.