objektorientierte komponenten auf der basis des artikels „integrating independent components with...
TRANSCRIPT
![Page 1: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/1.jpg)
Objektorientierte Komponenten
Auf der Basis des Artikels„Integrating Independent Components with
On-Demand Remodularization“ von M. Mezini und K. Ostermann
![Page 2: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/2.jpg)
1.1 Motivation
Generische Funktionalitäten in Komponenten kapseln
Bereits bestehende Software durch diese Komponenten jederzeit erweitern können (on-demand remodularization)
Dabei keine physische Veränderung der zu erweiternden Software
![Page 3: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/3.jpg)
Bsp: Universitätssoftware und Graphenalgorithmen
![Page 4: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/4.jpg)
Bsp: Universitätssoftware und Graphenalgorithmen
![Page 5: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/5.jpg)
Übersicht
1 Einführung1.1 Motivation1.2 Problemstellung
2 Konzept2.1 Collaboration Interface2.2 Wrapper Recycling 2.3 Wiederverwendung und Polymorphie
3 Fazit
![Page 6: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/6.jpg)
1.2 Problemstellung Fehlen zweier wichtiger Eigenschaften im
traditionellen Interface-Konzept
1. Unterstützung für das Design generischer Komponenten
2. Bidirektionale Kommunikation zwischen Klient und Server
![Page 7: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/7.jpg)
Bsp: TreeModel Interface (Java Swing)
interface TreeModel {Object getRoot();Object[] getChildren(Object node);String getStringValue(Object node, boolean selected, boolean expanded, boolean leaf, int row, boolean focus);
}
interface TreeGUIControl {display();
}
class SimpleTreeDisplay implements TreeGUIControl {TreeModel tm; ...display() {
Object root = tm.getRoot();... tm.getChildren(root) ...// prepare parameters for getStringValue... tm.getStringtValue(...); ...
}}
![Page 8: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/8.jpg)
Bsp: TreeModel Interface (Java Swing)
interface TreeModel {Object getRoot();Object[] getChildren(Object node);String getStringValue(Object node, boolean selected, boolean expanded, boolean leaf, int row, boolean focus);
}
interface TreeGUIControl {display();
}
Sehr häufige Verwendung des Typs Object !=> Konzeptionell fragwürdig=> Verlust der Typ-Sicherheit
![Page 9: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/9.jpg)
Bsp-Implementierung von TreeModel
class ExpressionDisplay implements TreeModel {Expression root;
ExpressionDisplay(Expression r) { root = r; }
Object getRoot() { return root; }
Object[] getChildren(Object node) {return ((Expression) node).getSubExpressions();
}
String getStringValue(Object node, boolean selected, boolean expanded, boolean leaf, int row, boolean focus){
String s = ((Expression) node).description();if (focus) s ="<"+s+">";return s;
}} Verlust der Typsicherheit
![Page 10: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/10.jpg)
Abgewandeltes TreeModel
interface TreeModel {TreeNode getRoot();
}
interface TreeNode {TreeNode[] getChildren();String getStringValue(boolean selected, boolean expanded, boolean leaf, int row, boolean focus);
}
![Page 11: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/11.jpg)
Einschub: Wrapper-Klassen
Definition des Begriffs „Wrapper“: to wrap (engl.) = verpacken, einhüllen Extraktion von Daten aus einer Datenquelle Stellt eine Schnittstelle zur Manipulation dieser
Daten dar In Java gibt es z.B. für jeden primitiven Datentyp
eine Wrapper-Klasse. Integer ist eine Wrapper-Klasse für den primitiven Typ int
![Page 12: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/12.jpg)
Bsp: TreeNode-Wrapper für Expression
interface TreeNode {TreeNode[] getChildren();String getStringValue(boolean selected, boolean expanded, boolean leaf, int row, boolean focus);
}
class ExpressionNode implements TreeNode {Expression expr;
ExpressionNode(Expression expr) { this.expr = expr; }
TreeNode[] getChildren() {Expression[] subExpr = expr.getSubExpressions();TreeNode[] children = new TreeNode[subExpr.length];for (i = 0; i < subExpr.length; i++) {
children[i] = new ExpressionNode(subExpr[i]));}return children;
}
String getStringValue(...){ ... }}
![Page 13: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/13.jpg)
Bsp: TreeModel Interface (Java Swing)
interface TreeModel {Object getRoot();Object[] getChildren(Object node);String getStringValue(Object node, boolean selected, boolean expanded, boolean leaf, int row, boolean focus);
}
interface TreeGUIControl {display();
}
Sehr viele Parameter, die nicht immer alle benötigt werden !=> Unnötige (, teure) Berechnungen
![Page 14: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/14.jpg)
2 Konzept (Lösung der Probleme)
1. Collaboration Interface
2. Wrapper Recycling
3. Wiederverwendung und Polymorphie
![Page 15: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/15.jpg)
2.1 Collaboration Interface eine Erweiterung des Standard Interfaces Unterteilung der Implementierung in eine
bindende und eine implementierende Klasse
zwei neue Modifikatoren: provided expected
neues Schlüsselwort binds
![Page 16: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/16.jpg)
Collaboration Interface für TreeDisplay
interface TreeDisplay {provided void display();expected TreeNode getRoot();
interface TreeNode {expected TreeNode[] getChildren();expected String getStringValue();provided void display();provided boolean isSelected();provided boolean isExpanded();provided boolean isLeaf();provided int row();provided boolean hasFocus();
}}
![Page 17: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/17.jpg)
Die implementierende Klasse Bietet generische Funktionalität an
Implementiert die als provided gekennzeichneten Methoden
Benutzt die als expected gekennzeichneten Methoden
Implementiert jede innere Schnittstelle
![Page 18: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/18.jpg)
Bsp: Implementierende Klasse für TreeDisplay
class SimpleTreeDisplay implements TreeDisplay {void display() {
getRoot().display();}class TreeNode {
boolean selected;...boolean isSelected() { return selected; }void setSelected(boolean s) {selected = s;}void display() {
...TreeNode c = getChildren()[i];paint(position, c.getStringValue());...
}}
}
![Page 19: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/19.jpg)
Die bindende Klasse Bindet die generische Funktionalität an die
spezielle Umgebung
Implementiert die als expected gekennzeichneten Methoden
Implementiert beliebig viele bindende Klassen für jede innere Schnittstelle
Stellt einen Konstruktor zur Verfügung
![Page 20: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/20.jpg)
Beispiel: Bindende Klasse für TreeDisplay
class ExpressionDisplay binds TreeDisplay {Expression root;public ExpressionDisplay(Expression rootExpr) {
root = rootExpr;}TreeNode getRoot() {
return ExprTreeNode(root);}class ExprTreeNode binds TreeNode {
Expression e;ExprTreeNode(Expression e) { this.e=e;}TreeNode[] getChildren() {
return ExprTreeNode[](e.getSubExpressions());}String getStringValue() {return e.description();}
}}
void anyMethod() {}
![Page 21: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/21.jpg)
Konstruktoren im Collaboration Interface Frage: Welcher der beiden Teile soll den Konstruktor enthalten ?
Antwort: Nur die bindende Klasse stellt einen Konstruktor
zur Verfügung !
Dieser entspricht dem der zusammengesetzten KlasseBegründung: Der bindende Teil stellt die Verbindung zur speziellen Anwendung dar.
![Page 22: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/22.jpg)
Komposition von bindender und implementierender Klasse
Beide sind alleine nicht instanzierungsfähig Sie müssen erst einmal wieder
zusammengefügt werden Mit Hilfe des Plus-Operators (+) Also:
class CompClass = BindClass + ImplClass;CompClass c = new CompClass(args);
![Page 23: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/23.jpg)
Beispiel für die Kompositionclass SimpleExpressionDisplay = SimpleTreeDisplay + ExpressionDisplay;...
Expression test = new Plus(new Times(5, 3), 9);
TreeDisplay t = new SimpleExpressionDisplay(test);
t.display();
![Page 24: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/24.jpg)
Virtuelle Typen Innere Schnittstellen von Collaboration Interfacen
sind virtuelle Typen
Ihre Benutzung macht nur in ihrem speziellen Kontext Sinn=> Sie sind nur im Kontext der sie umgebenden Klasse verwendbar
Vergleichbar mit Klassen-Variablen bzw. -Methoden
Frage: Ist die Typsicherheit dadurch noch gegeben ?
![Page 25: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/25.jpg)
Bsp: Virtuelle Typen und Typsicherheit
Expression e = ...;final ExpressionDisplay ed = new SimpleExpressionDisplay(e);...// sei FileSystemDisplay eine bindende Klasse von TreeDisplay// zu einer Struktur eines Dateisystemsclass SimpleFileSystemDisplay = SimpleTreeDisplay + FileSystemDisplay;FileSystem fs = ... ;final FileSystemDisplay fsd = new SimpleFileSystemDisplay(fs);...ed.TreeNode t = ed.getRoot();fsd.setRoot(t);
Typ-Fehler: fsd.TreeNode ist kein Untertyp von ed.TreeNode=> Typsicherheit gegeben !
T A F E L
![Page 26: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/26.jpg)
2.2 Wrapper Recycling Referenzen auf bereits kreierte Objekte werden in einer
Hashtabelle gespeichert
ein standard Konstruktor-AufrufObject o = new Wrapper(arguments);
wird ersetzt durchObject o = outerClass.Wrapper(arguments);
in Hashtabelle nachschauen, ob ein passendes Objekt schon existiert
Wenn ja, liefere dieses zurück Sonst, kreiere neues Objekt und lege Referenz in der
Hashtabelle ab
![Page 27: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/27.jpg)
Beispiel: Wrapper Recyclingclass ExpressionDisplay binds TreeDisplay {
Expression root;public ExpressionDisplay(Expression rootExpr) {
root = rootExpr;}TreeNode getRoot() {
return ExprTreeNode(root); // entspricht:// return this.ExprTreeNode(root);
}class ExprTreeNode binds TreeNode {
Expression e;ExprTreeNode(Expression e) { this.e=e;}. . .
}
![Page 28: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/28.jpg)
2.3 Wiederverwendung und Polymorphie das Collaboration-Interface(CI)-Konzept unterstützt
das Vererbungskonzept von Java => Erweiterungen bereits bestehender CI mit extends
Innere Schnittstellen können nicht erweitert werden Aber: Überschreiben mit dem neuen Schlüsselwort override möglich
![Page 29: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/29.jpg)
CI für einen Graphen-Datentyp
interface Graph {
interface Vertex {expected Edge[] getEdges();
}
interface Edge {expected Vertex getV1();expected Vertex getV2();
}
}
![Page 30: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/30.jpg)
Erweiterte CI für Graphen-Datentypinterface ColoredGraph extends Graph {
provided computeMinimumColoring(Vertex v[]);override interface Vertex {
expected void setColor(int c);expected int getColor();// aus Graph-Interface// expected Edge[] getEdges();
}override interface Edge {
provided float getBadness();}
}
interface MatchedGraph extends Graph {provided computeMaximumMatching(Vertex v[]);override interface Edge {
expected void setMatched(boolean b);expected boolean isMatched();
}}
![Page 31: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/31.jpg)
Hierarchisierung implementierender Klassen (1/2)
class SuccessiveAugmentationColoring implements ColoredGraph {// successive augmentation coloring algorithmvoid computeMinimumColoring(Vertex v[]) { ... }class Vertex {
int temp_color;boolean isLegalColor(int color) { ... }
}class Edge {
float badness;float getBadness() { return badness; }void setBadness(float b) { badness = b; }
}}class SimulatedAnnealingColoring implements ColoredGraph {
// Simulated Annealing coloring algorithmvoid computeMinimumColoring(Vertex v[]) { ...}...
}
![Page 32: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/32.jpg)
Hierarchisierung implementierender Klassen (2/2)
abstract class AbstractColoring implements ColoredGraph {class Vertex { ... }class Edge { float badness; ... }
}
class SuccessiveAugmentationColoring extends AbstractColoring {// Successive augmentation coloring algorithmvoid computeMinimumColoring(Vertex v[]) { ... }override class Vertex { ... }
}
class SimulatedAnnealingColoring extends AbstractColoring {// Simulated Annealing coloring algorithmvoid computeMinimumColoring(Vertex v[]) { ... }override class Vertex { ... }
}
![Page 33: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/33.jpg)
Bsp: Universitätssoftware und Graphenalgorithmen
![Page 34: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/34.jpg)
1.Graph: Course Collisionclass SchedulingGraph binds ColoredGraph {
class CourseVertex binds Vertex {Course c;Edge[] cachedEdges;CourseVertex(Course c) { this.c = c; }Edge[] getEdges() { . . .}void setColor(int color) {c.timeSlot = color;}}class CourseCollision binds Edge {Course c1,c2;CourseCollision(Course c1, Course c2) {this.c1=c1; this.c2 = c2;}Vertex getV1() { return CourseVertex(c1); }Vertex getV2() { return CourseVertex(c2); }}
}
![Page 35: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/35.jpg)
2.Graph: Student knows Teacherclass StudentKnowsTeacherGraph binds Graph {
class StudVertex binds Vertex {final Student s;StudVertex(Student s) {this.s=s;}...
}
class TeacherVertex binds Vertex {Teacher t;TeacherVertex(Teacher t) { this.t = t; }...
}... Vertex v1 = StudVertex(aStudent); ...... Vertex v2 = TeacherVertex(aTeacher); ...
}
![Page 36: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/36.jpg)
3.Graph: Student Contacts (1/2)class StudContactsGraph binds Graph {
class StudVertex binds Vertex {final Student s;StudVertex(Student s) {this.s=s;}Edge[] getEdges() {
... Student t = ... ;
... e[i] = StudContact(s,t);return e;
}}class StudContact binds Edge {
Student s,t;StudContact(Student s, Student t) {this.s = s; this.t = t;}
}}
![Page 37: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/37.jpg)
3.Graph: Student Contacts (2/2)class StudContactsColoredGraph extends StudContactsGraph
binds ColoredGraph {override StudVertex {// expected-Methoden von ColoredGraphvoid setColor(int c) {...}int getColor() {...}}
}
class StudContactsMatchedGraph extends StudContactsGraphbinds MatchedGraph {override StudContact {// expected-Methoden von MatchedGraphvoid setMatched(boolean b) {...}boolean isMatched(){...}}
}
![Page 38: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/38.jpg)
Polymorphie und der Plus-Operator (1/2)class SucAugSched =
SuccessiveAugmentationColoring + SchedulingGraph;
class SimAnSched =SimulatedAnnealingColoring + SchedulingGraph;
...
final SchedulingGraph sg = null;if (wantSucAug) {
sg = new SucAugSched();}else {
sg = new SimAnSched();}
sg.computeMinimumColoring( sg.CourseVertex[](courses) );
![Page 39: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/39.jpg)
Polymorphie und der Plus-Operator (2/2)class SucAugStudContacts =
SuccessiveAugmentationColoring + StudContactsColoredGraph;
class SimAnStudContacts =SimulatedAnnealingColoring +
StudContactsColoredGraph;
class Matching1StudContacts =MatchingAlgorithm1 + StudContactsMatchedGraph;
class Matching2StudContacts =MatchingAlgorithm2 + StudContactsMatchedGraph;
![Page 40: Objektorientierte Komponenten Auf der Basis des Artikels „Integrating Independent Components with On- Demand Remodularization“ von M. Mezini und K. Ostermann](https://reader036.vdocuments.net/reader036/viewer/2022062818/570491c41a28ab14218da1f5/html5/thumbnails/40.jpg)
3 Fazit Mit heutigen Sprachkonzepten wäre die
Lösung des hier beschriebenen Problems mit höherem Aufwand verbunden
Die Lösung wäre komplexer, unübersichtlicher Das Collaboration-Interface-Konzept ist
eleganter Es unterstützt das Konzept der
Wiederverwendung