Hilfe bei Design (Pattern)

[perlenfischer1984]

Hallo zusammen.

Ich habe heute mal eine theoretische Frage, zum Design von meiner Software. Kurz zum Ziel. Ich möchte für einen Sportverein, eine Planungssotware schreiben. Es soll möglich sein, verschiedene Mannschaften (z.B. Frauen I, U20 weiblich usw) anzulegen. Es soll dann weiter möglich sein, für jedes Mannschaftsmitglied einen persönlchen Spielplan zu erstellen.

So nun gibt es verschiedene Objekete.
Einen Nationalenverband, mehrere Regionalverbände und weiter Lokalverbände. Alle Verbände behinhalten Wettbewerbe (zum Regionalmeisterschaften, Deutsche Meistschaften usw).

Aus diesem Grund gibt es eine Basisklasse (AbstractAssociation).

Alle Objekte sind abgeleitet von einer Data Klasse, die die gemeinsamen Funktioenn und Members beinhaltet. Allerdings gibt es Klassen, die mit Listen arbeiten (werden von ListOperation) abgeleitet, andere dürfen keine Listen haben und werden nur von SportsObject abgeleitet. Ich finde das ewtas umübersichtlich. Allerdings ist mir nichts anderes eingefallen.

Ich hofe meine Erklärung war nicht zu konfus

 

[mrBrown]

Alle Objekte sind abgeleitet von einer Data Klasse, die die gemeinsamen Funktioenn und Members beinhaltet. Allerdings gibt es Klassen, die mit Listen arbeiten (werden von ListOperation) abgeleitet, andere dürfen keine Listen haben und werden nur von SportsObject abgeleitet.

Dieser Teil klingt merkwürdig und tendenziell nach schlechtem Design, aber in der kürze ist das zu wenig Info, um da mehr zu sagen.

Generell würde ich Vererbung vermeiden, wenn es keine sinnvolle "ist ein"-Beziehung ist, sondern nur zum Teilen von Methoden etc dient - und Data als Klasse klingt nicht nach einer sinnvollen Oberklasse, kommt aber auf den Kontext an.
Für ListOperation als Klasse gilt das gleiche - AbstractAssociation und SportsObject klingen dagegen schon besser, auch wenn der Name von letzterer uU etwas ungünstig ist.

 

[perlenfischer1984]

Danke für deine schnelle Antwort. Ohne Klassendiagramm ist auch nicht so einfach nachzu vollzeiehen.

Meine Abstrakte Klasse beinhaltet eine Liste, die verschiedene SportsObjekte aufnehmen kann. Ich wollte mir den ganzen Kram ersparen addLocalAssociation, addRegionalAssoication. Stattdessen gibt es nur eine Liste, und mann kann dann über getter die Objekte abfrage.

Also : Meine Abstrakte klasse beinhaltet Daten. Aus diesem Grund kann ich ja keine INterface Lösung verwenden. Zumindest nicht nach meinem Kenntnistsand

 

[looparda]

Leider wird mir der Sachverhalt nicht ganz klar. Kannst du vielleicht ein Minimalbeispiel bereitstellen oder ein Klassendiagramm, welches das Problem aufzeigt?

Alle Objekte sind abgeleitet von einer Data Klasse, die die gemeinsamen Funktioenn und Members beinhaltet. Allerdings gibt es Klassen, die mit Listen arbeiten (werden von ListOperation) abgeleitet, andere dürfen keine Listen haben und werden nur von SportsObject abgeleitet.

Du kannst natürlich immer mit Listen arbeiten, und dort wo keine Daten vorhanden sind eine leere Liste zurückgeben.

 

[mrBrown]

Meine Abstrakte Klasse beinhaltet eine Liste, die verschiedene SportsObjekte aufnehmen kann. Ich wollte mir den ganzen Kram ersparen addLocalAssociation, addRegionalAssoication. Stattdessen gibt es nur eine Liste, und mann kann dann über getter die Objekte abfrage.

Also : Meine Abstrakte klasse beinhaltet Daten. Aus diesem Grund kann ich ja keine INterface Lösung verwenden. Zumindest nicht nach meinem Kenntnistsand

Welche Abstrakte Klasse meinst du? Ich les da oben von vieren, die abstrakt sein sollten

 

[perlenfischer1984]

public class DataObject implements Comparable<DataObject> {

    private final String name;

    /**
     * default constructor <br>
     *
     * @param name
     */
    public DataObject(@NonNull String name) {
        log.debug("create a new {} object", DataObject.class.getSimpleName());       
        this.name = name;
    }

    @Override
    public int compareTo(@NonNull DataObject dataObject) {
        return name.compareTo(dataObject.name);
    }

    @Override
    public int hashCode() {
        return 31 + name.hashCode();
    }

    @Override
    public boolean equals(@NonNull Object object) {
        DataObject dataObject = (DataObject) object;

        return name.equals(dataObject.name);
    }

    @Override
    public String toString() {
        return name;
    }
}

@Slf4j
public abstract class SportsObject extends DataObject{

    /**
     * default constructor <br>
     *
     * @param name
     */
    public <T extends SportsObject> SportsObject(@NonNull String name) {
        super(name);

        log.debug("create a new {} object", VolleyballListObject.class.getSimpleName());
    }
   
    /**
     * update the element <br>
     *
     * @param element
     */
    public abstract <T extends SportsObject> void updateElement(@NonNull T element);
}

public abstract class SportsListObject extends SportsObject {

    @Getter(AccessLevel.NONE)
    private Set<Class<?>> acceptedElementType = Sets.newHashSet();

    @Getter(AccessLevel.NONE)
    private List<SportsObject> elementList = Lists.newArrayList();

    /**
     * default constructor <br>
     *
     * @param name
     */
    public SportsListObject(@NonNull String name) {
        super(name);

        log.debug("create a new {} object", SportsListObject.class.getSimpleName());
    }

    /**
     * add the element class to the acceptedElementType list <br<
     *
     * @param list
     */
    protected void acceptedElementType(List<Class<?>> list) {
        for (Class<?> type : list) {
            log.debug("accept {} ", type.getSimpleName());
            acceptedElementType.add(type);
        }
    }

    /**
     * add the list elements to the elementList <br>
     * check if the element class is accepted <br>
     * update the list element if it exists already <br>
     *
     * @param elements
     */
    public <T extends SportsObject> void addElement(@NonNull List<T> elements) {
        for (T element : elements) {

            if (acceptedElementType.contains(element.getClass())) {
                // check if the element exists already
                Optional<SportsObject> optional = elementList.stream().filter(e -> e.equals(element)).findFirst();

                if (optional.isPresent()) {
                    // update the existing element
                    optional.get().updateElement(element);
                } else {
                    // add the element to the element list
                    log.debug("add the {}", element);
                    elementList.add(element);
                }

            } else {
                log.warn("the class {} is not supported ", element, element.getClass().getSimpleName());
            }
        }
    }

    /**
     * remove the elements of the list to the elementList <br>
     * check if the element class is accepted <br>
     * remove the list element if it exists <br>
     *
     * @param elements
     */
    public <T extends SportsObject> void removeElement(@NonNull List<T> elements) {
        for (T element : elements) {

            if (acceptedElementType.contains(element.getClass())) {
                // check if the element exists already
                Optional<SportsObject> optional = elementList.stream().filter(e -> e.equals(element)).findFirst();

                if (optional.isPresent()) {
                    // remove the existing element
                    log.debug("remove the {}", element);
                    elementList.remove(optional.get());
                } else {
                    log.debug("the element {} was not found", element);
                }

            } else {
                log.warn("the class {} is not supported ", element, element.getClass().getSimpleName());
            }
        }
    }

    /**
     * @param elementType
     * @return a list with elements of the appropriate type <br>
     */
    @SuppressWarnings("unchecked")
    protected <T extends SportsObject> List<T> getElementOf(@NonNull Class<T> elementType) {
        return (List<T>) elementList.stream().filter(e -> e.getClass().equals(elementType))
                .collect(Collectors.toList());
    }
}