Title here
Summary here
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.