Moderne Programmierparadigmen Objekt-Orientierung

Transkript

1 Moderne Programmierparadigmen Objekt-Orientierung Sven Apel (Universität Passau) Christian Kästner (Universität Magdeburg)

2 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 2 Agenda Historie der Programmierparadigmen Grundlagen Objekt-Orientierter Programmierung (OOP) Überblick über Moderne OOP Konzepte Frameworks Entwurfsmuster (Design Pattern) Komponenten

3 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 3 Programmierparadigmen Ein Paradigma ist ein(e) grundlegendes Konzept/Prinzip/Weltsicht, auch in anderen Wissenschaften Paradigmen sind nicht universal akzeptiert, stehen in Konkurrenz, und werden manchmal durch neuere Paradigmen abgelöst Programmierparadigmen beschreiben grundlegende Konzepte von Programmiersprachen Programmiersprachen werden anhand solcher Paradigmen entworfen und kategorisiert

4 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 4 Bekannte Programmierparadigmen Strukturierte Programmierung, Anfang 70er Verzicht auf GOTO, dafür Sequenz, Auswahl, Schleifen Zerlegung in Teilprogramme (Prozeduren) Typische Sprache: Pascal, C, Ada Modulare Programmierung, 70er Wachsende Programmgröße Dekomposition in Teilprogramme (Module) Module einzeln planen, entwickeln, testen Typische Sprache: Modula-2, Ada

5 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 5 Bekannte Programmierparadigmen II Abstrakte Datentypen, Ende 70er Implementierungsunabhängige Spezifikation von Datenstrukturen Aufteilung Wertebereich vs. Operationen, und Signatur vs. Semantik Funktionale Programmierung, seit 50er Programme bestehen nur aus Funktionen Keine Statusvariablen, nur Parameter Logische Programmierung, seit 60er/70er Nutzung logischer Ausdrücke zur Programmierung

6 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 6 Bekannte Programmierparadigmen III Objekt-Orientierte Programmierung, Konzepte seit 60er, populär seit frühen 90er Objekte als Abstraktionsform, dieses Kapitel Subjekt-Orientierte Programmierung, seit '93 Erweiterung OOP für große Anwendungen und Integration unabhängig entwickelter Software Feature-Orientierte Programmierung (FOP), seit späten 90er Feature als zentrale Abstraktionsform, Kapitel 4ff Speziell für maßgeschneiderte Software

7 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 7 Bekannte Programmierparadigmen IV Aspekt-Orientierte Programmierung, seit '97 Implementierung quer-schneidender Belange durch Aspekte, Kapitel 7 Komponentenorientierte Programmierung, Ende 90er Teilung von Softwaresystemen in Komponenten Wiederverwendung im Großen

8 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 8 Was ist OOP? Objekte als zentrale Abstraktionsform Sprachen: Smalltalk, Eiffel, Java, C++, JavaScript, Object Pascal/Delphi, Self, Modula-2, Objective Caml, Visual Prolog Schlagworte: Objekte, Klassen, Instanzen, Vererbung, Kapselung, Methoden, Attribute, Schnittstellen, statische Methoden, Polymorphie, UML, Wiederverwendung Bildet die Welt besser auf das Programm ab; Objekte sind näher am natürlichen Denken

9 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 9 Java Beispiel interface ICounter { int get(); void inc(); class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); System.out.println(c.get());

10 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 10 OOP Fundamentale Konzepte Polymorphie (polymorphism) Kapselung (encapsulation) Subtypenbeziehung (subtyping) Vererbung (inheritance) Späte Bindung (late binding) Offene Rekursion (open recursion)

11 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 11 Polymorphie Objekt entscheidet selbst welcher Code ausgeführt wird, wenn eine Methode aufgerufen wird Unterschiedliche Objekte können die gleiche Methode unterschiedlich implementieren Methoden bilden die Schnittstelle (Protokoll) des Objektes und abstrahieren von der Implementierung Methodenaufrufe durch Senden von Nachrichten Gegensatz zu ADT, wo alle Instanzen die gleichen Methoden haben

12 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 12 Java Beispiel Polymorphie interface ICounter { int get(); void inc(); class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; Mehrfache Repräsentation Verschiedene Implementierungen eines Objektes class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); System.out.println(c.get());

13 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 13 Kapselung Die interne Repräsentation (der Status) des Objektes ist versteckt, nur Methoden des Objektes dürfen darauf zugreifen (In einigen Sprachen wie Smalltalk erzwungen, anderen wie Java und C++ erlauben individuelles Scoping mit private/public) Von außen kann nur über die Schnittstelle auf das Objekt zugegriffen werden Lokale Änderungen verbessern Lesbarkeit und Wartbarkeit

14 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 14 Java Beispiel Kapselung interface ICounter { int get(); void inc(); class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); System.out.println(c.get()); Kapselung Interne Repräsentation ist hinter einer Schnittstelle versteckt

15 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 15 Subtypenbeziehung Ein Objekt mit Schnittstelle A wird von allen Programmen akzeptiert, die Schnittstelle B mit weniger Methoden erwarten A ist ein Subtyp von B Ermöglicht teile einer Schnittstelle zu ignorieren Erlaubt Code zu schreiben, der verschiedene Objekte manipuliert indem er sich auf wenige gemeinsame Methoden beschränkt (In Java wird Subtyping explizit über benannte Typen/Interfaces implementiert)

16 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 16 Java Beispiel III interface ICounter { int get(); void inc(); class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; Subtyping: Akzeptiert verschiedene Objekte solange sie das ICounter Interface erfüllen class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); System.out.println(c.get());

17 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 17 Vererbung Objekte mit gemeinsamer Schnittstelle haben häufig gemeinsames Verhalten, welches nur einmal implementiert werden soll Die meisten OOP Sprachen, auch Java, nutzen dazu Klassen und Vererbung von Klassen Klassen als Schablonen zur Instantiierung von Objekte Subklassen können neue Methoden hinzufügen oder falls notwendig ausgewählte bestehende Methoden überschreiben Einige Sprachen nutzen Delegation statt Vererbung mittels Klassen

18 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 18 Java Beispiel Vererbung interface ICounter { int get(); void inc(); class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); Vererbung mit Klassen System.out.println(c.get()); Gemeinsame Methoden get, set und reset werden nur einmal implementiert, inc wird überschrieben, restore wird hinzugefügt

19 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 19 Java Beispiel Delegation interface ICounter { int get(); void inc(); Alternative Implementierung mittels Delegation statt Vererbung class Counter implements ICounter { private int x = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; class BackupCounter { ResetCounter del; BackupCounter(ResetCounter del) { this.del = del; private int backup; public void set(int x) { backup = this.get(); del.set(x); public void restore() { del.set(backup); public int get() { return del.get(); public void inc() { del.inc(); public void reset() { del.reset();

20 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 20 Späte Bindung / Offene Rekursion Methoden eines Objektes können andere Methoden des gleichen Objektes aufrufen (mit Hilfe eines speziellen Schlüsselwortes, wie this oder self) Späte Bindung erlaubt den Aufruf einer Methode in einer Klasse die erst später in einer Subklasse definiert wird Auch bekannt als virtuelle Methoden Übliches Feature vieler OOP Sprachen mit Klassen

21 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 21 Java Beispiel Späte Bindung interface ICounter { int get(); void inc(); Offene Rekursion mit this class Counter implements ICounter { private Späte int x Bindung = 1; public void inc() { x = x + 1; public int get() { return x; class ResetCounter implements ICounter { private int y = 0; public void set(int x) { y = x; public int get() { return y + 1; public void inc() { this.set(this.get() +1); public void reset() { y = 0; class BackupCounter extends ResetCounter{ private int backup; public void set(int x) { backup = this.get(); super.set(x); public void restore() { this.set(backup); class Test { void tripleinc(icounter x) { x.inc(); x.inc(); x.inc() void main(string[] args) { ICounter c = new BackupCounter(); c.inc(); tripleinc(c); System.out.println(c.get());

22 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 22 OOP Konzepte in Java Objekte als Instanzen von Klassen Benannte Klassen und Schnittstellen, explizite Subtypenbeziehung (nominal subtyping) Vererbung von Klassen und Schnittstellen Späte Bindung, da alle Methoden virtuell Packages zur zusätzlichen Modularisierung Zusätzliche (nicht-oop) Features wie statische Methoden

23 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 23 Warum OOP? Modularisierung mittels Objekten und Klassen passt zu vielen Problemen Trennung von Zustand und Verhalten, von Implementierung und Schnittstelle (information hiding) Wiederverwendung durch Kapselung und Vererbung Bildet die Welt besser ab, Objekte sind näher am natürlichen Denken

24 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 24 Beispiel für die restliche Vorlesung Datenstruktur für Graphen Darin sollten gerichtete, gewichtete Graphen gespeichert werden werden können in denen die Knoten (Vertex, Node) und Kanten (Edge) Farben haben können Später wird es Algorithmen geben die auf diesen Graphen arbeiten, z.b. Suche nach dem kürzesten Pfad Hier zunächst objekt-orientiertes Design und eine erste Implementierung

25 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 25 Objekt-Orientierter Entwurf Welche Objekttypen brauchen wir? Knoten (Node) Kanten (Edge) Den Graph selber Gewichte? Farben? Welche Funktionalität? Hinzufügen von Knoten zum Graphen Hinzufügen von Kanten Setzen von Kantengewichten und Farben Ausgeben des Graphen (Logging)

26 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 26 Objekt-Orientierter Entwurf in UML Graph 1 +addedge() +addnode() +print() 1 * * Node -name +print() * -startswith 1 * 1 * -endswith Edge - +print() * * 1 Weight +print() 1 Color 1 +setdisplaycolor ()

27 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 27 Erste Implementierung class Graph { Vector nv = new Vector(); Vector ev = new Vector(); Edge addedge(node n, Node m, Weight w) Edge e = new Edge(n, m, w); addnode(n); addnode(m); ev.add(e); return e; void addnode(node n) { nv.add(n); void print() { for(int i = 0; i < ev.size(); i++) { ((Edge)ev.get(i)).print(); class Color { static void setdisplaycolor(color c) {... class Weight { void print() {... class Node { int id = 0; Color color = new Color(); void print() { Color.setDisplayColor(color); System.out.print(id); class Edge { Node a, b; Color color = new Color(); Weight weight = new Weight(); Edge(Node a, Node b, Weight w) { this.a = a; this.b = b; this.weight = w; void print() { Color.setDisplayColor(color); a.print(); b.print(); weight.print(); Es folgen noch viele alternative Implementierungen im Verlauf der Vorlesung :-)

28 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 28 Wiederverwendung Vererbung und Delegation erlauben Wiederverwendung von Code-Fragmenten, wenn diese entsprechend entworfen wurden Moderne Ansätze für Wiederverwendung in OOP Frameworks Design Pattern Komponenten... können auch für Produktlinien verwendet werden, mehr dazu später in Kapitel 9a

29 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 29 Frameworks Menge abstrakter und konkreter Klassen Repräsentieren eine abstrakte Struktur, die für einen bestimmten Zweck erweitert werden kann (Anpassung von Software) Wiederverwendbare Lösung für eine Problemfamilie in einer Domäne Punkte an denen Erweiterungen vorgesehen sind: Hot Spots Umkehrung der Kontrolle, das Framework bestimmt die Ausführungsreihenfolge Hollywood Prinzip: Don t call us, we ll call you.

30 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 30 Eclipse JDT WTP SAPinst Workbench Platform Ant IDE Cheat Sheets Search Debug Team Help Update Views Resources Console Editors Forms Text Editors Compare Build Debug Edit JUnit Refactor Launch J2EE Web Control Items Component Table Script Messages Resourcepool Dialogs Meta-Dialogs Prerequisite C. Rich Client Platform Workbench Help JFace Core Runtime OSGi SWT

31 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 31 Entwurfsmuster Engl. design patterns, Gamma et al Wiederverwendung durch Identifikation und Beschreibung von Lösungen für typische Entwurfsprobleme Muster = Problembeschreibung + Lösungsidee Kein Wiederverwendung von Code

32 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 32 Ein Entwurfsproblem Row 1 3 Diagramme (manipulierbar) Row 2 0 Row Row 1 Row 2 Row 3 Row 4 Row 3 Synchronisation Datenstruktur für Messergebnisse Messergebnisse

33 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 33 Komponenten Abgeschlossene Implementierungseinheit mit Schnittstelle (black box), bietet ein oder mehrere Dienste an Wird zusammen mit anderen Komponenten auch von anderen Herstellern zusammengesetzt zu Software Systemen (Komposition) Einzeln vermarktbar Kontext (z.b. J2EE, Struts Framework) und Abhängigkeiten explizit spezifiziert Klein genug für Erzeugung und Wartung in einem Stück, groß genug um sinnvolle Funktion bieten zu können

34 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 34 Beispiel Komponenten Webshop Bestellen Großhändler Kunde anlegen Adresse ändern Kundenverwaltung Rechnung drucken Reportgenerator Einkäufe Katalog verwalten Webshop Rechnung schreiben Finanzbuchhaltung Entnehmen Einlagern Lagerhaltung

35 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 35 Zusammenfassung Es gibt eine Vielzahl Programmierparadigmen OOP ist sehr populär Vielgestaltigkeit, Kapslung, Vererbung Java, Eclipse Wiederverwendung mittels Vererbung, Delegation, Frameworks, Komponenten oder Entwurfsmuster

36 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 36 Grenzen von OOP Ausblick Neue Programmierkonzepte und Paradigmen Feature-Orientierte Programmierung Subjekt-Orientierte Programmierung Aspekt-Orientierte Programmierung

37 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 37 Literatur OOP B. Meyer, Object-oriented Software Construction, Prentice Hall, 1997 [OOP Generell] B. Pierce. Types and Programming Languages, Chap. 18, MIT Press, 2002 [5 Fundamentale Konzepte OOP]

38 Sven Apel, Christian Kästner Moderne Programmierparadigmen Folie 38 Literatur Wiederverwendung R. Johnson and B. Foote, Desiging reusable classes, Journal of Object-Oriented Programming, 1(2):22-35, 1988 [OOP Wiederverwendung, insb. Frameworks] E. Gamma, R. Helm, R. Johnson, J. Vlissedes, Design Patterns, Addison-Wesley, 1994 [Standardwerk Entwurfsmuster] C. Szyperski: Component Software: Beyond Object- Oriented Programming. Addison-Wesley, 1998 [Standardwerk Komponentenorientierte Softwareentwicklung]