Version von der überladenen Methode/Klasse

[xylibri]

Hallo,

ich habe folgendes Problem zu lösen:
Es gibt zwei Klassen, A und B, B wird von A abgeleitet und eine der Methoden wird überladen.

Class A 
{
   protected void myMethod()
   {
      doThis();
   }
   protected void yourMethod(){};
   protected void theirMethod(){};
}

Class B extends A 
{
   protected void myMethod()
   {
      doThat();
   }
}

Die Klassen werden von verschiedenen Entwicklern implementiert (EntwicklerA und EntwicklerB), die nichts voneinander wissen.
Später ändert EntwicklerA diee Methode der Klasse A:

Class A 
{
   protected void myMethod()
   {
      doThis();
      yourMethod();
      theirMethod();
   }
   protected void yourMethod(){};
   protected void theirMethod(){};
}

EntwicklerB aktualisiert die KlasseA. Welche Konzepte gibt es, um dem EntwicklerB "mitzuteilen", dass er seine Methode in der KlasseB evtl. aktualisieren soll?

Eine der Möglichkeiten z.B. ist, eine abstracte Methode mit der Versionsnummer hinzuzufügen:

Class A 
{
   ...
   abstract void version1(){}
}

Class B extends A 
{
   protected void myMethod()
   {
      void version1(){}
   }
}

Nach jeder Änderung in der KlasseA ändert EntwicklerA die Methode version1():

Class A 
{
   ...
   abstract void version2(){}
}

Damit bekommt EntwicklerB mit, dass die KlasseA sich geändert hat.

Nachteil: Umständlich, hässlich, 1 Methode für die ganze Klasse (ich hätte das gerne für jede Methode)

Weißt jemand Konzepte, auch externe Tools (z.B. Hashes von Methoden zu erstellen), wie man dieses Problem lösen kann?

Danke im Voraus.

Gruß
xylibri

 

[mattit-jah]

Wenn ich das richtig verstanden habe, arbeiten zwei Entwickler gleichzeitig an der gleichen Klasse? Ist das Sinnvoll?

Hast du dir schon SVN oder CVS angeschaut?

 

[xylibri]

Die Arbeiten an verschiedenen Klassen: EntwicklerA an A und EntwicklerB an B. Die beiden können auch Versionsverwaltung benutzen. Nach dem Aktualisieren bleibt das Problem. Logs anzuschauen hilft nicht wirklich, wenn sich 1000 Dateien geändert haben, man aber nur an 2 interessiert ist.

 

[Oliver Gierke]

Die Arbeiten an verschiedenen Klassen: EntwicklerA an A und EntwicklerB an B. Die beiden können auch Versionsverwaltung benutzen. Nach dem Aktualisieren bleibt das Problem. Logs anzuschauen hilft nicht wirklich, wenn sich 1000 Dateien geändert haben, man aber nur an 2 interessiert ist.

Dann hast du ein methodisches Problem. Jemand, der 1000 Dateien auf einmal commitet bekommt ein Problem. Mit seinen Kollegen. Genau aus dem von dir geschilderten Grund. Ich würde definitiv nicht anfangen, Methoden mit Versionsinformationen zu versehen. Wer passt mir denn dann all die Clients der Methode an? Ausserdem werden dann die Methodennamen unheimlich hässlich und es gäbe unheimlich viel doppelten Code. Definitiv keine Lösung.

Es ist einfach grundsätzlich keine Idee zwei Leute gleichzeitig an einer Implementierung arbeiten zu lassen. Es sollte regelmäßig mit SPRECHENDEN Kommentaren commitet werden. Sowas wie "Suchfunktion hinzugefügt" ist OK, was nicht geht ist "Änderungen gemacht" oder "Überarbeitet".

Ich committe zum Teil jede halbe Stunde bzw. immer wenn wieder ein compilierbarer sinnvoller Codezustand gegeben ist (Testcases laufen usw.).

Hilfreich ist die Regel, dass derjenige die Konflike mergen muss, der als später eingecheckt hat. Wer das einmal ein zwei Tage nicht gemacht hat, während Kollegen vernünftig arbeiten, ändert sein Verhalten ganz schnell

REINHAUN!