Frage zum Design :: allgemein

[mikachu]

Moin moin,

ich hab da mal eine abstrakte klasse für die geschichte rund um xpath geschrieben, welche ihrerseits nur die ganzen achsen beinhaltet...

import java.util.Arrays;
import java.util.Random;
import java.util.Vector;

public abstract class AbstractAxes
{
   private final Vector<EnumAxes> _axes;
   private final int AXES_LENGTH;
   private final Random _rand = new Random();
   private int _lastIndex = 0;

   public AbstractAxes( Class child )
   {
      _axes = new Vector<EnumAxes>();

      if( child == XPathAxes.class )
      {
         _axes.addAll( Arrays.asList( EnumAxes.values() ) );
      }

      if( child == FirstLevelAxes.class )
      {
         _axes.add( EnumAxes.CHILD );
         _axes.add( EnumAxes.DESCENDANT );
         _axes.add( EnumAxes.DESCENDANT_OR_SELF );
         _axes.add( EnumAxes.FOLLOWING_SIBLING );
      }
      AXES_LENGTH = _axes.size();
   }

   /**
    * This method ensures that the next axe is not the same as the last axe.
    * @return the next axe.
    */
   public final String nextShuffledAxe()
   {
      int lastIndex = _lastIndex;
      while( _lastIndex == lastIndex )
         _lastIndex = Math.abs( _rand.nextInt() ) % AXES_LENGTH; 
      return _axes.get( _lastIndex ).value();
   }

   private enum EnumAxes
   {
      CHILD             ( "/child::" ),
      DESCENDANT        ( "/descendant::" ),
      DESCENDANT_OR_SELF( "/descendant-or-self::" ),
      FOLLOWING_SIBLING ( "/following-sibling::" ),

      PARENT            ( "/parent::" ),
      ANCESTOR          ( "/ancestor::" ),
      ANCESTOR_OR_SELF  ( "/ancestor-or-self::" ),
      PRECEDING         ( "/preceding::" ),
      PRECEDING_SIBLING ( "/preceding-sibling::" ),
      FOLLOWING         ( "/following::" ),
      SELF              ( "/self::" );
      
      private String _value;
      private EnumAxes( String valuep )
      {
         _value = value;
      }

      /**
       * @return the value of the axe.
       */
      public String value(){ return _value; }
   }
}

desweiteren hab ich, wie dem aufmerksamen code-leser aufgefallen ist, zwei weitere klassen davon abgeleitet:

public class FirstLevelAxes extends AbstractAxes
{
   public FirstLevelAxes()
   {
      super( FirstLevelAxes.class );
   }
}

und

public class XPathAxes extends AbstractAxes
{
   public XPathAxes()
   {
      super( XPathAxes.class );
   }
}

Jetzt wollt ich fragen, ob das so sinnvoll ist... das es geht, erübrigt sich an dieser stelle...

Ich persönlich finde das mit den zwei abgeleiteten klassen genial (klar, ist ja auch von mir :wink

Gut, ja, es gibt da noch andere Möglichkeiten...
aber was sagt ihr zu diesem Stil ?

 

[kleiner_held]

Wenn man in der abstrakten Baisklasse mit einer abgeleiteten Klasse arbeitet (Zeilen 16 & 21) ist das Design nicht so toll.
Vererbung ist ja grad dazu da, dass man die spezialisierten teile in die Sub-Klassen auslagert und in der abstrakten Oberklasse nur den allgemeinen Teil implementiert.

 

[tfa]

Wie gesagt, ein recht kaputtes Design.
Warum machst Du die spezifischen Initialisierungen nicht in
den Konstruktoren der Unterklassen?

Außerdem scheinen die Code-Conventions nicht einheitlich zu sein.
Eine der (final) Variablennamen fängt mit Unterstrich an, eine andere nicht,
die dritte besteht nur aus Großbuchstaben...

Thomas

 

[mikachu]

@thomas aka tfa
da haste recht... tu ich noch ändern
die mit den nur großbuchstaben ist ne konstante, wie man sieht, aber das mit der rand-variable tu ich noch ändern!

das mit den speziellen daten in den unterklassen hab ich nicht gesagt, dass ich das nicht mag... es ist mir gestern nur mal so eingefallen... sonst mach ich das auch immer so.
mir haben nur die kleinen klässchen gefallen, die nix weiter an die super-klasse geben, als die eigene klasse

ich würde das niee so machen, wenn es für weitere nutzungszwecke bestimmt ist :wink:

 

[byte]

die mit den nur großbuchstaben ist ne konstante, wie man sieht

Konstanten werden als final static deklariert.

Ansonsten wurde schon alles gesagt. Das Design ist schwachsinnig. Eine Oberklasse weiss nichts über seine Unterklassen. Bei diesem Code musst Du die Oberklasse verändern, sobald neue Unterklassen hinzukommen. Damit ist der Nutzen von abstrakten Klassen ausgehebelt und Du kannst gleich alles einfach in eine Klasse schreiben.

 

[mikachu]

ich seh schon...
ihr seid doch sehr aufs funktionelle bedacht...

 

[tfa]

ich seh schon...
ihr seid doch sehr aufs funktionelle bedacht...

Wohl eher aufs objektoriente Design.