Übung 7.2

[bafnai]

Hallo,
in der Klasse AbstractGameLogic gibt es die verschachtelte Klasse TimerRunnable. Werden die Variablen und Methoden von TimerRunnable bei der Bestimmung des LCOM-Wertes von AbstractGameLogic auch betrachtet?

[Hentschel]

Hi

Entscheidend sind die Methoden von AbstractGameLogic. Diese können nicht auf die Variablen der inneren Klasse zugreifen.
Methoden der inneren Klasse sind in einer anderen Klasse und können ignoriert werden.

Mfg

Martin

[Anka369]

Ich habe eine Frage zu der Definition des LCOM-Wertes. Und zwar steht da "any two methods in the same set share at least one local instance variable". Auf Folie 20 wird jedoch die Menge {SimpleLinkedList, getValue, getTail} als zulässige Menge betrachtet, woraus der LCOM-Wert 1 folgt. Aber getValue und getTail teilen sich doch gar keine Variable. Also müsste die Definition doch genau genommen eher heißen: "to any method exists at least one other method in the same set, with which it shares at least one local instance variable", oder?

[Seldon]

Ja, das ist in der Tat recht seltsam. Mir gefällt da auch die Formulierung von Hitz/Montazeri (Dokument auf der Vorlesungsseite, S. 9) besser:

Let X denote a class, \(I_X\) the set of its instance variables of X, and \(M_X\) the set of its methods. Consider a simple, undirected graph \(G_X(V, E)\) with \(V = M_X\) and \(E = \{(m, n) \in V \times V | \exists i \in I_X: (m\text{ accesses }i) \land (n\text{ accesses }i)\}\).
LCOM(X) is then defined as the number of connected components of \(G_X (1 \leq LCOM(X) \leq |MX|)\).

Wenn man den Graphen für das erste Beispiel mit den Methoden SimpleLinkedList (S), getValue (gV) und getTail (gT) zeichnet, ergibt sich dann das folgende:

Code: Alles auswählen

gT --- S --- gV

Für das zweite Beispiel mit getLineColor (gLC), setLineColor (sLC) usw.:

Code: Alles auswählen

gLC --- sLC        sFC --- gFC

und man kann sehr schön den LCOM ablesen.

[bagwell]

Eine kleine Frage zu LCOM, betrachtet man als eine Menge in LCOM wirklich nur Methoden die auf gemeinsame Variablen zugreifen, oder gehören zu dieser Menge auch Methoden die zwar selber keine Variable nutzen, jedoch andere Methoden der o.g. Menge aufrufen bzw. von Methoden der o.g. Menge aufgerufen werden ?

Da die Frage ein wenig unverständlich formuliert ist, ein kleines Beispiel zur Verdeutlichung:

Code: Alles auswählen

 public class X {
int a, b, c;
Object o;

public int getA{...}

public int getB{...}

public int getC{...}

public Object getO{...}

public int computeSum{ 
Obj myO = getO();
return getA()+getB()+getC(); }
}

Würde jetzt gelten, dass zur Berechnung von LCOM nur Methoden gezählt werden, die gemeinsame Variablen haben, würde folgender Graph bzw. folgender LCOM Wert entstehen:

getA getB getC getO -> LCOM = 4

sprich, keine der Methoden ist miteinanderverbunden und der LCOM Wert ist 4 (Da computeSum() nicht direkt auf Variablen zugreift, fällt sie bei dieser Interpretation aus der Berechnung raus).

Wenn man nun aber auch Methoden mithineeinnimmt, die andere Methoden aufrufen welche widerrum auf Variablen zugreifen, erhält man einen sternförmigen Graphen bei dem die o.g. 4 Methoden jeweils mit der Methode computeSum() verbunden sind und der LCOM Wert wäre 1 (was in meinen Augen mehr Sinn macht).

Was von beiden stimmt denn nun?

Danke schonmal

[hstr]

Eine kleine Frage zu LCOM, ...

Das wüsste ich auch gerne und zusätzlich noch ob wir auch die Methoden der Klasse "TimerRunnable" berücksichtigen sollen.

[noelma]

Würde jetzt gelten, dass zur Berechnung von LCOM nur Methoden gezählt werden, die gemeinsame Variablen haben, würde folgender Graph bzw. folgender LCOM Wert entstehen:

getA getB getC getO -> LCOM = 4

sprich, keine der Methoden ist miteinanderverbunden und der LCOM Wert ist 4 (Da computeSum() nicht direkt auf Variablen zugreift, fällt sie bei dieser Interpretation aus der Berechnung raus).

Diese Variante ist richtig.
Die getter-Methoden sind ja nicht für die internen Berechnungen gedacht, sondern um von außen die Werte abfragen zu können.

... und zusätzlich noch ob wir auch die Methoden der Klasse "TimerRunnable" berücksichtigen sollen.

TimerRunnable ist eine innere Klasse und muss somit für den LCOM nicht berücksichtigt werden ( siehe oben )

[bubel]

Ja, das ist in der Tat recht seltsam. Mir gefällt da auch die Formulierung von Hitz/Montazeri (Dokument auf der Vorlesungsseite, S. 9) besser:

Let X denote a class, \(I_X\) the set of its instance variables of X, and \(M_X\) the set of its methods. Consider a simple, undirected graph \(G_X(V, E)\) with \(V = M_X\) and \(E = \{(m, n) \in V \times V | \exists i \in I_X: (m\text{ accesses }i) \land (n\text{ accesses }i)\}\).
LCOM(X) is then defined as the number of connected components of \(G_X (1 \leq LCOM(X) \leq |MX|)\).

Wenn man den Graphen für das erste Beispiel mit den Methoden SimpleLinkedList (S), getValue (gV) und getTail (gT) zeichnet, ergibt sich dann das folgende:

Hallo,

vielen Dank. Die Folien verwenden, die aus dem obigen Papier entnommene umgangssprachliche Definition, die aber leider abweichend zu der genannten formalen Definition bzgl. dieses Falles ist. Wir werden für das Übungsblatt Lösungen nach beiden Varianten akzeptieren. Auf den Folien werde ich die alte Definition noch mit der formaleren Definition ersetzen (und auf die Änderung hinweisen).

Vielen Dank und ein frohes neues Jahr,
Richard

[bagwell]

Würde jetzt gelten, dass zur Berechnung von LCOM nur Methoden gezählt werden, die gemeinsame Variablen haben, würde folgender Graph bzw. folgender LCOM Wert entstehen:

getA getB getC getO -> LCOM = 4

sprich, keine der Methoden ist miteinanderverbunden und der LCOM Wert ist 4 (Da computeSum() nicht direkt auf Variablen zugreift, fällt sie bei dieser Interpretation aus der Berechnung raus).

Diese Variante ist richtig.
Die getter-Methoden sind ja nicht für die internen Berechnungen gedacht, sondern um von außen die Werte abfragen zu können.

Ok, ich glaub das mit den getter Methoden war ein schlechtes Beispiel.

Code: Alles auswählen

public class X{
int a, b;
int c,d;
public int sum(){
return a+b;
}

public int mul(){
return c*d;
}

public int something(){
return sum()/mul();
}

}

LCOM=2 oder LCOM=1?

Wenn ich die Antwort zum obigen Beispiel mit den getter Methoden hier anwende, müsste LCOM=2 gelten (Obwohl die beiden Methoden sum() und mul() durch something() "zusammengehalten" werden?)

[studypad]

Ich würde sagen LCOM = 2 = |{ {sum()} ,{mul()} }| doch nun meine Frage noch dazu:

Ist something() eine Methode die gar nicht zum LCOM gehört, da sie keine Variablen der Klasse benutzt? In der Hausübung gibt es auch solche und ich frage mich, wie diese zu behandeln sind.

Danke

[Seldon]

something() muss zum LCOM von Li und Henry dazu gezählt werden, der LCOM ist dann 3. Damit sollen Methoden verhindert werden, die praktisch gar nichts mit dem Objekt zu tun haben, z.B. eine Zeichenzählmethode in einer Shape-Klasse. Diese Rechnung ist aber auch einer der Kritikpunkte an dieser Metrik: Die Aufspaltung einer Aufgabe in Teilmethoden wird nicht berücksichtigt.

[psheldr]

[bafnai]

Auf den Folien werde ich die alte Definition noch mit der formaleren Definition ersetzen (und auf die Änderung hinweisen).

Wurde die Änderung bereits durchgeführt?
Ich bin mir nämlich gerade unsicher, ob ich die aktuellste Version des Foliensatzes vorliegen habe.

[bubel]

Hallo,

Danke für den Hinweis. Ist hochgeladen.

Viele Grüße,
Richard