Interfaces in Squirrel 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.
@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 variable has an interface type, then 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 the program:
$ 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 similar to those in other languages. They define a contract that classes must fulfill by implementing all the methods declared in the interface. This allows for polymorphism, where objects of different types can be treated uniformly if they implement the same interface.