hallo, ich bin grad dabei, eine art routenplaner für die u-bahn zu programmieren.
Allerdings bekomme ich dauernd Null Pointer Exceptions, die ich mir nicht erklären kann.
Das ist mein Hauptprogramm, in dem die Verbindungen eingetragen sind.
und das meine Knotenklasse.
Also Direktverbindungen sind kein Problem, wenn es allerdings darüber hinaus gehen soll, ich also Verbindungen eingebe, die über einen 3. verbunden sind, dann spielt er nicht mehr mit und gibt Exceptions aus (Zeile 153 bei Routenberechnung.java und Zeile 29 bei Knoten.java)
Bin ich in einer Endlosschleife oder wieso macht er nicht das, was er soll
Allerdings bekomme ich dauernd Null Pointer Exceptions, die ich mir nicht erklären kann.
Code:
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Routenberechnung {
public static double liesEineZahlEin(){
double rueckgabewert = 0.0;
try{
byte [] b = new byte[ 200 ];
System.in.read( b );
rueckgabewert = (new Double( new String( b ))).doubleValue();
} catch( Exception e){
}
return rueckgabewert;
}
public static String liesEineZeichenketteEin(){
String rueckgabe ="";
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
rueckgabe = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return rueckgabe;
}
public static void main (String args[]) {
//Knoten mit Verbindungen einlesen und mit Name speichern
Knoten haltestellen[] = new Knoten[100];
haltestellen[1] = new Knoten();
haltestellen[1].nameKnoten = "Bason Court";
haltestellen[2] = new Knoten();
haltestellen[2].nameKnoten = "Eart's Court";
haltestellen[3] = new Knoten();
haltestellen[3].nameKnoten = "Gloucester Road";
haltestellen[4] = new Knoten();
haltestellen[4].nameKnoten = "South Kensington";
haltestellen[5] = new Knoten();
haltestellen[5].nameKnoten = "Victoria";
haltestellen[6] = new Knoten();
haltestellen[6].nameKnoten = "Embankment";
haltestellen[7] = new Knoten();
haltestellen[7].nameKnoten = "Green Park";
haltestellen[8] = new Knoten();
haltestellen[8].nameKnoten = "Bond Street";
haltestellen[9] = new Knoten();
haltestellen[9].nameKnoten = "Notting Hill Gate";
haltestellen[1].kinderknoten[0] = haltestellen[2];
haltestellen[2].kinderknoten[0] = haltestellen[1];
haltestellen[2].kinderknoten[1] = haltestellen[3];
haltestellen[2].kinderknoten[2] = haltestellen[9];
haltestellen[3].kinderknoten[0] = haltestellen[2];
haltestellen[3].kinderknoten[1] = haltestellen[4];
haltestellen[3].kinderknoten[2] = haltestellen[9];
haltestellen[4].kinderknoten[0] = haltestellen[3];
haltestellen[4].kinderknoten[1] = haltestellen[5];
haltestellen[4].kinderknoten[2] = haltestellen[7];
haltestellen[4].kinderknoten[3] = haltestellen[9];
haltestellen[5].kinderknoten[0] = haltestellen[4];
haltestellen[5].kinderknoten[1] = haltestellen[6];
haltestellen[5].kinderknoten[2] = haltestellen[7];
haltestellen[6].kinderknoten[0] = haltestellen[5];
haltestellen[6].kinderknoten[1] = haltestellen[7];
haltestellen[7].kinderknoten[0] = haltestellen[4];
haltestellen[7].kinderknoten[1] = haltestellen[5];
haltestellen[7].kinderknoten[2] = haltestellen[6];
haltestellen[7].kinderknoten[3] = haltestellen[8];
haltestellen[8].kinderknoten[0] = haltestellen[7];
haltestellen[8].kinderknoten[1] = haltestellen[9];
haltestellen[9].kinderknoten[0] = haltestellen[2];
haltestellen[9].kinderknoten[1] = haltestellen[3];
haltestellen[9].kinderknoten[2] = haltestellen[8];
// Namen der Haltestationen säubern
int anzahlHaltestationen = 1;
while( haltestellen[ anzahlHaltestationen ] != null ){
haltestellen[ anzahlHaltestationen ].nameKnoten = haltestellen[ anzahlHaltestationen ].nameKnoten.trim().toLowerCase();
anzahlHaltestationen++;
}
//Was soll getan werden? Route oder Verbindungen anzeigen lassen
System.out.println("Was möchten sie tun? Drücken sie die Entsprechende Taste und bestätigen sie!");
System.out.println("1. Direktverbindungen anzeigen lassen");
System.out.println("2. Die Route zwischen 2 Punkten berechnen lassen");
int mode =(int) liesEineZahlEin();
//Verbindungen anzeigen lassen
if(mode == 1){
for(int zaehler = 1 ; zaehler <10 ; zaehler++){
System.out.println(zaehler + " "+haltestellen[zaehler].nameKnoten);
}
System.out.println("Von welcher Station wollen sie die Verbindungen wissen?");
int n =(int) liesEineZahlEin();
System.out.println("Die angeschlossenen Stationen sind");
haltestellen[n].gibDeineKindKnotenAus();
} else {
//Beginn der Routenberechnung
//Start der Route
System.out.println("Wie lautet ihre Starthaltestelle?");
String startname = liesEineZeichenketteEin();
startname = startname.trim().toLowerCase();
int zaehler = 1;
if ( haltestellen[ zaehler ].nameKnoten != null ) zaehler =1;
while( ! startname.equals( haltestellen[ zaehler ].nameKnoten )){
zaehler++;
}
int start;
start = zaehler;
System.out.println("Nummer der Starthaltestelle:" + start );
//Ziel der Route
System.out.println("Wie lautet ihre Zielhaltestelle?");
String zielname = liesEineZeichenketteEin();
zielname = zielname.trim().toLowerCase();
zaehler = 1;
while( !zielname.equals( haltestellen[ zaehler ].nameKnoten )){
zaehler++;
}
int ziel = zaehler;
System.out.println("Nummer der Zielhaltestelle:" + ziel );
// Aufruf der Planung
if ( !haltestellen[ziel].gibRouteAus( haltestellen[ start ]))
System.out.println( "Tut mir leid, keine Route gefunden!");
}
}
}Das ist mein Hauptprogramm, in dem die Verbindungen eingetragen sind.
Code:
public class Knoten {
String nameKnoten;
int nummerKnoten;
Knoten kinderknoten[] = new Knoten[9];
boolean schonBesucht = false;
public void gibDeineKindKnotenAus() {
int zaehler = 0;
while (kinderknoten[zaehler] != null) {
System.out.println(kinderknoten[zaehler].nameKnoten);
zaehler++;
}
}
public boolean gibRouteAus(Knoten start) {
boolean routeGefunden = false;
int aktuellerKindknoten = 0;
System.out.println("ich besuche: " + nameKnoten);
if (kinderknoten[0] != null) {
// Direkte Verbindungen
while (aktuellerKindknoten <= kinderknoten.length) {
if (this.kinderknoten[aktuellerKindknoten].nameKnoten.equals(start.nameKnoten)) {
System.out.println("Direktverbindung");
return true;
}
aktuellerKindknoten++;
}
aktuellerKindknoten = 0;
int Kindknoten2 = 0;
while (aktuellerKindknoten <= kinderknoten.length) {
while (Kindknoten2 <= kinderknoten[aktuellerKindknoten].kinderknoten.length) {
if (this.kinderknoten[aktuellerKindknoten].kinderknoten[Kindknoten2].nameKnoten
.equals(start.nameKnoten)) {
System.out
.println("Umweg ueber "
+ kinderknoten[aktuellerKindknoten].nameKnoten
+ "und "
+ kinderknoten[aktuellerKindknoten].kinderknoten[Kindknoten2].nameKnoten);
return true;
}
Kindknoten2++;
}
aktuellerKindknoten++;
}
}
return true;
}
}und das meine Knotenklasse.
Also Direktverbindungen sind kein Problem, wenn es allerdings darüber hinaus gehen soll, ich also Verbindungen eingebe, die über einen 3. verbunden sind, dann spielt er nicht mehr mit und gibt Exceptions aus (Zeile 153 bei Routenberechnung.java und Zeile 29 bei Knoten.java)
Bin ich in einer Endlosschleife oder wieso macht er nicht das, was er soll
