Methoden Methoden anpassen und fehlende Funktionen hinzufügen

DagobertDuck

Bekanntes Mitglied
Guten Abend,

ich melde mich erneut, um meine bisherigen Methoden noch etwas anzupassen und angenehmer für den Benutzer zu gestalten.

Es muss noch geprüft werden, ob der Start- oder Endpunkt des hinzuzufügenden Tracks mit einem Start- oder Endpunkt eines anderen Tracks verbunden ist - natürlich nur wenn !edges.isEmpty(). Im Falle einer Weiche: einer der drei Punkte muss auf einem Start- oder Endpunkt eines anderen Gleises liegen. Nur ein anderes Gleis (normales Gleis oder Weiche) kann mit einem Punkt eines Gleises verbunden werden.

Hier ist meine derzeitige addTrack() Methode:
Java:
    public void addTrack(Track track) throws LogicException {
        /* TODO:
            - Check if start- or endpoint of the track to be added is connected with a start- or endpoint of another track - only if !edges.isEmpty().
                -> In case of a switch: one of the three points must be on a start or end point of another track.
            - Only one other track (normal track or track switch) can be connected to a point of a track.
         */
         edges.computeIfAbsent(track.getStartPoint(), x -> new ArrayList<>()).add(track);
         track.getEndPoints().forEach(p -> edges.computeIfAbsent(p, x -> new ArrayList<>()).add(track));
         ...
    }

Sollte ich hierbei mit Tiefensuche arbeiten? @mihe7 kann die isConnectedAfterRemoving() Methode ggf. einfach etwas angepasst werden?
Außerdem würde ich gerne computeIfAbsent() ersetzen: Falls der key bereits existiert, möchte ich eine Exception werfen lassen. Kann ich dies mit computeIfAbsent() bewerkstelligen, oder ist das gar nicht möglich? Falls nicht, wie kann der Code umstrukturiert werden, sodass eine Exception geworfen wird?

Ähnliches Problem habe ich mit der Methode zum Entfernen eines Tracks:
Java:
    public void removeTrack(int trackId) {
        ...
        edges.remove(track.getStartPoint(), track.getPoints());

        //edges.computeIfAbsent(track.getStartPoint(), x -> new ArrayList<>()).remove(track);
        //track.getEndPoints().forEach(p -> edges.computeIfAbsent(p, x -> new ArrayList<>()).remove(track));
        this.tracks.remove(trackId, track);
    }

Funktioniert computeIfAbsent() im Falle des Entfernens überhaupt? Falls nicht, wie kann dies angepasst werden? edges.remove(track.getStartPoint(), track.getPoints()); funktioniert leider nicht.

Viele Grüße
 

mihe7

Top Contributor
Sollte ich hierbei mit Tiefensuche arbeiten?
Nein, dazu brauchst Du doch keine Tiefensuche. Ganz einfach: edges liefert Dir zu einem gegebenen Punkt alle Gleise, die dort starten oder enden.

Java:
//erstmal eine Abkürzung einführen
private boolean hasConnections(Point p) {
    return !edges.computeIfAbsent(p, x -> new ArrayList<>()).isEmpty();
}

public void addTrack(Track track) throws LogicException {
    if (edges.isEmpty() || hasConnections(track.getStartPoint()) || 
            track.getEndPoints().stream().anyMatch(this::hasConnections)) {
        // track hinzufügen
    } else {
        // Kein Anschlusspunkt vorhanden
    }
}

Falls der key bereits existiert, möchte ich eine Exception werfen lassen.
Das ergibt wenig Sinn. Ich wiederhole mich: "edges liefert Dir zu einem gegebenen Punkt alle Gleise, die dort starten oder enden. "

Funktioniert computeIfAbsent() im Falle des Entfernens überhaupt?
Ja, computeIfAbsent sorgt nur dafür, dass Du nicht null sondern einen bestimmten Wert (hier: eine leere Liste) erhältst. Aus einer Liste etwas entfernen, das in der Liste nicht vorhanden ist, ist kein Problem.

Du kannst natürlich auch explizit vorher prüfen, ob der Punkt in der Map vorhanden ist:
Java:
    public void removeTrack(int trackId) {
        Track track = tracks.get(trackId);
        if (track == null) {
            return; // oder Exception, da Track nicht existiert
        } 
        tracks.remove(trackId);
        for (Point p : track.getPoints()) {
            if (edges.containsKey(p)) {
                edges.get(p).remove(track);
            }
        }
    }
 

DagobertDuck

Bekanntes Mitglied
Danke! An einem Punkt an einem Gleis kann immer nur ein anderes Gleis (normales Gleis oder Gleisweiche) angeschlossen werden.
Wie kann ich dies nun noch beim Hinzufügen eines neuen Tracks überprüfen und damit allerdings nicht die Funktion einer Switch blockieren?

Da ich noch nicht wirklich oft mit Sets/HashSets gearbeitet habe, habe ich die Instanziierung eines HashSets mit nur einem Element leider nicht kürzer hinbekommen:
if (!isConnectedAfterRemoving(Stream.of(track).collect(Collectors.toCollection(HashSet::new)))) - geht das auch etwas kürzer, oder ist das gut so? (Erinnerung: isConnectedAfterRemoving(Set<Track> toRemove))
 

mihe7

Top Contributor
Da ich noch nicht wirklich oft mit Sets/HashSets gearbeitet habe, habe ich die Instanziierung eines HashSets mit nur einem Element leider nicht kürzer hinbekommen:
Collections.singleton(track) liefert ein Set mit dem einzigen Element track.

An einem Punkt an einem Gleis kann immer nur ein anderes Gleis (normales Gleis oder Gleisweiche) angeschlossen werden.
Wie kann ich dies nun noch beim Hinzufügen eines neuen Tracks überprüfen und damit allerdings nicht die Funktion einer Switch blockieren?
Naja, wie viele Tracks dürfen denn von einem Punkt ausgehen oder an einem Punkt enden?

BTW: Die Funktion der Weiche hat damit gar nichts zu tun.
 

DagobertDuck

Bekanntes Mitglied
Naja, wie viele Tracks dürfen denn von einem Punkt ausgehen oder an einem Punkt enden?

BTW: Die Funktion der Weiche hat damit gar nichts zu tun.

Ich habe mich vielleicht etwas unglücklich ausgedrückt. Die Funktion hat damit nichts zu tun, allerdings hängt die Anzahl der potenziell anliegenden Tracks vom Track-Typ ab.

Das reicht doch dann im Grunde genommen schon, oder?
Java:
        if (track.isSwitch(track)) {
            // TODO: Check if number of adjacent tracks is < 3
        } else {
            // TODO: Check if number of adjacent tracks is < 2
        }

Jetzt weiß ich nicht so richtig, ob damit bereits der Fall einer Kreuzung ausgeschlossen wird (?). Also es kann ja passieren, dass eine Kreuzung durch folgenden Ablauf entsteht. So ein Fall muss damit auch abgedeckt sein.

Code:
add switch (1,1) -> (1,2),(2,1)
add switch (2,1) -> (2,-2),(3,1)
add track (1,2) -> (2,2)
add track (2,2) -> (2,1)
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Um an einen Punkt ein Gleis anschließen zu können, darf dort höchstens ein einfaches Gleis liegen, d. h. die Liste ist entweder leer oder sie enthält ein Element mit 2 Punkten.
 

DagobertDuck

Bekanntes Mitglied
Ich tue mich damit gerade etwas schwer, diese Funktion gescheit zu implementieren.

Das ist mit Sicherheit nicht richtig, aber wie würde es richtig aussehen...? Hierbei beachte ich die Endpunkte auch noch gar nicht.
Java:
        if (track.isSwitch(track)) {
            if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 1) {
                return;
            } else {
                // Throw exception
            }
        } else {
            if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 2) {
                return;
            } else {
                // Throw exception
            }
        }

Des Weiteren hat sich herausgestellt, dass es keine Grundeinstellung für eine Weiche gibt. Ich habe die Initialisierung this.switchedTo = this.points.get(0); nun aus dem Konstruktor entfernt. Sollte ich this.switchedTo stattdessen einen anderen Wert (null o. Ä.) zuweisen?
Wirklich problematisch wird es erst bei der Instanziierung einer neuen Track, da mir nicht klar ist, was der Parameter int length beim Hinzufügen einer neuen Switch für einen Wert annehmen soll.

Beispiel:
Code:
add track (1,1) -> (2,1)
1
add switch (2,1) -> (3,1),(2,-2)
2
list tracks
t 1 (1,1) -> (2,1) 1
s 2 (2,1) -> (3,1),(2,-2)
Die Zahl hinter den Endpunkten ist die Länge. Bei einer Switch wird dieser Wert nicht unmittelbar berechnet.

Die Länge soll also erst berechnet werden, sobald mit Hilfe des set-switch-Befehls eine Weichenstellung gewählt wurde. Wäre es nun sinnvoll, den Parameter ganz zu entfernen, oder wie löst man das Problem am besten?
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Das ist mit Sicherheit nicht richtig, aber wie würde es richtig aussehen...? Hierbei beachte ich die Endpunkte auch noch gar nicht.
Richtig. Das äußere if brauchst Du nicht, es bleibt nur
if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 2) {
übrig, wobei Du track.getStartPoint() durch track.getPoints() ersetzen musst. hinten getTrackConnections(track.getStartPoint()).get(0).getPoints().size() == 2 prüfen musst.

Des Weiteren hat sich herausgestellt, dass es keine Grundeinstellung für eine Weiche gibt.
Wie das?
Sollte ich this.switchedTo stattdessen einen anderen Wert (null o. Ä.) zuweisen?
Wenn Du switchTo nichts zuweist, initialisiert Java automatisch mit null. Wenn es aber nur einen Endpunkt gibt, muss switchTo auf diesen gesetzt werden (normales Gleis).

da mir nicht klar ist, was der Parameter int length beim Hinzufügen einer neuen Switch für einen Wert annehmen soll.
Mir auch nicht. Wozu brauchst Du den Parameter, wenn die Länge aus den Punkten berechnet wird?
 

DagobertDuck

Bekanntes Mitglied
Danke.

Leider ist die Aufgabenstellung sehr undurchsichtig und wirklich realitätsnah ist dies auch nicht (?). Gibt es Weichen, die keine Weichenstellung haben...? Jedenfalls wird dies so gefordert und die Weichenstellung wird erst mit Hilfe des zugehörigen Befehls eingestellt.

Wenn Du switchTo nichts zuweist, initialisiert Java automatisch mit null. Wenn es aber nur einen Endpunkt gibt, muss switchTo auf diesen gesetzt werden (normales Gleis).
Wieso muss switchTo bei einem normalen Gleis überhaupt gesetzt werden? Kann ich beim Fahrbetrieb nicht einfach überprüfen, ob es sich um ein normales Gleis oder eine Weiche handelt (isSwitch())?

Mir auch nicht. Wozu brauchst Du den Parameter, wenn die Länge aus den Punkten berechnet wird?
Um z. B. beim Befehl list tracks die Länge auszugeben. Oder soll ich diese dann jedes Mal erneut berechnen? Daher hatte ich die Idee, dies direkt einmal zu speichern, was sich jetzt als schwierig erweisen wird.
 

DagobertDuck

Bekanntes Mitglied
Code:
add track (1,1) -> (2,1)
Exception in thread "main" java.lang.NullPointerException
    at RailNetwork.addTrack(RailNetwork.java:79)
    at Register.addTrack(Register.java:79)
    at AddTrackCommand.execute(AddTrackCommand.java:23)
    at Session.run(Session.java:48)
    at Main.main(Main.java:24)

Die Exception wird geworfen, da die Methode
Java:
    public List<Track> getTrackConnections(Point point) {
        return edges.get(point);
    }

hier aufgerufen wird
Java:
getTrackConnections(track.getStartPoint()).get(0).getPoints().size() != 2
obwohl es zu dem Zeitpunkt (beim Hinzufügen der allerersten Track) noch keine TrackConnections gibt und versucht wird auf das Element mit Index 0 zuzugreifen.
 

mihe7

Top Contributor
Nein, die Exception bekommst Du bereits, weil
getTrackConnections(track.getStartPoint()).isEmpty()
aufgerufen wird. Du musst halt sicherstellen, dass getTrackConnectios() nicht null ist, bevor Du darauf zugreifst.

Zum Beispiel:
Java:
List<Track> connections = getTrackConnections(track.getStartPoint());
if (connections != null && (connections.isEmpty() || connections.get(0).getPoints().size() == 2)) {
Oder eben mit
Java:
List<Track> connections = edges.computeIfAbsent(track.getStartPoint(), () -> new ArrayList<>());
if (connections.isEmpty() || connections.get(0).getPoints().size() == 2) {
 

DagobertDuck

Bekanntes Mitglied
Danke. Warum funktioniert in diesem Fall () bei dem Lambda-Ausdruck nicht? Mit einer Variable x funktioniert es beispielsweise. Gibt es hierbei bestimmte Naming Conventions? Wird () nicht sogar beim Instanziieren benutzt, was hier ja passiert (?).

Jetzt funktionieren auf jeden Fall schon mal die Funktionen Gleis hinzufügen/entfernen und ändern der Weicheneinstellung.

Da ich den Parameter int length entfernen musste, habe ich mir jetzt eine Notlösung gebastelt:
Java:
    private void checkLength(Track track) {
        try {
            int length = track.getStartPoint().distanceTo(track.getSwitchedTo());
        } catch (ArithmeticException e) {
            // Throw exception
        }
    }
und in der addTrack Methode:
Java:
        if (track.getSwitchedTo() != null) {
            checkLength(track);
        }

Dies ist nötig, um einen Integer overflow zu verhindern, der durch eine zu weit entfernte Punktelage entstehen kann.
Meine Methode funktioniert so auch, ist aber nicht wirklich effizient, oder? In der distanceTo() Methode wird eine ArithmeticException geworfen, wenn ein Integer overflow stattfindet. Jetzt weise ich der Variable length einen Wert zu, der allerdings hier nie verwendet wird. Kann das auch irgendwie geschickter gemacht werden?

Geht das hier auch etwas schöner (beim Auflisten der Tracks)?
Java:
private int length;

...

@Override
    public String toString() {
        ...
        if (switchedTo != null) {
            length = getStartPoint().distanceTo(getSwitchedTo());
        }
        if (isSwitch(this)) {
            if (switchedTo != null) {
                return "s " + getId() + " " + getStartPoint() + " -> " + endPoints + " " + length;
            } else {
                return "s " + getId() + " " + getStartPoint() + " -> " + endPoints;
            }
        } else {
            return "t " + getId() + " " + getStartPoint() + " -> " + endPoints + " " + length;
        }
    }
 

mihe7

Top Contributor
Warum funktioniert in diesem Fall () bei dem Lambda-Ausdruck nicht? Mit einer Variable x funktioniert es beispielsweise.
Weil die Funktion einen Parameter erwartet und ich mich verschrieben habe.

Dies ist nötig, um einen Integer overflow zu verhindern, der durch eine zu weit entfernte Punktelage entstehen kann.
Da die Punkte ja nur horizontal/vertikal angeordnet sein dürfen, frage ich mich, wie es hier zu einem Overflow kommen sollte...
 

DagobertDuck

Bekanntes Mitglied
Zum Beispiel bei einer Track (-1073741824,1) -> (1073741824,1). Damit würde ein Integer overflow zustande kommen. Die Überprüfung in der distanceTo() Methode habe ich auch schon programmiert, mir geht es jetzt nur um eine gescheite Abfrage in der addTrack Methode, da der Parameter length wegfällt und eine Switch/Track gar nicht erst erstellt werden soll, wenn der Abstand zu einen der Endpunkte zu weit ist.
 

mihe7

Top Contributor
Hab ich doch geschrieben: nimm long für die Länge, dann hast Du das Problem nicht und auf checkLength() kannst Du dann verzichten.

Dann: switchedTo sollte bei einem normalen Gleis gesetzt sein.

Dein Code verkürzt sich dann Pi mal Daumen zu:
Java:
public String toString() {
    String len = switchedTo == null ? "" : " " + getStartPoint().distanceTo(switchedTo);
    return (isSwitch() ? "s " : "t ") + getId() + " " + getStartPoint() + " -> " + endPoints + len;
}
 

DagobertDuck

Bekanntes Mitglied
Hab ich doch geschrieben: nimm long für die Länge, dann hast Du das Problem nicht und auf checkLength() kannst Du dann verzichten.
Das tut es natürlich auch... Danke!

Dein Code verkürzt sich dann Pi mal Daumen zu:
Java:
public String toString() {
String len = switchedTo == null ? "" : " " + getStartPoint().distanceTo(switchedTo);
return (isSwitch() ? "s " : "t ") + getId() + " " + getStartPoint() + " -> " + endPoints + len;
}

Das ist ja genial, vielen Dank!
 

DagobertDuck

Bekanntes Mitglied
Java:
List<Track> connections = edges.computeIfAbsent(track.getStartPoint(), () -> new ArrayList<>());

if (connections.isEmpty() || connections.get(0).getPoints().size() == 2) {
    ...
} else {
    // Throw exception
}
@mihe7 Leider funktioniert das noch nicht so ganz. Zum Beispiel beim Ablauf
Code:
        add track (1,1) -> (5,1)
        1
        add switch (5,1) -> (8,1),(5,3)
        2
        add track (10,1) -> (8,1)
        3
        add switch (10,-3) -> (10,1),(12,-3)
        4
        add track (10,-3) -> (1,-3)
        Error, only one other track can be connected at any one point on a track

Hier sollte allerdings keine Fehlermeldung ausgegeben werden, da dies ein valides Gleis bzw. Netzwerk wäre. Was ist hier falsch?
 

mihe7

Top Contributor
Täusche ich mich, oder gibt es in letzter Zeit exorbitant viele Fragen zu Graphen und Bahnhöfen?
Das Semester nähert sich dem Ende :)

Eine Weiche ist eine Track, das ist richtig, aber inwiefern löst das mein Problem?
Ich bin wieder soweit, dass ich der Meinung bin, dass an jedem Punkt der Map einfach nur zwei Tracks in der Liste stehen dürfen, sozusagen "ankommender Track" - "ausgehender Track".
 

DagobertDuck

Bekanntes Mitglied
Ich bin wieder soweit, dass ich der Meinung bin, dass an jedem Punkt der Map einfach nur zwei Tracks in der Liste stehen dürfen, sozusagen "ankommender Track" - "ausgehender Track".
Das soll auch so sein. Muss es dann nicht einfach
Java:
if (connections.isEmpty() || connections.get(0).getPoints().size() != 2) {
heißen, oder vertue ich mich hier?
 

DagobertDuck

Bekanntes Mitglied
Das macht natürlich Sinn. Danke! Noch eine kurze Frage: hast du eine Idee, wie ich prüfen kann, ob jede Track zu einem Punkt geswitched ist? Bei normalen Gleisen ist dies ja bereits immer der Fall. Bei Weichen allerdings nicht.
Meine Idee ist
Java:
tracks.values().forEach(x -> (x.getSwitchedTo() != null) ? throw new ... ("position of switches not set")));
So funktioniert es nur leider nicht. Bisher habe ich noch nicht viel mit Lambda-Expressions und Collection/Stream-forEach gearbeitet.
 

mihe7

Top Contributor
Wenn es eine RuntimeException ist, dann sollte
Java:
tracks.values().stream().findAny(x -> x.getSwitchedTo() == null).ifPresent(x -> throw new ...);
funktionieren, sonst
Java:
if (tracks.values().stream().findAny(x -> x.getSwitchedTo() == null).isPresent()) {
    throw ...
}
 

DagobertDuck

Bekanntes Mitglied
Super, danke für die schnelle Antwort. findAny() scheint hier aber nicht zu funktionieren, oder? Dabei wird in meiner IDE die Fehlermeldung Cannot resolve method 'getSwitchedTo()' angezeigt.
 

DagobertDuck

Bekanntes Mitglied
Guten Abend,

das Projekt neigt sich langsam dem Ende zu und ich habe noch Schwierigkeiten mit zwei essentiellen Funktionen.

Die erste Funktion ist es, einen Zug auf ein Gleis zu setzen. Dabei wird immer der ganze Zug komplett auf das Gleis gesetzt. Beim Aufsetzen muss ein Richtungsvektor angegeben werden. Dieser gibt die initiale Fahrrichtung des Zuges an. Der Richtungsvektor entspricht dem Richtungsvektor des Gleises oder ist genau der entgegensetze Vektor. Beim Aufgleisen muss beachtet werden, dass die benutzten Gleise noch frei sind, d.h. kein anderer Zug dort steht und es dort überhaupt ein Gleis gibt. Dabei spielt natürlich auch die Länge eines Zuges eine Rolle. Falls der Zug auf eine Weiche gesetzt werden soll, muss zuerst geprüft werden, ob die Gleisweichenstellung dementsprechend eingestellt ist. Falls dies nicht der Fall ist, soll eine Fehlermeldung ausgegeben werden. Falls Gleisweichen auf denen ein Zug bereits steht, geschaltet werden, entgleist der daraufstehende Zug.

Hier ist meine bisherige Methode:
Java:
    /*
    TODO:
         - Check if there is even a track at the point <point>.
         - If it is a switch at point <point> then check if it's switched to this track.
         - Check if no other train is already on the required track(s) - note the length of the train
         - Check if directionVector fits with direction of track
    */
    public void putTrain(Train train, Point point, Point directionVector) throws LogicException {
        ...
        long trainLength = train.getLength();

    }

Wie sollte ich am besten alle Züge, die aufgegleist sind, speichern? Für den step <speed> Befehl, der alle Züge um n-Einheiten fahren lässt, ist es wichtig zu wissen, in welche Richtung der Zug fahren soll (Richtungsvektor) und auf welchem Punkt sich der Zugkopf (vorderster Wagen) gerade befindet. Meine ursprüngliche Idee war es, die aufgegleisten Züge in einer Map<Point, Train> zu speichern, aber woher weiß man dann beim step Befehl in welche Richtung er fahren soll? Des Weiteren weiß ich noch nicht so richtig wie ich den angegeben Richtungsvektor, der durch eine x- und y-Koordinate angegeben wird, auszuwerten habe. Macht es Sinn ihn zu normieren?
Ich hoffe, dass mir hierbei jemand helfen könnte.

Viele Grüße
 

mihe7

Top Contributor
Also besteht das erste Problem schon einmal darin, das betreffende Gleis zu finden. Schreib mal eine Methode dafür.
 

Mika34

Bekanntes Mitglied
Eine Möglichkeit ist es über das Kreuzprodukt zu berechnen, zumindest klappt es bei mir auf die Weise, wenn ich über die Edges gehe
Java:
    public boolean isPointOnEdge(int xCoordinateToCheck, int yCoordinateToCheck, int lengthOfTrain,
            int xDirectionVector, int yDirectionVector) {
        for (int i = 0; i < allTracks.size(); i++) {
            if (allTracks.get(i) instanceof NormalTrack) {
                int xCoordStart = allTracks.get(i).getStartXCoordiante();
                int yCoordStart = allTracks.get(i).getStartYCoordiante();
                int xCoordEnd = allTracks.get(i).getEndXCoordiante();
                int yCoordEnd = allTracks.get(i).getEndYCoordiante();

                int dxc = xCoordinateToCheck - xCoordStart;
                int dyc = yCoordinateToCheck - yCoordStart;

                int dxl = xCoordEnd - xCoordStart;
                int dyl = yCoordEnd - yCoordStart;

                int cross = dxc * dyl - dyc * dxl;
                if (cross == 0) {
                    if (Math.abs(dxl) >= Math.abs(dyl)) {
                        if (dxl > 0) {
                            ...
                           
                            }
                        }
 

mihe7

Top Contributor
Das hilft hier nicht weiter, da wir hier ein anderes Modell haben. Konkret brauchen wir eine Methode der Form
Java:
/** findet den Track, der ein Gleis enthält, auf dem Punkt p liegt. 
  * @returns Track oder null, falls kein Track gefunden wurde.
  */
public Track findTrack(Point p) {
}
Ist jetzt nicht sooo schwer.
 

DagobertDuck

Bekanntes Mitglied
@mihe7 Ich habe folgende Idee:
Jede Track durchgehen und überprüfen, ob die Distanz vom Startpunkt zum angegebenen Punkt + die Distanz vom Endpunkt zum angegeben Punkt gleich die Distanz vom Startpunkt zum Endpunkt ist. Sobald eine Track mit dieser Eigenschaft gefunden wird, wird sie returned.

Also irgendwie so:
Java:
if (getStartPoint().distanceTo(point) + getEndPoints.get(0).distanceTo(point) == getStartPoint.distanceTo(getEndPoint.get(0))) {
    // Der Punkt liegt auf dem Gleis
    return track;
}
// Der Punkt liegt auf keinem Gleis
return false;

Das ganze dann in einer for-Schleife und beide Endpunkte beachten. Ist dieser Ansatz sinnvoll, oder geht es besser?
 

DagobertDuck

Bekanntes Mitglied
Einer weitere Idee wäre: Für jede Track wird geschaut, ob die x-Koordinate mit der x-Koordinate von dem angegebenen Punkt übereinstimmt. Falls ja, dann: prüfen, ob die y-Koordinate des Punktes zwischen den beiden y-Punkten des Gleises liegt; und umgekehrt. Die Laufzeit des Algorithmus wäre O(n) für die Anzahl der Tracks.
 

mihe7

Top Contributor
Du kannst dabei ausnutzen, dass Du Track-Objekte hast, die Methoden anbieten können... ;)

EDIT: macht den Umgang mit Weichen einfacher.
 

DagobertDuck

Bekanntes Mitglied
Nur wann weiß ich, ob die Track horizontal oder vertikal ist, damit ich entweder die x- oder die y-Koordinate prüfen kann? Muss ich vorher prüfen, ob die x- bzw y-Koordinaten gleich sind -> horizontal / vertikal? Sollte ich mir dafür am besten eine Methode in der Klasse Track schreiben (nur mit welchem Rückgabetyp)?
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
L Methoden methoden an generischen klassentyp anpassen Allgemeine Java-Themen 5
B Leere vererbte Interface-Methoden Allgemeine Java-Themen 8
R Programm führt Methoden gleichzeitig aus Allgemeine Java-Themen 2
Encera Unterschied zweier "toString"-Methoden Allgemeine Java-Themen 1
torresbig Klasse mit extends Calendar über Methoden ändern (Hirnblockade) Allgemeine Java-Themen 7
Sachinbhatt Sind alle Methoden in Java implizit virtuell Allgemeine Java-Themen 2
B Arrays von Methoden möglich? Allgemeine Java-Themen 44
S Mit Methoden kann man definieren für was <T> steht. Geht das auch irgendwie für Variablen? Allgemeine Java-Themen 12
N abstracte klassen methoden Allgemeine Java-Themen 32
G Methoden für die Zukunft sinnvoll? Allgemeine Java-Themen 4
nonickatall Methoden Kann man Klassen/Methoden aus Variablen heraus aufrufen? Allgemeine Java-Themen 6
LimDul Hä? Lambda-Ausdruck geht, Methoden-Referenz nicht Allgemeine Java-Themen 8
B Methoden Java Getter und Setter Methoden Allgemeine Java-Themen 9
Y Java Methoden unterschiedliche Zahlenreihen Allgemeine Java-Themen 2
S Interface Design von HookUp oder Callback Methoden für eigenes Framework Allgemeine Java-Themen 9
F Sich automatisch aufrufende Java-Methoden Allgemeine Java-Themen 2
J Namen von Methoden über Reguläre Ausdrücke bearbeiten Allgemeine Java-Themen 6
V Threads Probleme beim Aufrufen von Methoden einer anderen Klasse (Threads) Allgemeine Java-Themen 14
R Statistische Methoden (Mathematik) Aufgabe Allgemeine Java-Themen 9
X Brüche kürzen mittels Methoden und ggT Allgemeine Java-Themen 15
L Operatoren Java Reflections: Alle Methoden einer Klasse aufrufen ohne Exceptions Allgemeine Java-Themen 5
L mehrere Methoden Allgemeine Java-Themen 19
KeexZDeveoper Zugriff auf Methoden vom Server Allgemeine Java-Themen 7
B StAX Parser - mehrere Methoden, ein XML Allgemeine Java-Themen 4
F Operationen/Methoden einen WebService im Browser mit Apache Axis aufrufen Allgemeine Java-Themen 4
A Automatisches Methoden Laufzeiten logging? Allgemeine Java-Themen 7
M Quellcode von Java-Methoden Allgemeine Java-Themen 9
rentasad Design-Frage - Interfaces, Klassen, statische Methoden Allgemeine Java-Themen 3
N HashMap und Methoden richtig einbinden Allgemeine Java-Themen 2
R Variable durch mehrere Methoden ändern und nutzen Allgemeine Java-Themen 17
Q-bert Methoden Methoden in Java Allgemeine Java-Themen 13
D Methoden Java-Aufgabe Allgemeine Java-Themen 2
M Compiler-Fehler Methoden-Referenz Allgemeine Java-Themen 5
X Threads Externe Variablen in Run Methoden verändern Allgemeine Java-Themen 4
S 2 methoden mit gleichen namen und ein Interface Allgemeine Java-Themen 9
F Enum-werte als Methoden-Parameter übergeben Allgemeine Java-Themen 6
N Vererbung Design-Problem mit vorhandenen, von der Klasse unabhängigen Methoden Allgemeine Java-Themen 12
E OOP Objekte und Methoden Allgemeine Java-Themen 1
K Java ruft Methoden nicht der Reihe nach auf Allgemeine Java-Themen 14
N Methoden Methoden einer Klasse auf Grundlage eines Strings aufrufen Allgemeine Java-Themen 6
T Java Array in Methoden Allgemeine Java-Themen 1
D Code für bereitgestellte Methoden Allgemeine Java-Themen 1
P Entity Objekt Methoden vs Service methoden Allgemeine Java-Themen 2
R Signatur von Methoden in eine Datei schreiben? Allgemeine Java-Themen 4
A Methoden verändern Allgemeine Java-Themen 12
F Methoden Arraylist weiterverwenden nach methoden Aufruf Allgemeine Java-Themen 2
J Best Practice Testen von protected Methoden Allgemeine Java-Themen 7
L Methoden "Schiffe versenken" Quellcode in Methoden umwandeln Allgemeine Java-Themen 6
G Matrix reduzieren zwei Methoden Allgemeine Java-Themen 2
Sogomn Best Practice "Doppelte" Methoden Allgemeine Java-Themen 3
Paul15 String Methoden Allgemeine Java-Themen 7
G Methoden BMI -Wert Aufgabe(Methoden) Allgemeine Java-Themen 4
F Testen von Methoden Allgemeine Java-Themen 3
S "Vererben" statischer Felder/Methoden Allgemeine Java-Themen 4
F Methoden in der Enumeration Klasse Allgemeine Java-Themen 1
S Methoden ohne Methodenkopf ?! Allgemeine Java-Themen 5
T Überschreiben von Methoden Allgemeine Java-Themen 6
M Methoden werden in falscher Reihenfolge bearbeitet Allgemeine Java-Themen 10
S Methoden Methoden überschreiben Allgemeine Java-Themen 3
N Threads statische Methoden in Threads Allgemeine Java-Themen 5
O Java-Obfuscator, welcher einzelne Methoden, Klassen und Ordnerstrukturen ausnehmen kann. Allgemeine Java-Themen 1
A also definition von klassen und string methoden und algorithmik Allgemeine Java-Themen 13
X Eigene Annotation - mit Bedingung für ganze Klassen oder Methoden Allgemeine Java-Themen 2
A Threads Lock über mehrere Abschnitte in verschiedenen Methoden Allgemeine Java-Themen 5
S Methoden Frage Allgemeine Java-Themen 2
R Wie kann man diese Methoden in arrays etablieren? Allgemeine Java-Themen 8
M Methoden in Rescources speichern Allgemeine Java-Themen 4
G Synchronisation nicht statischer Methoden Allgemeine Java-Themen 4
A Vererbung finale Methoden überschreiben Allgemeine Java-Themen 24
A Methoden parallelisieren? Allgemeine Java-Themen 2
C Methoden Übernahme von standart nativen Methoden? Allgemeine Java-Themen 9
B Zusammenfassen verschiedener ähnlicher Methoden Allgemeine Java-Themen 8
K JNI: Methoden aus unterschiedlichen Threads aufrufen Allgemeine Java-Themen 3
P Unterschiedliche Clone- Methoden Allgemeine Java-Themen 5
MQue Spezialfrage Überschreiben von Methoden Allgemeine Java-Themen 14
B Methoden Alle Methoden und Variablen aus Java-Dateien auslesen. Allgemeine Java-Themen 7
MiMa Rekursive Methoden Allgemeine Java-Themen 3
S Programm das alle aufgerufenen Methoden ausgibt..? Allgemeine Java-Themen 6
F ListIterator (next & previous methoden) Allgemeine Java-Themen 5
W Frage zu Refactoring statischer Methoden Allgemeine Java-Themen 4
M Methoden/Klassen für andere Projekte Allgemeine Java-Themen 4
T Methoden per String-Namen aufrufen Allgemeine Java-Themen 2
C Kapselung Warum graift man auf Variablen nur über Methoden und nich direkt zu? Allgemeine Java-Themen 10
M Methoden Static Methoden und Thread??? Allgemeine Java-Themen 4
A Methoden ohne Referenzen finden Allgemeine Java-Themen 9
turmaline OOP zwei gleiche Methoden mit kleinen Unterschieden Allgemeine Java-Themen 15
G JUnit Test Methoden in anderen Thread verlagern Allgemeine Java-Themen 4
K Auf Methoden der Runnable Klasse zugreifen Allgemeine Java-Themen 2
S Methoden Class.forName() >> Methoden - Reihenfolge Allgemeine Java-Themen 5
D Passende Name für Methoden finden Allgemeine Java-Themen 3
D Wann sollte ich statische Methoden und Variablen benutzen? Allgemeine Java-Themen 44
A Methoden laufen im Konstruktor, außerhalb allerdings nicht Allgemeine Java-Themen 2
M Generische Methoden mit Java und globale Variablen Allgemeine Java-Themen 9
GianaSisters ArrayList in Methoden übergeben Allgemeine Java-Themen 3
S static methoden Allgemeine Java-Themen 9
J coole Methoden Allgemeine Java-Themen 6
R Methoden in einem Thread unterschiedlich oft ausführen Allgemeine Java-Themen 4
A OOP: Überschreiben/Implementierung von Methoden Allgemeine Java-Themen 5
P Methoden und Werte Allgemeine Java-Themen 17
E Performace/Ausführungszeit von Methoden ermitteln Allgemeine Java-Themen 4

Ähnliche Java Themen

Neue Themen


Oben