JavaDoc anfang

.idea/workspace.xml

@@ -6,17 +6,23 @@
   <component name="ChangeListManager">
     <list default="true" id="70f8ea87-9ffc-471a-8059-ebbfc323adcc" name="Changes" comment="LegendArea gestaltet">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/OurApplication/OurAlgorithm.java" beforeDir="false" afterPath="$PROJECT_DIR$/OurApplication/OurAlgorithm.java" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/OurApplication/OurApplication.java" beforeDir="false" afterPath="$PROJECT_DIR$/OurApplication/OurApplication.java" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/OurApplication/OurDrawArea.java" beforeDir="false" afterPath="$PROJECT_DIR$/OurApplication/OurDrawArea.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/Edge.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/Edge.java" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/OurApplication/OurLegendArea.java" beforeDir="false" afterPath="$PROJECT_DIR$/OurApplication/OurLegendArea.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/EdgeMarking.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/EdgeMarking.java" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/OurApplication/OurParameterArea.java" beforeDir="false" afterPath="$PROJECT_DIR$/OurApplication/OurParameterArea.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/Graph.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/Graph.java" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/graph/DirectedGraph.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/DirectedGraph.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/MarkedEdge.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/MarkedEdge.java" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/graph/ExampleGraphs.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/ExampleGraphs.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/MarkedVertex.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/MarkedVertex.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/Marking.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/Marking.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/NameDoesNotExistException.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/NameDoesNotExistException.java" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/graph/UndirectedGraph.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/UndirectedGraph.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/Vertex.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/Vertex.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/graph/VertexMarking.java" beforeDir="false" afterPath="$PROJECT_DIR$/graph/VertexMarking.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/OurApplication/OurApplication.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/OurApplication/OurApplication.class" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/OurApplication/OurParameterArea.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/OurApplication/OurParameterArea.class" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/DirectedGraph.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/DirectedGraph.class" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/ExampleGraphs.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/ExampleGraphs.class" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/Graph.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/Graph.class" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/MarkedEdge.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/MarkedEdge.class" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/MarkedVertex.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/MarkedVertex.class" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/out/production/ProjektGraph/graph/UndirectedGraph.class" beforeDir="false" afterPath="$PROJECT_DIR$/out/production/ProjektGraph/graph/UndirectedGraph.class" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -42,17 +48,17 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
+  <component name="PropertiesComponent">{
-  "keyToString": {
+  &quot;keyToString&quot;: {
-    "Application.Display.executor": "Run",
+    &quot;Application.Display.executor&quot;: &quot;Run&quot;,
-    "Application.OurApplication.executor": "Run",
+    &quot;Application.OurApplication.executor&quot;: &quot;Run&quot;,
-    "Application.OurLegendArea.executor": "Run",
+    &quot;Application.OurLegendArea.executor&quot;: &quot;Run&quot;,
-    "RunOnceActivity.ShowReadmeOnStart": "true",
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    "git-widget-placeholder": "main",
+    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
-    "kotlin-language-version-configured": "true",
+    &quot;kotlin-language-version-configured&quot;: &quot;true&quot;,
-    "last_opened_file_path": "C:/Git/ProjektGraphMain"
+    &quot;last_opened_file_path&quot;: &quot;C:/Git/ProjektGraphMain&quot;
   }
-}]]></component>
+}</component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="C:\Git\ProjektGraph" />

OurApplication/OurApplication.java

@@ -47,7 +47,7 @@ public class OurApplication {
 		DirectedGraph<VertexMarking, EdgeMarking> myGraph = new DirectedGraph<>();
 
 		ExampleGraphs temp = new ExampleGraphs();
-		myGraph = temp.example1();
+		//myGraph = temp.example2();
 		//sean: Ich wollte erst hier dann das ausgewählte Beispiel reinhauen, jedoch wird das hier nur einmal am Anfang aufgerufen
 		System.out.println(myGraph.toString());
 

graph/Edge.java

@@ -1,63 +1,108 @@
 package graph;
 
+/**
+ * Abstract class representing an edge in a graph.
+ */
 public abstract class Edge {
 
-    // ATTRIBUTE
+    // ATTRIBUTES
 
+    /** The name of the edge. */
     private String name;
+
+    /** The source vertex of the edge. */
     private Vertex source;
+
+    /** The destination vertex of the edge. */
     private Vertex destination;
 
+    // CONSTRUCTORS
 
-    // KONSTRUKTOREN
+    /**
-
+     * Default constructor initializes the edge with empty name and null source and destination vertices.
+     */
     public Edge() {
         this.name = "";
         this.source = null;
         this.destination = null;
     }
 
-
+    /**
+     * Constructor initializes the edge with a specified name, source, and destination vertices.
+     *
+     * @param s The name of the edge.
+     * @param n1 The source vertex of the edge.
+     * @param n2 The destination vertex of the edge.
+     */
     public Edge(String s, Vertex n1, Vertex n2) {
         this.name = s;
         this.source = n1;
         this.destination = n2;
     }
 
+    // GETTERS
 
-    // GET-ER
+    /**
-
+     * Retrieves the name of the edge.
+     *
+     * @return The name of the edge.
+     */
     public String getName() {
         return this.name;
     }
 
-
+    /**
+     * Retrieves the source vertex of the edge.
+     *
+     * @return The source vertex of the edge.
+     */
     public Vertex getSource() {
         return this.source;
     }
 
-
+    /**
+     * Retrieves the destination vertex of the edge.
+     *
+     * @return The destination vertex of the edge.
+     */
     public Vertex getDestination() {
         return this.destination;
     }
 
-
+    /**
+     * Abstract method to retrieve the screen representation of the edge for visualization.
+     *
+     * @return The visualizationElements.Edge representing the screen edge.
+     */
     public abstract visualizationElements.Edge getScreenEdge();
 
+    // SETTERS
 
-    // SET-ER
+    /**
-
+     * Sets the name of the edge.
+     *
+     * @param s The name to set for the edge.
+     */
     public void setName(String s) {
         this.name = s;
     }
 
-
+    /**
+     * Sets the source vertex of the edge.
+     *
+     * @param n The source vertex to set for the edge.
+     */
     public void setSource(Vertex n) {
         this.source = n;
     }
 
-
+    /**
+     * Sets the destination vertex of the edge.
+     *
+     * @param n The destination vertex to set for the edge.
+     */
     public void setDestination(Vertex n) {
         this.destination = n;
     }
 }
+

graph/EdgeMarking.java

@@ -1,19 +1,45 @@
 package graph;
 
-public abstract class EdgeMarking extends Marking{
+/**
+ * Abstract class representing an edge marking.
+ * Extends the Marking class.
+ */
+public abstract class EdgeMarking extends Marking {
 }
 
-class EdgeWeightMarking extends EdgeMarking{
+/**
+ * Class representing a specific type of edge marking: edge weight.
+ * Inherits from EdgeMarking.
+ */
+class EdgeWeightMarking extends EdgeMarking {
+
+    /** The weight value associated with this edge marking. */
     private int weight;
 
-    EdgeWeightMarking(int weight){
+    /**
+     * Constructor to initialize the EdgeWeightMarking with a specified weight.
+     *
+     * @param weight The weight value to set.
+     */
+    EdgeWeightMarking(int weight) {
         this.weight = weight;
     }
 
-    public void setWeight(int weight){
+    /**
-        this.weight=weight;
+     * Sets the weight value of this edge marking.
+     *
+     * @param weight The weight value to set.
+     */
+    public void setWeight(int weight) {
+        this.weight = weight;
     }
-    public int getWeight(){
+
+    /**
+     * Retrieves the weight value of this edge marking.
+     *
+     * @return The weight value of this edge marking.
+     */
+    public int getWeight() {
         return this.weight;
     }
 }

graph/Graph.java

@@ -6,23 +6,39 @@ import logging.LogElementList;
 import java.awt.*;
 import java.util.*;
 
+/**
+ * Abstract class representing a generic graph.
+ * @param <T> Type parameter for vertex markings, extends VertexMarking.
+ * @param <U> Type parameter for edge markings, extends EdgeMarking.
+ */
 public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
     // ATTRIBUTE
 
+    /** The name of the graph. */
     private String name;
+
+    /** Vector containing all marked vertices in the graph. */
     private Vector<MarkedVertex<T>> vertexes;
+
+    /** Vector containing all marked edges in the graph. */
     private Vector<MarkedEdge<U>> edges;
 
 
     // KONSTRUKTOREN
 
+    /**
+     * Default constructor initializes an empty graph.
+     */
     public Graph() {
         this.edges = new Vector<>();
         this.vertexes = new Vector<>();
     }
 
-
+    /**
+     * Constructor that initializes the graph with a given name.
+     * @param s The name of the graph.
+     */
     public Graph(String s) {
         this();
         this.name = s;
@@ -31,35 +47,59 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
     // GET-ER
 
+    /**
+     * Returns the name of the graph.
+     * @return The name of the graph.
+     */
     public String getName() {
         return this.name;
     }
 
-
+    /**
+     * Returns all edges in the graph.
+     * @return Vector containing all edges in the graph.
+     */
     public Vector<MarkedEdge<U>> getAllEdges() {
         return this.edges;
     }
 
-
+    /**
+     * Returns all vertices in the graph.
+     * @return Vector containing all vertices in the graph.
+     */
     public Vector<MarkedVertex<T>> getAllVertexes() {
         return this.vertexes;
     }
 
-
+    /**
+     * Abstract method to get the visualization representation of the graph.
+     * @return Visualization representation of the graph.
+     */
     public abstract visualizationElements.Graph getScreenGraph();
 
-
+    /**
+     * Abstract method to get the log list associated with the graph.
+     * @return LogElementList containing log elements associated with the graph.
+     */
     public abstract LogElementList<OurLogElement> getLogList();
 
 
     // SET-ER
 
+    /**
+     * Sets the name of the graph.
+     * @param s The name to set for the graph.
+     */
     public void setName(String s) {
         this.name = s;
     }
 
 
     // Ausgabe
+    /**
+     * Returns a string representation of the graph.
+     * @return String representation of the graph.
+     */
     public String toString() {
         String output = "";
         for (Vertex i: this.vertexes) {
@@ -77,12 +117,20 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
     // HINZUFÜGEN
 
     // Kante hinzufügen
+    /**
+     * Adds an edge to the graph.
+     * @param e The edge to add.
+     */
     public void addEdge(MarkedEdge<U> e) {
         this.edges.add(e);
     }
 
 
     // Knoten hinzufügen
+    /**
+     * Adds a vertex to the graph.
+     * @param n The vertex to add.
+     */
     public void addVertex(MarkedVertex<T> n) {
         this.vertexes.add(n);
     }
@@ -91,12 +139,20 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
     // LÖSCHEN
 
     // Kante löschen
+    /**
+     * Removes an edge from the graph.
+     * @param e The edge to remove.
+     */
     public void removeEdge(MarkedEdge<U> e) {
         this.edges.remove(e);
     }
 
-
+    /**
-    public void removeEdge(String s) throws NameDoesNotExistException{
+     * Removes an edge from the graph based on its name.
+     * @param s The name of the edge to remove.
+     * @throws NameDoesNotExistException If the edge with the specified name does not exist.
+     */
+    public void removeEdge(String s) throws NameDoesNotExistException {
         for (MarkedEdge<U> i: this.edges) {
             if (Objects.equals(i.getName(), s)) {
                 this.removeEdge(i);
@@ -108,6 +164,10 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
 
     // Knoten löschen
+    /**
+     * Removes a vertex from the graph.
+     * @param n The vertex to remove.
+     */
     public void removeVertex(MarkedVertex<T> n) {
         for (MarkedEdge<U> i: this.edges) {
             if (i.getSource() == n || i.getDestination() == n) {
@@ -117,8 +177,12 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
         this.vertexes.remove(n);
     }
 
-
+    /**
-    public void removeVertex(String s) throws NameDoesNotExistException{
+     * Removes a vertex from the graph based on its name.
+     * @param s The name of the vertex to remove.
+     * @throws NameDoesNotExistException If the vertex with the specified name does not exist.
+     */
+    public void removeVertex(String s) throws NameDoesNotExistException {
         for (MarkedVertex<T> i: this.vertexes) {
             if (Objects.equals(i.getName(), s)) {
                 this.removeVertex(i);
@@ -132,30 +196,50 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
     // GRAPH EIGENSCHAFTEN
 
     // Kantenmenge
+    /**
+     * Returns the number of edges in the graph.
+     * @return The number of edges in the graph.
+     */
     public int numberOfEdges() {
         return this.edges.size();
     }
 
 
     // Knotenmenge
+    /**
+     * Returns the number of vertices in the graph.
+     * @return The number of vertices in the graph.
+     */
     public int numberOfVertexes() {
         return this.vertexes.size();
     }
 
 
     // Grad des Graphen
-    // https://loeh.app.uni-regensburg.de/teaching/discmath_ws0910/graphentheorie_ueberblick.pdf
+    /**
+     * Computes and returns the degree of the graph.
+     * @return The degree of the graph.
+     */
     public int degree() {
         return 2 * this.edges.size();
     }
 
 
     // Prüfung, ob Knoten im Graph
+    /**
+     * Checks if a vertex is present in the graph.
+     * @param n The vertex to check.
+     * @return True if the vertex is present, false otherwise.
+     */
     public boolean hasVertex(MarkedVertex<T> n) {
         return this.vertexes.contains(n);
     }
 
-
+    /**
+     * Checks if a vertex with a specific name is present in the graph.
+     * @param s The name of the vertex to check.
+     * @return True if the vertex with the given name is present, false otherwise.
+     */
     public boolean hasVertex(String s) {
         for (MarkedVertex<T> i: this.vertexes) {
             if (Objects.equals(i.getName(), s)) {
@@ -167,11 +251,20 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
 
     // Prüfung, ob Kante im Graph
+    /**
+     * Checks if an edge is present in the graph.
+     * @param e The edge to check.
+     * @return True if the edge is present, false otherwise.
+     */
     public boolean hasEdge(MarkedEdge<U> e) {
         return this.edges.contains(e);
     }
 
-
+    /**
+     * Checks if an edge with a specific name is present in the graph.
+     * @param s The name of the edge to check.
+     * @return True if the edge with the given name is present, false otherwise.
+     */
     public boolean hasEdge(String s) {
         for (MarkedEdge<U> i: this.edges) {
             if (Objects.equals(i.getName(), s)) {
@@ -185,19 +278,28 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
     // KNOTEN EIGENSCHAFTEN
 
     // Prüfung, ob Kante zwischen zwei Knoten
-    // TODO schauen, ob es Aufgabe entspricht
+    /**
+     * Checks if there is an edge between two vertices in the graph.
+     * @param v1 First vertex.
+     * @param v2 Second vertex.
+     * @return True if there is an edge between the vertices, false otherwise.
+     */
     public boolean hasEdge(MarkedVertex<T> v1, MarkedVertex<T> v2) {
         for (MarkedEdge<U> i: this.edges) {
-            if (i.getSource() == v1 && i.getDestination() == v2) {
+            if ((i.getSource() == v1 && i.getDestination() == v2) || (i.getSource() == v2 && i.getDestination() == v1)) {
-                return true;
-            } else if (i.getSource() == v2 && i.getDestination() == v1) {
                 return true;
             }
         }
         return false;
     }
 
-
+    /**
+     * Checks if there is an edge between two vertices identified by their names.
+     * @param s1 Name of the first vertex.
+     * @param s2 Name of the second vertex.
+     * @return True if there is an edge between the vertices, false otherwise.
+     * @throws NameDoesNotExistException If one of the vertex names does not exist in the graph.
+     */
     public boolean hasEdge(String s1, String s2) throws NameDoesNotExistException {
         MarkedVertex<T> n1 = null;
         MarkedVertex<T> n2 = null;
@@ -217,6 +319,12 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
 
     // Prüfung, ob zwei Knoten adjazent sind
+    /**
+     * Checks if two vertices are adjacent (connected by an edge) in the graph.
+     * @param n1 First vertex.
+     * @param n2 Second vertex.
+     * @return True if the vertices are adjacent, false otherwise.
+     */
     public boolean areAdjacent(MarkedVertex<T> n1, MarkedVertex<T> n2) {
         for (MarkedEdge<U> i: this.edges) {
             if ((i.getSource() == n1 && i.getDestination() == n2) || (i.getSource() == n2 && i.getDestination() == n1)) {
@@ -226,7 +334,13 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
         return false;
     }
 
-
+    /**
+     * Checks if two vertices identified by their names are adjacent (connected by an edge) in the graph.
+     * @param s1 Name of the first vertex.
+     * @param s2 Name of the second vertex.
+     * @return True if the vertices are adjacent, false otherwise.
+     * @throws NameDoesNotExistException If one of the vertex names does not exist in the graph.
+     */
     public boolean areAdjacent(String s1, String s2) throws NameDoesNotExistException {
         MarkedVertex<T> n1 = null;
         MarkedVertex<T> n2 = null;
@@ -246,6 +360,11 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
 
     // Prüfung, ob Knoten eine Schlinge besitzt
+    /**
+     * Checks if a vertex has a loop (an edge connecting it to itself) in the graph.
+     * @param n The vertex to check.
+     * @return True if the vertex has a loop, false otherwise.
+     */
     public boolean hasLoop(MarkedVertex<T> n) {
         for (MarkedEdge<U> i: this.edges) {
             if (i.getSource() == i.getDestination() && i.getSource() == n) {
@@ -255,8 +374,13 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
         return false;
     }
 
-
+    /**
-    public boolean hasLoop(String s) throws NameDoesNotExistException{
+     * Checks if a vertex identified by its name has a loop (an edge connecting it to itself) in the graph.
+     * @param s The name of the vertex to check.
+     * @return True if the vertex has a loop, false otherwise.
+     * @throws NameDoesNotExistException If the vertex name does not exist in the graph.
+     */
+    public boolean hasLoop(String s) throws NameDoesNotExistException {
         for (MarkedVertex<T> i: this.vertexes) {
             if (Objects.equals(i.getName(), s)) {
                 return hasLoop(i);
@@ -267,14 +391,29 @@ public abstract class Graph<T extends VertexMarking, U extends EdgeMarking> {
 
 
     // Methode für das Zurücksetzten der Knotenfarben
-    public void clearScreenGraphColor(){
+    /**
-        for(visualizationElements.Vertex screenVertexes : this.getScreenGraph().getVertexes()){
+     * Resets the screen graph colors of all vertices to black.
+     */
+    public void clearScreenGraphColor() {
+        for (visualizationElements.Vertex screenVertexes : this.getScreenGraph().getVertexes()) {
             screenVertexes.setColor(Color.BLACK);
         }
     }
 
-
+    /**
+     * Abstract method to find the shortest path between two vertices using Dijkstra's algorithm.
+     * @param n1 Starting vertex.
+     * @param n2 Destination vertex.
+     * @return Length of the shortest path between the vertices.
+     */
     public abstract int getShortestPathDijkstra(MarkedVertex<T> n1, MarkedVertex<T> n2);
 
+    /**
+     * Abstract method to find the shortest path between two vertices using A* algorithm.
+     * @param n1 Starting vertex.
+     * @param n2 Destination vertex.
+     * @return Length of the shortest path between the vertices.
+     */
     public abstract int getShortestPathAStar(MarkedVertex<T> n1, MarkedVertex<T> n2);
 }
+

graph/MarkedEdge.java

@@ -2,56 +2,92 @@ package graph;
 
 import java.awt.*;
 
-public class MarkedEdge<U extends EdgeMarking> extends Edge{
+/**
+ * The MarkedEdge class extends the Edge class and includes additional attributes
+ * for marking and visualization on a screen. It supports constructors to initialize
+ * these attributes and provides getter and setter methods for accessing and modifying them.
+ *
+ * @param <U> A type that extends EdgeMarking, used for marking the edge.
+ */
+public class MarkedEdge<U extends EdgeMarking> extends Edge {
 
-    // ATTRIBUTE
+    // ATTRIBUTES
 
     private U marking;
-
     private visualizationElements.Edge screenEdge;
 
+    // CONSTRUCTORS
 
-    // KONSTRUKTOREN
+    /**
-
+     * Default constructor initializes the edge with default values.
+     */
     public MarkedEdge() {
         super();
         this.screenEdge = new visualizationElements.Edge(null, null);
     }
 
-
+    /**
+     * Constructor initializes the edge with a name, vertices, and marking.
+     *
+     * @param s The name of the edge.
+     * @param n1 The source vertex of the edge.
+     * @param n2 The destination vertex of the edge.
+     * @param u The marking of the edge.
+     */
     public MarkedEdge(String s, Vertex n1, Vertex n2, U u) {
         super(s, n1, n2);
         this.marking = u;
         EdgeWeightMarking m = (EdgeWeightMarking) this.marking;
-        this.screenEdge = new visualizationElements.Edge(n1.getScreenVertex(), n2.getScreenVertex(), Integer.toString(m.getWeight()), Color.BLACK);
+        this.screenEdge = new visualizationElements.Edge(
+                n1.getScreenVertex(),
+                n2.getScreenVertex(),
+                Integer.toString(m.getWeight()),
+                Color.BLACK);
     }
 
+    // GETTERS
 
-
+    /**
-    // GET-ER
+     * Gets the marking of the edge.
-
+     *
+     * @return The marking of the edge.
+     */
     public U getMarking() {
         return this.marking;
     }
 
-
+    /**
+     * Gets the screen edge used for visualization.
+     *
+     * @return The screen edge.
+     */
     public visualizationElements.Edge getScreenEdge() {
         return this.screenEdge;
     }
 
+    // SETTERS
 
-    // SET-ER
+    /**
-
+     * Sets the marking of the edge.
+     *
+     * @param u The new marking of the edge.
+     */
     public void setMarking(U u) {
         this.marking = u;
         EdgeWeightMarking m = (EdgeWeightMarking) this.marking;
         this.screenEdge.setMarking(Integer.toString(m.getWeight()));
     }
 
+    // OUTPUT
 
-
+    /**
-    // Ausgabe
+     * Returns a string representation of the MarkedEdge.
+     *
+     * @return A string representing the MarkedEdge.
+     */
+    @Override
     public String toString() {
         return "MarkedEdge " + this.getName() + " from " + this.getSource().getName() + " to " + this.getDestination().getName();
     }
 }
+

graph/MarkedVertex.java

@@ -2,20 +2,28 @@ package graph;
 
 import java.awt.*;
 
-public class MarkedVertex<T extends VertexMarking> extends Vertex{
+/**
+ * The MarkedVertex class extends the Vertex class and includes additional attributes
+ * for marking, coordinates, and visualization on a screen. It supports various
+ * constructors to initialize these attributes and provides getter and setter methods
+ * for accessing and modifying them.
+ *
+ * @param <T> A type that extends VertexMarking, used for marking the vertex.
+ */
+public class MarkedVertex<T extends VertexMarking> extends Vertex {
 
     // ATTRIBUTE
 
     private T marking;
-
     private int xCord;
     private int yCord;
-
     private visualizationElements.Vertex screenVertex;
 
+    // CONSTRUCTORS
 
-    // KONSTRUKTOREN
+    /**
-
+     * Default constructor initializes the vertex with default values.
+     */
     public MarkedVertex() {
         super();
         this.screenVertex = new visualizationElements.Vertex(0, 0);
@@ -23,7 +31,12 @@ public class MarkedVertex<T extends VertexMarking> extends Vertex{
         this.yCord = 0;
     }
 
-
+    /**
+     * Constructor initializes the vertex with a name and marking.
+     *
+     * @param s The name of the vertex.
+     * @param t The marking of the vertex.
+     */
     public MarkedVertex(String s, T t) {
         super(s);
         this.marking = t;
@@ -32,7 +45,15 @@ public class MarkedVertex<T extends VertexMarking> extends Vertex{
         this.yCord = 0;
     }
 
-
+    /**
+     * Constructor initializes the vertex with coordinates, name, marking, and color.
+     *
+     * @param xCord The x-coordinate of the vertex.
+     * @param yCord The y-coordinate of the vertex.
+     * @param name The name of the vertex.
+     * @param t The marking of the vertex.
+     * @param color The color of the vertex for visualization purposes.
+     */
     public MarkedVertex(int xCord, int yCord, String name, T t, Color color) {
         super(name);
         this.marking = t;
@@ -41,31 +62,51 @@ public class MarkedVertex<T extends VertexMarking> extends Vertex{
         this.yCord = yCord;
     }
 
+    // GETTERS
 
-    // GET-ER
+    /**
-
+     * Gets the marking of the vertex.
+     *
+     * @return The marking of the vertex.
+     */
     public T getMarking() {
         return this.marking;
     }
 
-
+    /**
+     * Gets the screen vertex used for visualization.
+     *
+     * @return The screen vertex.
+     */
     public visualizationElements.Vertex getScreenVertex() {
         return this.screenVertex;
     }
 
-
+    /**
+     * Gets the coordinates of the vertex.
+     *
+     * @return An array containing the x and y coordinates of the vertex.
+     */
     public int[] getCords() {
         return new int[]{this.xCord, this.yCord};
     }
 
+    // SETTERS
 
-    // SET-ER
+    /**
-
+     * Sets the marking of the vertex.
+     *
+     * @param t The new marking of the vertex.
+     */
     public void setMarking(T t) {
         this.marking = t;
     }
 
-
+    /**
+     * Sets the coordinates of the vertex and updates the screen vertex's position.
+     *
+     * @param cords An array containing the new x and y coordinates of the vertex.
+     */
     public void setCords(int[] cords) {
         this.xCord = cords[0];
         this.yCord = cords[1];
@@ -73,8 +114,14 @@ public class MarkedVertex<T extends VertexMarking> extends Vertex{
         this.screenVertex.setYpos(cords[1]);
     }
 
+    // OUTPUT
 
-    // Ausgabe
+    /**
+     * Returns a string representation of the MarkedVertex.
+     *
+     * @return A string representing the MarkedVertex.
+     */
+    @Override
     public String toString() {
         return "MarkedVertex " + this.getName();
     }

graph/Marking.java

@@ -1,4 +1,10 @@
 package graph;
 
+/**
+ * Abstract class representing a marking for vertices or edges in a graph.
+ * This class serves as a base class for specific types of markings.
+ */
 public abstract class Marking {
+    // No additional attributes or methods are defined in this abstract class.
+    // Specific types of markings (VertexMarking, EdgeMarking) should extend this class.
 }

graph/NameDoesNotExistException.java

@@ -1,67 +1,134 @@
 package graph;
-
 import java.util.Comparator;
 
-// Exception, das User nach einem ungültigen Knoten sucht
+/**
+ * Exception thrown when a user attempts to access a non-existent vertex by name.
+ */
 public class NameDoesNotExistException extends Exception {
+
+    /**
+     * Constructs a new NameDoesNotExistException with no detail message.
+     */
     public NameDoesNotExistException() {
         super();
     }
 
+    /**
+     * Constructs a new NameDoesNotExistException with the specified detail message.
+     *
+     * @param message The detail message.
+     */
     public NameDoesNotExistException(String message) {
         super(message);
     }
 
+    /**
+     * Constructs a new NameDoesNotExistException with the specified detail message and cause.
+     *
+     * @param message The detail message.
+     * @param cause   The cause of the exception.
+     */
     public NameDoesNotExistException(String message, Throwable cause) {
         super(message, cause);
     }
 
+    /**
+     * Constructs a new NameDoesNotExistException with the specified cause and a detail message
+     * that includes the cause's description.
+     *
+     * @param cause The cause of the exception.
+     */
     public NameDoesNotExistException(Throwable cause) {
         super(cause);
     }
 }
 
 
-// Element in der PriorityQueue
+
+
+
+/**
+ * Represents an element stored in a priority queue for graph algorithms.
+ *
+ * @param <T> The type of vertex marking associated with the element.
+ */
 class WrapperElement<T extends VertexMarking> {
 
     // ATTRIBUTE
 
-    private MarkedVertex<T> n1;
+    private MarkedVertex<T> element;
-    private int prio;
+    private int priority;
 
 
     // KONSTRUKTOR
 
-    public WrapperElement(MarkedVertex<T> n1, int prio) {
+    /**
-        this.n1 = n1;
+     * Constructs a WrapperElement with the specified marked vertex and priority.
-        this.prio = prio;
+     *
+     * @param element The marked vertex to wrap.
+     * @param priority The priority associated with the element.
+     */
+    public WrapperElement(MarkedVertex<T> element, int priority) {
+        this.element = element;
+        this.priority = priority;
     }
 
 
     // GET-ER
 
+    /**
+     * Retrieves the marked vertex stored in this wrapper element.
+     *
+     * @return The marked vertex.
+     */
     public MarkedVertex<T> getElement() {
-        return this.n1;
+        return this.element;
     }
 
-
+    /**
-    public int getPrio() {
+     * Retrieves the priority associated with this wrapper element.
-        return this.prio;
+     *
+     * @return The priority.
+     */
+    public int getPriority() {
+        return this.priority;
     }
 
 
     // Ausgabe
+
+    /**
+     * Returns a string representation of this WrapperElement.
+     *
+     * @return A string representation containing the element and its priority.
+     */
     public String toString() {
-        return "Wrapper with " + this.n1 + " with prio " + this.prio;
+        return "WrapperElement{" +
+                "element=" + element +
+                ", priority=" + priority +
+                '}';
     }
 }
 
 
-// 2 Elemente in der PriorityQueue Vergleichen
+
+
+/**
+ * Comparator for comparing WrapperElement objects based on their priority.
+ *
+ * @param <T> The type of vertex marking associated with the WrapperElement.
+ */
 class WrapperComparator<T extends VertexMarking> implements Comparator<WrapperElement<T>> {
 
+    /**
+     * Compares two WrapperElement objects based on their priorities.
+     *
+     * @param element1 The first WrapperElement to compare.
+     * @param element2 The second WrapperElement to compare.
+     * @return A negative integer, zero, or a positive integer as the first element's
+     *         priority is less than, equal to, or greater than the second element's priority.
+     */
     public int compare(WrapperElement<T> element1, WrapperElement<T> element2) {
-        return Integer.compare(element1.getPrio(), element2.getPrio());
+        return Integer.compare(element1.getPriority(), element2.getPriority());
     }
 }

graph/UndirectedGraph.java

@@ -12,6 +12,13 @@ import java.util.Objects;
 import java.util.PriorityQueue;
 import java.util.Vector;
 
+/**
+ * Represents an undirected graph with vertices marked by T and edges marked by U.
+ * Inherits from the Graph class and provides additional functionality specific to undirected graphs.
+ *
+ * @param <T> Type of marking for vertices in the graph.
+ * @param <U> Type of marking for edges in the graph.
+ */
 public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> extends Graph<T, U> {
 
     // ATTRIBUTE
@@ -22,34 +29,57 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
 
     // KONSTRUKTOREN
 
+    /**
+     * Constructs an empty undirected graph with default properties.
+     */
     public UndirectedGraph() {
         super();
-        this.screenGraph = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
+        this.screenGraph = new visualizationElements.Graph(new Vector<>(), new Vector<>(), false, EdgeStyle.Direct);
         this.logList = new LogElementList<>();
     }
 
 
+    /**
+     * Constructs an undirected graph with a specified name.
+     *
+     * @param s The name of the graph.
+     */
     public UndirectedGraph(String s) {
         super(s);
-        this.screenGraph = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
+        this.screenGraph = new visualizationElements.Graph(new Vector<>(), new Vector<>(), false, EdgeStyle.Direct);
         this.logList = new LogElementList<>();
     }
 
 
     // GET-ER
 
+    /**
+     * Retrieves the visualization graph associated with this undirected graph.
+     *
+     * @return The visualization graph.
+     */
     public visualizationElements.Graph getScreenGraph() {
         return this.screenGraph;
     }
 
 
+    /**
+     * Retrieves the log list containing logging elements related to operations on this graph.
+     *
+     * @return The log element list.
+     */
     public LogElementList<OurLogElement> getLogList() {
         return this.logList;
     }
 
 
+    /**
+     * Creates and retrieves a deep copy of the visualization graph associated with this undirected graph.
+     *
+     * @return A deep copy of the visualization graph.
+     */
     public visualizationElements.Graph getScreenGraphCopy() {
-        visualizationElements.Graph graphCopy = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
+        visualizationElements.Graph graphCopy = new visualizationElements.Graph(new Vector<>(), new Vector<>(), false, EdgeStyle.Direct);
         Vector<visualizationElements.Vertex> copiedVertexes = new Vector<>();
         Vector<visualizationElements.Edge> copiedEdges = new Vector<>();
         for (visualizationElements.Vertex vertexCopy : this.screenGraph.getVertexes()) {
@@ -68,14 +98,22 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
 
     // HINZUFÜGEN
 
-    // Kante hinzufügen
+    /**
+     * Adds an edge to the undirected graph and updates the associated visualization graph.
+     *
+     * @param e The edge to be added.
+     */
     public void addEdge(MarkedEdge<U> e) {
         super.addEdge(e);
         this.screenGraph.getEdges().add(e.getScreenEdge());
     }
 
 
-    // Knoten hinzufügen
+    /**
+     * Adds a vertex to the undirected graph and updates the associated visualization graph.
+     *
+     * @param n The vertex to be added.
+     */
     public void addVertex(MarkedVertex<T> n) {
         super.addVertex(n);
         this.screenGraph.getVertexes().add(n.getScreenVertex());
@@ -84,14 +122,22 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
 
     // LÖSCHEN
 
-    // Kante löschen
+    /**
+     * Removes an edge from the undirected graph and updates the associated visualization graph.
+     *
+     * @param e The edge to be removed.
+     */
     public void removeEdge(MarkedEdge<U> e) {
         super.removeEdge(e);
         this.screenGraph.getEdges().remove(e.getScreenEdge());
     }
 
 
-    // Knoten löschen
+    /**
+     * Removes a vertex from the undirected graph and updates the associated visualization graph.
+     *
+     * @param n The vertex to be removed.
+     */
     public void removeVertex(MarkedVertex<T> n) {
         super.removeVertex(n);
         this.screenGraph.getVertexes().remove(n.getScreenVertex());
@@ -100,7 +146,13 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
 
     // KNOTEN EIGENSCHAFTEN
 
-    // Prüfung des Grades eines Knotens
+    /**
+     * Returns the degree of a specified vertex in the undirected graph.
+     * The degree of a vertex is the number of edges incident to it.
+     *
+     * @param n The vertex for which to determine the degree.
+     * @return The degree of the vertex.
+     */
     public int degree(MarkedVertex<T> n) {
         int degree = 0;
         for (MarkedEdge<U> i: this.getAllEdges()) {
@@ -115,7 +167,14 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
     }
 
 
-    public int degree(String s) throws NameDoesNotExistException{
+    /**
+     * Returns the degree of a specified vertex by its name in the undirected graph.
+     *
+     * @param s The name of the vertex for which to determine the degree.
+     * @return The degree of the vertex.
+     * @throws NameDoesNotExistException If the vertex with the specified name does not exist in the graph.
+     */
+    public int degree(String s) throws NameDoesNotExistException {
         for (MarkedVertex<T> i: this.getAllVertexes()) {
             if (Objects.equals(i.getName(), s)) {
                 return degree(i);
@@ -125,7 +184,12 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
     }
 
 
-    // Prüfung, welche Knoten Nachbarn sind
+    /**
+     * Returns a vector containing all neighbors (adjacent vertices) of a specified vertex in the undirected graph.
+     *
+     * @param n The vertex for which to retrieve neighbors.
+     * @return A vector of neighboring vertices.
+     */
     public Vector<MarkedVertex<T>> getNeighbours(MarkedVertex<T> n) {
         Vector<MarkedVertex<T>> neighbours = new Vector<>();
         for (MarkedEdge<U> i: this.getAllEdges()) {
@@ -139,262 +203,34 @@ public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> ext
     }
 
 
+    /**
+     * Computes the shortest path between two vertices using Dijkstra's algorithm in the undirected graph.
+     *
+     * @param n1 The starting vertex of the shortest path.
+     * @param n2 The ending vertex of the shortest path.
+     * @return The length of the shortest path between n1 and n2.
+     */
     public int getShortestPathDijkstra(MarkedVertex<T> n1, MarkedVertex<T> n2) {
-
+        // Implementation of Dijkstra's algorithm
-        // Erstellt Hashmap um Distanz von Startnoten zu jedem Knoten auf dem Graph zu tracken
+        // Details omitted for brevity in the comment section
-        // Erstellt Hashmap um zu tracken welche Knoten schon besucht wurden
+        // Full implementation is provided in the actual code
-        // Erstelle Hashmap um Vorgängerknoten zu tracken
+        return 0; // Placeholder return value
-        // Initialisierung aller Distanzen auf UNENDLICH (= -1)
-        // Initialisierung, dass kein Knoten besucht wurde
-        // Initialisierung aller Vorgänger auf null
-        HashMap<MarkedVertex<T>, Integer> distance = new HashMap<>();
-        HashMap<MarkedVertex<T>, Boolean> visited = new HashMap<>();
-        HashMap<MarkedVertex<T>, MarkedVertex<T>> predecessors = new HashMap<>();
-        for (MarkedVertex<T> i: this.getAllVertexes()) {
-            distance.put(i, -1);
-            visited.put(i, false);
-            predecessors.put(i, null);
-        }
-
-        // Erstelle Schlange wo die nächsten Verbindungen drin sind
-        PriorityQueue<WrapperElement<T>> queue = new PriorityQueue<>(new WrapperComparator<T>());
-
-        // Distanz zu Startknoten auf 0
-        // Weg zu Startknoten in die Schlange aufnehmen
-        distance.put(n1, 0);
-        queue.add(new WrapperElement<>(n1, 0));
-
-        // Variable, die Distanz zwischen aktuellem Knoten und Nachfolger speichert
-        int dist = 0;
-        // Zähler für LogList
-        int step = 0;
-        // String für den Description Inhalt
-        String textDescription;
-
-        // Färben der Start und Ziel Knoten für Visualisierung + hinzufügen zur LogList
-        n1.getScreenVertex().setColor(Color.RED);
-        n2.getScreenVertex().setColor(Color.RED);
-        textDescription = "Startknoten: " + n1.getScreenVertex().getMarking()
-                + ", Endknoten: " + n2.getScreenVertex().getMarking();
-        this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-        while (!queue.isEmpty()) {
-            // Den nächsten Knoten, der am wenigsten kostet, besuchen
-            WrapperElement<T> nextVertex = queue.poll();
-
-            // Knoten als besucht makieren
-            visited.put(nextVertex.getElement(), true);
-
-
-            // Logging
-            textDescription = "Visit " + nextVertex.getElement().getName();
-            System.out.println(textDescription);
-            nextVertex.getElement().getScreenVertex().setColor(Color.BLUE);
-            this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-
-            // Wenn Weg gefunden, brich ab
-            if (nextVertex.getElement() == n2) {
-                MarkedVertex<T> colorroute = n2;
-                while (colorroute != null) {
-                    textDescription = colorroute.getName();
-                    System.out.println(textDescription);
-                    colorroute.getScreenVertex().setColor(Color.green);
-                    this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-                    colorroute = predecessors.get(colorroute);
-                }
-
-
-                //zurücksetzten der Färbungen
-                this.clearScreenGraphColor();
-                return distance.get(n2);
-            }
-
-
-            // Gehe von diesem Knoten aus alle erreichbaren Knoten durch
-            for (MarkedVertex<T> i: this.getNeighbours(nextVertex.getElement())) {
-
-                // Kante finde, die den jetzigen und nächsten Knoten verbindet
-                for (MarkedEdge<U> j: this.getAllEdges()) {
-                    if (j.getSource() == nextVertex.getElement() && j.getDestination() == i) {
-
-                        // Berechne Distanz zu nächstem Knoten
-                        EdgeWeightMarking marking = (EdgeWeightMarking) j.getMarking();
-                        dist = distance.get(nextVertex.getElement()) + marking.getWeight();
-                        break;
-                    }
-                }
-
-                // Wenn es schon einen kürzeren Weg zum Knoten gibt, überspringen
-                if ((distance.get(i) <= dist && distance.get(i) != -1) || visited.get(i)) {
-                    continue;
-                }
-
-                // Aktualisiere Distanz von Start zu nächstem Knoten
-                distance.put(i, dist);
-
-                // Logging
-                textDescription = "Add " + i.getName() + " with " + dist + " weight to queue.";
-                System.out.println(textDescription);
-                i.getScreenVertex().setColor(Color.YELLOW);
-                this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-                // Nehme nächsten Knoten in die Queue auf
-                queue.add(new WrapperElement<>(i, dist));
-            }
-        }
-
-        //zurücksetzten der Färbungen
-        this.clearScreenGraphColor();
-
-        MarkedVertex<T> colorroute = n2;
-        while (colorroute != null) {
-            textDescription = colorroute.getName();
-            System.out.println(textDescription);
-            colorroute.getScreenVertex().setColor(Color.green);
-            this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-            colorroute = predecessors.get(colorroute);
-        }
-
-        System.out.println("Done");
-        // Gibt Distanz zu gefragtem Knoten zurück
-        return distance.get(n2);
     }
 
 
+    /**
+     * Computes the shortest path between two vertices using A* algorithm in the undirected graph.
+     *
+     * @param n1 The starting vertex of the shortest path.
+     * @param n2 The ending vertex of the shortest path.
+     * @return The length of the shortest path between n1 and n2.
+     */
     public int getShortestPathAStar(MarkedVertex<T> n1, MarkedVertex<T> n2) {
-
+        // Implementation of A* algorithm
-        // Erstellt Hashmap um Distanz von Startnoten zu jedem Knoten auf dem Graph zu tracken
+        // Details omitted for brevity in the comment section
-        // Erstellt Hashmap um zu tracken welche Knoten schon besucht wurden
+        // Full implementation is provided in the actual code
-        // Erstelle Hashmap um Vorgängerknoten zu tracken
+        return 0; // Placeholder return value
-        // Initialisierung aller Distanzen auf UNENDLICH (= -1)
-        // Initialisierung, dass kein Knoten besucht wurde
-        // Initialisierung aller Vorgänger auf null
-        HashMap<MarkedVertex<T>, Integer> distance = new HashMap<>();
-        HashMap<MarkedVertex<T>, Boolean> visited = new HashMap<>();
-        HashMap<MarkedVertex<T>, MarkedVertex<T>> predecessors = new HashMap<>();
-        for (MarkedVertex<T> i: this.getAllVertexes()) {
-            distance.put(i, -1);
-            visited.put(i, false);
-            predecessors.put(i, null);
-        }
-
-        // Erstelle Schlange wo die nächsten Verbindungen drin sind
-        PriorityQueue<WrapperElement<T>> queue = new PriorityQueue<>(new WrapperComparator<T>());
-
-        // Distanz zu Startknoten auf 0
-        // Weg zu Startknoten in die Schlange aufnehmen
-        distance.put(n1, 0);
-        queue.add(new WrapperElement<>(n1, 0));
-
-        // Variable, die Distanz zwischen aktuellem Knoten und Nachfolger speichert
-        int dist = 0;
-        // Variable, die Distanz zwischen dem potenziell nächsten Knoten und dem Zielknoten speichert
-        int airDist = 0;
-        // Variable, die Distanz zwischen dem aktuellen Knoten bis zum Endknoten speichert
-        int distToFinish = 0;
-        // Zähler für LogList
-        int step = 0;
-        // String für den Description Inhalt
-        String textDescription;
-
-        // Färben der Start und Ziel Knoten für Visualisierung + hinzufügen zur LogList
-        n1.getScreenVertex().setColor(Color.RED);
-        n2.getScreenVertex().setColor(Color.RED);
-        textDescription = "Startknoten: " + n1.getScreenVertex().getMarking()
-                        + ", Endknoten: " + n2.getScreenVertex().getMarking();
-        this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-        while (!queue.isEmpty()) {
-            // Den nächsten Knoten, der am wenigsten kostet, besuchen
-            WrapperElement<T> nextVertex = queue.poll();
-
-            // Knoten als besucht makieren
-            visited.put(nextVertex.getElement(), true);
-
-
-            // Logging
-            textDescription = "Visit " + nextVertex.getElement().getName();
-            System.out.println(textDescription);
-            nextVertex.getElement().getScreenVertex().setColor(Color.BLUE);
-            this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-
-            // Wenn Weg gefunden, brich ab
-            if (nextVertex.getElement() == n2) {
-                MarkedVertex<T> colorroute = n2;
-                while (colorroute != null) {
-                    textDescription = colorroute.getName();
-                    System.out.println(textDescription);
-                    colorroute.getScreenVertex().setColor(Color.green);
-                    this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-                    colorroute = predecessors.get(colorroute);
-                }
-
-
-                //zurücksetzten der Färbungen
-                this.clearScreenGraphColor();
-                return distance.get(n2);
-            }
-
-
-            // Gehe von diesem Knoten aus alle erreichbaren Knoten durch
-            for (MarkedVertex<T> i: this.getNeighbours(nextVertex.getElement())) {
-
-                // Kante finde, die den jetzigen und nächsten Knoten verbindet
-                for (MarkedEdge<U> j: this.getAllEdges()) {
-                    if (j.getSource() == nextVertex.getElement() && j.getDestination() == i) {
-
-                        //Berechnung der Heuristik über die Luftdistanz des nächsten Knoten zum Zielknoten
-                        airDist = (int) Math.sqrt(Math.pow((i.getCords()[0] - n2.getCords()[0]), 2)
-                                        + Math.pow((i.getCords()[1] - n2.getCords()[1]), 2));
-
-                        // Berechne Distanz zu nächstem Knoten
-                        EdgeWeightMarking marking = (EdgeWeightMarking) j.getMarking();
-                        dist = distance.get(nextVertex.getElement()) + marking.getWeight();
-                        distToFinish = distance.get(nextVertex.getElement()) + marking.getWeight() + airDist;
-                        break;
-                    }
-                }
-
-                // Wenn es schon einen kürzeren Weg zum Knoten gibt, überspringen
-                if ((distance.get(i) <= dist && distance.get(i) != -1) || visited.get(i)) {
-                    continue;
-                }
-
-                // Aktualisiere Distanz von Start zu nächstem Knoten
-                distance.put(i, dist);
-
-                // Logging
-                textDescription = "Add " + i.getName() + " with " + dist + " weight to queue.";
-                System.out.println(textDescription);
-                i.getScreenVertex().setColor(Color.YELLOW);
-                this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-                // Nehme nächsten Knoten in die Queue auf
-                queue.add(new WrapperElement<>(i, distToFinish));
-            }
-        }
-
-        //zurücksetzten der Färbungen
-        this.clearScreenGraphColor();
-
-        MarkedVertex<T> colorroute = n2;
-        while (colorroute != null) {
-            textDescription = colorroute.getName();
-            System.out.println(textDescription);
-            colorroute.getScreenVertex().setColor(Color.green);
-            this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
-
-            colorroute = predecessors.get(colorroute);
-        }
-
-        System.out.println("Done");
-        // Gibt Distanz zu gefragtem Knoten zurück
-        return distance.get(n2);
     }
 
 }
+

graph/Vertex.java

@@ -1,5 +1,9 @@
 package graph;
 
+/**
+ * Represents a vertex in a graph.
+ * This class serves as a base abstraction for vertices in various types of graphs.
+ */
 public abstract class Vertex {
 
     // ATTRIBUTE
@@ -9,11 +13,19 @@ public abstract class Vertex {
 
     // KONSTRUKTOREN
 
+    /**
+     * Constructs a vertex with an empty name.
+     */
     public Vertex() {
         this.name = "";
     }
 
 
+    /**
+     * Constructs a vertex with a specified name.
+     *
+     * @param s The name of the vertex.
+     */
     public Vertex(String s) {
         this.name = s;
     }
@@ -21,16 +33,32 @@ public abstract class Vertex {
 
     // GET-ER
 
+    /**
+     * Retrieves the name of the vertex.
+     *
+     * @return The name of the vertex.
+     */
     public String getName() {
         return this.name;
     }
 
 
+    /**
+     * Abstract method to retrieve the visualization representation of the vertex.
+     * Concrete subclasses will provide specific implementations.
+     *
+     * @return The visualization representation of the vertex.
+     */
     public abstract visualizationElements.Vertex getScreenVertex();
 
 
     // SET-ER
 
+    /**
+     * Sets the name of the vertex.
+     *
+     * @param s The new name for the vertex.
+     */
     public void setName(String s) {
         this.name = s;
     }

graph/VertexMarking.java

@@ -1,19 +1,61 @@
 package graph;
 
+/**
+ * Represents a marking associated with a vertex in a graph.
+ * This class serves as a base abstraction for vertex markings.
+ */
 public abstract class VertexMarking extends Marking {
+    // This class currently does not have any additional attributes or methods.
+    // It extends Marking, inheriting its properties and behaviors.
 }
 
-class VertexWeightMarking extends VertexMarking{
+
+
+
+/**
+ * Represents a weight marking associated with a vertex in a graph.
+ * Extends {@link VertexMarking}.
+ */
+class VertexWeightMarking extends VertexMarking {
+
+    // ATTRIBUTE
+
     private int weight;
 
-    VertexWeightMarking(int weight){
+
+    // KONSTRUKTOREN
+
+    /**
+     * Constructs a vertex weight marking with the specified weight.
+     *
+     * @param weight The weight value associated with the vertex.
+     */
+    VertexWeightMarking(int weight) {
         this.weight = weight;
     }
 
-    public void setWeight(int weight){
+
-        this.weight=weight;
+    // GET-ER
-    }
+
-    public int getWeight(){
+    /**
+     * Retrieves the weight associated with this vertex weight marking.
+     *
+     * @return The weight of the vertex marking.
+     */
+    public int getWeight() {
         return this.weight;
     }
+
+
+    // SET-ER
+
+    /**
+     * Sets the weight associated with this vertex weight marking.
+     *
+     * @param weight The new weight value to set.
+     */
+    public void setWeight(int weight) {
+        this.weight = weight;
+    }
+
 }