Java Interfaces: ממשקים, חוזים ו-implements

ממשק הוא חוזה

ממשק מצהיר מה מחלקה יכולה לעשות בלי לומר איך. זו רשימה של חתימות מתודות שכל מחלקה מממשת מתחייבת למלא. המטרה היא הפרדה: קוד יכול לעבוד עם טיפוס הממשק ולא לדאוג לאיזו מחלקה קונקרטית עומדת מאחוריו.

interface Shape {
    double area();          // כל Shape חייב לספק area
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

    Circle(double radius) { this.radius = radius; }

    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape אומר ש-Circle חייבת להגדיר את area ואת perimeter. ברגע שהיא עושה זאת, Circle הוא Shape ואפשר לשמור אותו במשתנה מטיפוס Shape.

הרבה מחלקות, טיפוס אחד

הכוח מתגלה כשכמה מחלקות שאינן קשורות מממשות את אותו ממשק. קוד שנכתב מול Shape מטפל בכולן:

import java.util.List;

interface Shape {
    double area();
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() { return Math.PI * r * r; }
}

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Rectangle(2, 3), new Circle(2));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // עובד לכל Shape, לא משנה מה המחלקה שלו
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

הלולאה אף פעם לא שואלת "זה Circle או Rectangle?". היא פשוט קוראת ל-area() וסומכת על החוזה. הוספת Triangle בהמשך לא דורשת שום שינוי כאן.

מימוש כמה ממשקים

מחלקה מרחיבה רק מחלקה אחת, אבל היא יכולה לממש כמה ממשקים שתרצו. כך Java מאפשרת "ירושה מרובה" של התנהגות בצורה בטוחה:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

כתבו את הממשקים אחרי implements, מופרדים בפסיקים. המחלקה חייבת לעמוד בכולם.

מתודות default ו-static

מאז Java 8 ממשק יכול לכלול גופי מתודות. מתודת default נותנת למחלקות המממשות מימוש מוכן שהן יורשות בחינם (ויכולות לדרוס):

interface Greeter {
    String name();

    default String greet() {        // מימוש משותף
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() עובר בירושה מהממשק
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

מתודות default מאפשרות לממשק להתפתח: להוסיף מתודה בלי לשבור כל מחלקה שכבר מממשת אותו. מתודת ממשק static, לעומת זאת, מתנהגת כמו איברים סטטיים אחרים: זו פונקציית עזר שקוראים לה על הממשק עצמו, כמו Comparator.naturalOrder().

קבועים

שדות בממשק הם באופן מובלע public static final: הם קבועים, לא מצב של מופע:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

באופן מסורתי לממשקים אין מצב לכל אובייקט; היעדר שדות מופע הוא חלק ממה שמבדיל אותם ממחלקות.

ממשקים פונקציונליים

ממשק עם מתודה מופשטת אחת בדיוק הוא ממשק פונקציונלי (functional interface), ואפשר לממש אותו עם ביטוי למדא במקום מחלקה שלמה:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // הלמדא מממשת את המתודה היחידה
        System.out.println(doubler.apply(21));
    }
}

זה הבסיס של הלמדות ב-Java ושל הטיפוסים ב-java.util.function (Function, Predicate, Supplier וחבריהם). האנוטציה @FunctionalInterface הופכת את הכוונה למפורשת ומאפשרת לקומפיילר לאכוף את כלל המתודה היחידה.

ממשק מול מחלקה מופשטת

שניהם מאפשרים לתכנת מול הפשטה, אז מתי בוחרים בכל אחד?

• ממשק: יכולת שמחלקות לא קשורות יכולות לחלוק. גם Bird וגם Airplane יכולים להיות Flyable. מחלקה יכולה לממש הרבה ממשקים. אין מצב של מופע.
• מחלקה מופשטת: מצב וקוד משותפים בין מחלקות קרובות. גם Cat וגם Dog מרחיבים את Animal, ויורשים שדות משותפים ומתודות שממומשות בחלקן. מחלקה מרחיבה רק מחלקה אחת.

דפוס נפוץ משלב ביניהם: ממשק מגדיר את החוזה, ומחלקה מופשטת מממשת את החלקים השגרתיים, כך שתת-המחלקות הקונקרטיות ממלאות רק את הפרטים הספציפיים.

הבא בתור: מחלקות מופשטות

ממשקים מגדירים התנהגות בלי מצב. מחלקות מופשטות נמצאות באמצע בין ממשקים למחלקות מלאות: הן יכולות להצהיר על מתודות שלא ממומשות וגם להחזיק שדות ובנאים. זה העמוד הבא.