Interface-Segregation-Prinzip

Das Interface-Segregation-Prinzip oder Schnittstellenaufteilungsprinzip ist ein Begriff aus der Informatik. Es handelt sich um ein Prinzip des objektorientierten Entwurfs. Demnach sollen zu große Schnittstellen in mehrere Schnittstellen aufgeteilt werden, falls implementierende Klassen unnötige Methoden haben müssen. Nach erfolgreicher Anwendung dieses Entwurfprinzips müsste ein Modul, das eine Schnittstelle benutzt, nur diejenigen Methoden implementieren, die es auch wirklich braucht.

Zweck

Durch dieses Prinzip ist es möglich, die von Bertrand Meyer geforderten schlanken Schnittstellen zu realisieren, was eine verbesserte Wartbarkeit mit sich bringt, da Klassen nur noch die Methoden implementieren, die sie benötigen. Somit wird der Code kompakt und ist besser wiederverwertbar. Auch eine verbesserte Überprüfbarkeit ist gegeben.[1]

Beispiele

Java

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Human implements Workable, Eatable {
    @Override
    public void work() {
        System.out.println("Mensch arbeitet");
    }
    
    @Override
    public void eat() {
        System.out.println("Mensch isst");
    }
}

class Robot implements Workable {
    /**
     * Robot implementiert nur Workable, nicht Eatable.
     * Dies erfüllt das ISP, da Robot nicht gezwungen wird, eine eat()-Methode
     * zu implementieren, die er nicht benötigt. Dadurch wird vermieden, dass
     * unnötige Methoden mit Dummy-Implementierungen oder Exceptions gefüllt werden müssen.
     */
    @Override
    public void work() {
        System.out.println("Roboter arbeitet");
    }
}
Anwendung
Workable[] workers = { new Human(), new Robot()};

// Alle Arbeiter können arbeiten
for (Workable worker: workers) {
    worker.work(); // Kompiliert erfolgreich
}

// Mittagspause: Falsche Implementierung wird durch IDE / Compiler erkannt
for (Workable worker: workers) {
    // worker.eat();  // COMPILER-FEHLER: eat() existiert nicht in Workable
}

// Mittagspause, korrekte Lösung: eat() nur auf Eatable-Objekten aufrufen
for (Workable worker: workers) {
    if (worker instanceof Eatable) {
        ((Eatable) worker).eat();
    }
}

Typescript

interface Workable {
    work(): void;
}

interface Eatable {
    eat(): void;
}

class Human implements Workable, Eatable {
    work(): void {
        console.log("Mensch arbeitet");
    }
    
    eat(): void {
        console.log("Mensch isst");
    }
}

class Robot implements Workable {
    /**
     * Robot implementiert nur Workable, nicht Eatable.
     * Dies erfüllt das ISP, da Robot nicht gezwungen wird, eine eat()-Methode
     * zu implementieren, die er nicht benötigt. Dadurch wird vermieden, dass
     * unnötige Methoden mit Dummy-Implementierungen oder Exceptions gefüllt werden müssen.
     */
    work(): void {
        console.log("Roboter arbeitet");
    }
}

function isEatable(worker: Workable): worker is Eatable {
    return 'eat' in worker;
}
Anwendung
const workers: Workable[] = [new Human(), new Robot()];

// Alle Arbeiter können arbeiten
for (const worker of workers) {
    worker.work();
}

// Mittagspause: Falsche Implementierung wird durch IDE / Compiler erkannt
for (const worker of workers) {
    // worker.eat();  // COMPILER-FEHLER: eat() existiert nicht in Workable
}

// Mittagspause, korrekte Lösung: eat() nur auf Eatable-Objekten aufrufen
for (const worker of workers) {
    if (isEatable(worker)) {
        worker.eat();
    }
}

Einzelnachweise

  1. ↑ Wolfgang Kowarschick: Programmierprinzipien: Interface-Segregation-Prinzip, Interface segregation principle. GlossarWiki der Hochschule Augsburg (HSA), 23. Februar 2012, archiviert vom Original am 27. Juni 2012; abgerufen am 26. Juni 2012.  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/glossar.hs-augsburg.de

Content Disclaimer

Informasi ini disarikan dari Wikipedia dan disajikan kembali untuk tujuan edukasi. Konten tersedia di bawah lisensi CC BY-SA 3.0. Kami tidak bertanggung jawab atas ketidakakuratan data yang bersumber dari kontribusi publik tersebut.

  1. The information displayed on this website is sourced in part or in whole from Wikipedia and has been adapted for the purpose of restating it. We strive to provide accurate and relevant information, however:
  2. There is no guarantee of absolute accuracy. Wikipedia is an open, collaborative project that can be edited by anyone, so information is subject to change.
  3. It is not intended to constitute professional advice. The content displayed is for informational and educational purposes only. For important decisions (e.g., medical, legal, or financial), please consult a professional.
  4. Content copyright. Wikipedia is licensed under the Creative Commons Attribution-ShareAlike License (CC BY-SA). This means that content may be reused with appropriate attribution and shared under a similar license.
  5. Responsible use. Any risk arising from the use of information from this website is entirely the responsibility of the user.