# Einfachvererbung und Arraylist



## Ganzir (15. Apr 2009)

Hallo, 

meine Aufgabe sieht so aus, dass es eine Fähre gibt die mit Fahrzeugen beladen werden soll, Fahrzeuge lassen sich unterteilen in PKW, LKW, Motorräder und Fahrräder.

Ein PKW kann mehr Beifahrer haben als ein LKW usw...

Daher ist meine Superklasse Fahrzeug mit den gemeinsamen attributen wie, z.B. Gewicht, breite und Länge.

eine Unterklasse von Fahrzeug kann nun PKW sein ... soweit so gut nur sagt er mir der Konstruktor wäre undefniert und damit kann ich nichts anfangen ... hier mein Code der Überklasse:


```
package org.faehre;

public abstract class Fahrzeug {

	//attribute
	private static int gewicht = 0, laenge = 0, breite = 0; 

	protected Fahrzeug
    (int gewicht, int breite, int laenge)
{
  this.gewicht = gewicht;		
  this.laenge = laenge;
  this.breite = breite;

}
	
	//lesende Methode
	
	public int getGewicht()
	{
		return gewicht;
	}
	
	public int getLaenge()
	{
		return laenge;
	}
	
	public int getBreite()
	{
		return breite;
	}
	
	// schreibende Methode
	
	public void setGewicht(int gewicht)
	{
		this.gewicht = gewicht;
	}

	public void setLaenge(int laenge)
	{
		this.laenge = laenge;
	}
	
	public void setBreite (int breite)
	{
		this.breite = breite;
	}
```

Und hier der Unterklasse:


```
package org.faehre;

public class PKW extends Fahrzeug{
	
	 //Attribute
	 private String fahrzeugtyp = "PKW";
	 
	 //Konstruktor
	 public PKW
	   (int gewicht, int laenge, int breite, String fahrzeugtyp) <---- Diese Zeile mag ecplipse nicht
	 {
	     super(gewicht, laenge, breite);
	 }
	 public String getFahrzeugtyp()
	 {
	  return fahrzeugtyp;
	 }
}
```

Greetz
Ganzir


----------



## SlaterB (15. Apr 2009)

bei mir gibts keine Compiler-Warning, sicher mit dem Code?
welche genaue Fehlermeldung?

du vertauschst übrigens laenge und breite, das kann böse enden

edit: statische Attribute sind schlecht, sind alle gleich für mehrere Objekte 

edit: 
falls veraltete .class-Dateien oder mehrere gleichnamige Klassen existieren:
neue Dateien aufmachen, Klassen neu benennen (A und B), Konstruktoren ebenso, restlichen Code gleich lassen


----------



## Ganzir (15. Apr 2009)

Danke für den Hinweis mit Static.... hab ich jetzt weggemacht ... bei mir zeigt der Compiler nun auch keinen Fehler mehr an, nachdem ich eclipse einmal neu gestartet habe... ich nehme das einfach mal so hin....

Nun habe ich haber ein anders Problem.... ich kann die get-Methode die ich in der Klasse PKW definiert habe nicht in meiner UI Klasse aufrufen.... warum ist das so?

Hier meine UI-Klasse ist noch ein wenig caotisch....


```
package org.faehre;

import inout.Console;

public class FaehreUI {

	private static int gesamtplatz = 1000;	
	private static int restplatz = 0;
	private static int verbrauchterplatz = 0;
	private static int flaeche = 0;
	private static int x, y, z;

	
	
	
	private static MeineFahrzeuge eineListe;
	
	public static void platzpruefen (MeineFahrzeuge eineListe)
	{
		for (int i = 0; i < eineListe.getAnzahlFahrzeuge(); i++)
			flaeche = (eineListe.getFahrzeug(i).getBreite()* eineListe.getFahrzeug(i).getLaenge());
			verbrauchterplatz = verbrauchterplatz + flaeche;
			restplatz = gesamtplatz - verbrauchterplatz;
		if (verbrauchterplatz > gesamtplatz)
		
			System.out.println("Die fähre ist voll");
		else
			System.out.println("Es sind noch " + restplatz + " Platzeinheiten auf der Fähre Frei, es wurden bereits " + verbrauchterplatz + " Platzeinheiten verbraucht");
	}
	
	public static void ausgebenListe(MeineFahrzeuge eineListe)
	{
		for (int i = 0; i < eineListe.getAnzahlFahrzeuge(); i++)
			System.out.println(eineListe.getFahrzeug(i).getBreite() + " " + eineListe.getFahrzeug(i).getLaenge() 
					+ " Fahrzeug befindet sich auf Position " + i +" der Fähre. Es handelt sich dabei um einen "); <---- hier möchte ich nun die get-Methode einhängen... aber aus der UI-Kasse lässt die sich nicht auswählen.
		    System.out.println();
	}

	
	public static void main(String arg[])
	{	
		Fahrzeug einFahrzeug;
		eineListe = new MeineFahrzeuge();
		char auswahl; 

		do
	     {
	      System.out.println("PKW hinzufügen: 1 Fahrzeug entfernen: 2 Fahrzeuge anzeigen: 3  Platz prüfen 4 Ende: 9");
	      auswahl = Console.readChar();
	      switch (auswahl) 
	      {  
	        case '1': 
	        
	        	
	        	
	        einFahrzeug = new PKW(x, y, z, "PKW");
	        
			System.out.println("Bitte geben Sie das Gewicht des PKWs");
			einFahrzeug.setGewicht(Console.readInt());
			
			System.out.println("Bitte geben Sie die Länge des PKWs ein");
			einFahrzeug.setLaenge(Console.readInt());
			
			System.out.println("Bitte geben Sie die Breite des PKWs ein");
			einFahrzeug.setBreite(Console.readInt());
			

			
			eineListe.hinzufuegen(einFahrzeug);
	        break; 
	        
	        case '2': 
	        System.out.print("Um ein Fahrzeug vom der Fähre zu entfernen geben Sie bitte die Position selbigens ein."); 
	        eineListe.entfernen();
	        break;
	                
	        case '3': 
	        
	    	FaehreUI.ausgebenListe(eineListe);	
	        break;
	        
	        case '4':

	        FaehreUI.platzpruefen(eineListe);	
	        break;
	        
	         default: System.out.println
	                       ("Programm wurde beendet");   
	       } 
	      } while ( auswahl >= '1' && auswahl <='5');

		
	}
	
}
```

Greetz
Ganzir


----------



## Matt (15. Apr 2009)

Ganzir hat gesagt.:


> Java Code:
> 
> 
> ```
> ...



himm also abgesehen davon das es klappen sollte ^^ versteh ich das mit dem "String fahrzeugtyp" nicht bei Parametern....

Der Fahrzeugtyp steht doch schon fest allein durch die Klasse oder etwa nicht? (bzw. das Attribut sagt es schon)....


Achja... dein Get Problem:


```
System.out.println(eineListe.getFahrzeug(i).getBreite() + " " + eineListe.getFahrzeug(i).getLaenge() 
					+ " Fahrzeug befindet sich auf Position " + i +" der Fähre. Es handelt sich dabei um einen ");
```

Es sollte eig. ganz einfach sein:

```
System.out.println(eineListe.getFahrzeug(i).getBreite() + " " + eineListe.getFahrzeug(i).getLaenge() 
					+ " Fahrzeug befindet sich auf Position " + i +" der Fähre. Es handelt sich dabei um einen "
+eineListe.getFahrzeug(i).getFahrzeugtyp);
```

Mich würde es interessieren mal deine Klasse MeineFahrzeuge zu sehen, wegen "eineListe".....

Hab dein Beispiel ma selber genommen und da geht:

```
PKW golf = new PKW(1,2,3,"");
		List<PKW> bla = new ArrayList<PKW>();
		bla.get(1).getFahrzeugtyp();
```

Oo kriege auch alle Methoden die sich in der Klasse "Fahrzeug" befinden....


----------



## Ganzir (15. Apr 2009)

Ja genau... du hast das mit dem get-Problem richtig erkannt .... ich soll ja später noch LKWs und Fahrräder etc. geben.... diese Klassen habe ich aber noch nicht geschrieben, da ich erstmal die eine ans laufen bekommen möchte. So und dann möchte ich am Ende meine Array List auslesen und alle Daten zu den darin gespreicherten objekten sehen können, daher der Fahrzeugtyp....



> System.out.println(eineListe.getFahrzeug(i).getBreite() + " " + eineListe.getFahrzeug(i).getLaenge()
> + " Fahrzeug befindet sich auf Position " + i +" der Fähre. Es handelt sich dabei um einen "
> +eineListe.getFahrzeug(i).getFahrzeugtyp);



genau das klappt nicht.... der Code-Assist von eclipse schlägt es nicht vor und wenn man es manuell einträgt zeigt der einen fehler an und zwar 



> The Method getFahrzeugtyp() is undefined for the Typ Fahrzeug



so hier nun wie gewünscht die Klasse meine Fahrzeuge


```
package org.faehre;

import inout.Console;

import java.util.ArrayList;


public class MeineFahrzeuge {
private ArrayList Liste = new ArrayList();
	
	void hinzufuegen(Fahrzeug einFahrzeug)
	{
		Liste.add(einFahrzeug);
	}
	
	int getAnzahlFahrzeuge()
	{
		return Liste.size();
	}
	
	Fahrzeug getFahrzeug(int index)
	{
		return (Fahrzeug)Liste.get(index);
	}
	
	boolean entfernen()
	{
		Liste.remove(Console.readInt());
		return true;
	}
	
}
```

Wie gesagt und wie du an meinem Code sowie meinen Fragen siehst bin ich absoluter noob was programmieren angeht... aber soweit ich einfach-vererbung verstanen habe... gibt es die klasse Fahrzeug die duch die Klasse PKW bzw. alle Klassen die mit extends Fahrzeug dadrunter gehangen werden erweitert wird. Demzufolge müsste ich in der UI doch auch alle getter und setter benutzen können die zu der oberklasse hinzugefügt werden oder nicht?

Greetz
Ganzir


----------



## Matt (15. Apr 2009)

Ah ich musste viel rumprobieren aber ich habs geschafft ^^ 

Ich hab jezz mal nicht deine Klasse "MeineFahrzeuge" übernommen sondern direkt in der Main eine Liste erstellt ^^. und ob es wirklich so super sauber ist wer weiss xD

Also hier mal die Main:

```
import java.io.*;
import java.util.*;

public class Cmain {
    
    public static String getCmdIn() throws IOException{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        return reader.readLine();
    }
    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        
        //Fahrzeug Object
        Fahrzeuge car;
        
        //Liste
        List<Fahrzeuge> Autos = new ArrayList<Fahrzeuge>();
        
        //Variable für Standard Fahrzeug werte
        int breite = 0;
        int laenge = 0;
        int gewicht = 0;
        
        String command=" "; //Variable für eingabe
        
        //Wähle Fahrzeug - Fahrzeug wird erstellt und auch gleich in Liste eingefügt
        while(!command.equals("exit")){
            command = getCmdIn();
            if(command.equals("PKW")){
                car = new PKW(gewicht, laenge, breite);
                Autos.add(car);
            }
            else if(command.equals("LKW")){
                car = new LKW(gewicht, laenge, breite);
                Autos.add(car);
            }
            else if(command.equals("Fahrrad")){
                car = new Fahrrad(gewicht, laenge, breite);
                Autos.add(car);
            }
            else if(command.equals("Motorrad")){
                car = new Motorrad(gewicht, laenge, breite);
                Autos.add(car);
            }
            System.out.println(Autos.get(0).getFahrzeugtyp()); //Ausgabe des FahrzeugTyps    
        }
    }
}
```

Hier mal die Abtracte Klasse Fahrzeuge:

```
abstract public class Fahrzeuge {

	int gewicht = 0;
	int laenge = 0;
	int breite = 0; 
	
	Fahrzeuge(int g, int l, int b){
		gewicht = g;
		laenge = l;
		breite = b;
	}
	//lesende Methode
	public abstract String getFahrzeugtyp();	
	public abstract int getGewicht();	
	public abstract int getLaenge();
	public abstract int getBreite();
	
	// schreibende Methode
	public abstract void setGewicht(int gewicht);
	public abstract void setLaenge(int laenge);
	public abstract void setBreite (int breite);
}
```

PKW:

```
public class PKW extends Fahrzeuge{
	
	 //Attribute
	 private String fahrzeugtyp = "PKW";
	 
	 //Konstruktor
	 public PKW(int g, int l, int b) 
	 {
		 super(g, l, b);
	 }	 
	 public String getFahrzeugtyp()
	 {
	  return fahrzeugtyp;
	 }
	@Override
	public int getBreite() {
		// TODO Auto-generated method stub
		return this.breite;
	}
	@Override
	public int getGewicht() {
		// TODO Auto-generated method stub
		return this.gewicht;
	}
	@Override
	public int getLaenge() {
		// TODO Auto-generated method stub
		return this.laenge;
	}
	@Override
	public void setBreite(int breite) {
		// TODO Auto-generated method stub
		this.breite = breite;
	}
	@Override
	public void setGewicht(int gewicht) {
		// TODO Auto-generated method stub
		this.gewicht = gewicht;
	}
	@Override
	public void setLaenge(int laenge) {
		// TODO Auto-generated method stub
		this.laenge = laenge;
	}
}
```

LKW, Motorrad und Fahrrad sind quasi Identisch zu einander >-< nur ein Problem existiert...und dafür bin ich entweder einfach noch zu doof für oder ich hab nen Brett vorm Kopf -.-... und zwar die tatsache wenn ich neue Methoden in den Unterklassen erzeuge die keineswegs identisch zueinander stehen kann ich die nicht benutzen ohne das ein head in der abstrakten Klasse Fahrzeuge steht, sowie eine Abzug davon (auch wenn er leer ist) in jeder SubKlasse (PKW;LKW; Fahrrad; Motorrad)....

Ich bin mir absolut sicher das es noch eine elegantere Variante gibt...aber ich komm einfach nicht darauf...>_<


----------



## Ebenius (16. Apr 2009)

Hab ich einen Witz nicht verstanden?

Ebenius


----------



## Ganzir (16. Apr 2009)

> Hab ich einen Witz nicht verstanden?



Hallo Ebenius, ich habe keine Ahnung was so witzig sein soll. 

Sofern dir das "Problem" als lächerlich trivial erscheint, wäre mir mit einer alternativ Lösung bzw. einer Erklärung sehr geholfen.

Greetz
Ganzir


----------



## Ebenius (16. Apr 2009)

Liegt an der Uhrzeit, sorry. Mein Kommentar bezog sich eigentlich auf Matt. Entweder habe ich irgendeine Besonderheit nicht verstanden, oder sein Entwurf ist sehr zweifelhaft. Aus welchem Grund sollte ich die Felder _gewicht_, _laenge_ und _breite_ in der abstrakten Klasse deklarieren, die getter- und setter-Methoden aber nur abstrakt aufnehmen?

Ebenius


----------



## Ganzir (16. Apr 2009)

Hi Ebenius, ... nichts für ungut.

Ich glaube das grundliegende Problem ist, dass es sich hierbei um eine Aufgabe handelt die an den Haaren herbeigezogen ist.

Handelte es sich um eine reales Problem würde ich sagen, die Autos fahren über eine Waage, dann gibt es ein Gewicht, werden vermessen und dann gibt es einen Platzbedarf ... die so generierten Objekte werden in die Arraylist gestopft und es wird überprüft ob der Gesamtplatz der Fähre oder die maximal zulässige Zuladung überschritten wird und dann kommt die Nachrricht, das Schiff ist voll.... Problem gelöst.

Dummerweise soll ich diese Aufgabe mit Einfachvererbung Lösen, dazu hat sich der Aufgabensteller (mit Sicherheit einer der brilliantesten Köpfe überhaupt) folgendes ausgedacht.

Es gibt PKWs, LKWs, Motorräder und Fahrräder.

PKWs können bis zu 3 Beifahrer haben, Motorräder 1, LKWs 2 und Fahrräder keinen.

Das Ganze soll dann so ablaufen.

Was für ein Fahrzeug fährt auf die Fähre?

1.PKW 2. LKW 3. Motorrad 4. Fahrrad

Anhand dieser Vorauswahl kommt dann ein Untermenü, dass nach der Anzahl der Beifahrer fragt.
Dabei sollen nur die Eingabemöglichkeiten entsprechend oben genannter Kriterien bestehen.

Nehmen wir mal an ich habe einen PKW mit 3 Beifahrern,

Dann soll ich das Gewicht des PKWs (ohne Fahrer und Beifahrer) eingeben,

Dann das Gewicht für jeden einzelnen Beifahren und den Fahrer (es sollen unterschiedliche Gewichte pro Person möglich sein)

Dann die Länge und die Breite des Fahrzeugs, diese multipliziert mit 1,5 ergibt den Platzbedarf des Fahrzeugs auf der Fähre (es muss ja noch Platz zum aussteigen sein)

Dann lasse ich Fahrzeuge gemäß den obigen Angaben auf die Fähre fahren und schaue ob zuerst Gewicht oder Platz überschritten wird und dann soll das Prog sagen die Fähre ist voll.

Daher soll Einfachvererbung angwendet werden.

Es gibt gemeinsame Attribute jedes Fahrzeugs

Gewicht
Länge
Breite
Gewicht des Fahrers

und es gibt unterschiedliche Attribute

Anzahl der Beifahrer

An dieser Aufgabe soll das Konzept "Generalisieren, Spezialsieren und Redefinieren" veranschaulicht werden.

Das einzige was ich als Vorlage hatte waren ca. 20. Zeilen Code die mir zeigen wie ich eine Super und eine Subklasse selbiger erstelle.

In einer UI eine Subklasse anzusprechen und dann ein Objekt, welches durch diese subklasse und oberklasse generiert wurde in eine Arraylist einzüfgen... habe ich noch nie gemacht.

Wie du an dem was ich hier fabriziert habe erkennen kannst sind meine Kenntnisse rudimentär (meine Einschätzung)

Sofern du dich jetzt noch nicht totgelacht hast über diesen Blödsinn und es eine simple Lösung gibt, die aber den oben erläuterten Kriteren entspricht, bzw. mir sagen kannst was ich ändern muss wäre das echt ne super Geschichte.

Greetz
Ganizr


----------



## Ebenius (16. Apr 2009)

Naja das ist ja alles gut und schön. Mir ging es eigentlich nur darum, dass Matts Beispiel so umgebaut wesentlich weniger Aufwand macht: 
	
	
	
	





```
public abstract class Fahrzeug {

  private int gewicht = 0;
  private int laenge = 0;
  private int breite = 0;

  public abstract String getFahrzeugTyp();

  // -------------------------------------------------------------------------
  // Getters and setters
  // -------------------------------------------------------------------------

  public int getGewicht() {
    return gewicht;
  }

  public void setGewicht(int gewicht) {
    this.gewicht = gewicht;
  }

  public int getLaenge() {
    return laenge;
  }

  public void setLaenge(int laenge) {
    this.laenge = laenge;
  }

  public int getBreite() {
    return breite;
  }

  public void setBreite(int breite) {
    this.breite = breite;
  }
}
```


```
public class PKW extends Fahrzeug {

  @Override
  public String getFahrzeugTyp() {
    return "PKW";
  }
}
```
Ebenius


----------



## Matt (16. Apr 2009)

Trotzdem bleibt ein anderes Problem Ebenius....

Und zwar die Tatsache mit unterschiedlichen Methoden in den Subklassen.....es ist zwar nicht gefragt aber dennoch interessant ^^

denn wenn ich eine Liste von unterschiedlichen Objekten zur Laufzeit schon baue und die Methoden der einzelnen Objekte benutzen will...so weigert er sich unterschiedliche Methoden zu benutzen, da zur Entwicklungszeit noch gar nicht feststeht ob an einer Besteimmten Stelle in der Liste, jene Methode von einem der Objekte zur verfügung steht......

Wie gesagt ist zwar net unbedingt verlangt in seiner Aufgabe ^^ funktionieren tut es auch so....nur für mich ist es interessant mal sowas zu wissen


----------



## Ebenius (16. Apr 2009)

Matt, ich verstehe das Problem nicht.

Ebenius


----------



## Matt (16. Apr 2009)

Ebenius hat gesagt.:


> Matt, ich verstehe das Problem nicht.
> 
> Ebenius




................hmmm








Na ob das Bild das verdeutlich?

Edit: da fehlt im beispiel nen "new" vor fahrrad -.- nix bei denken wollte halt keine ewigkeit malen...


----------



## Ebenius (16. Apr 2009)

Ja, ich weiß was Methoden sind. Ich weiß, dass man sie in unterschiedlichen Ableitungen unterschiedlich deklarieren kann. Ich weiß auch, dass man einen cast-Operator benötigen würde, wenn man die konkrete Instanz nur per allgemeinerem Typ kennt...

Aber ich sehe kein Problem! Wo benötige ich denn im Kontext der Fährenanwendung um die es hier geht spezielle Methoden in PKW, Fahrrad, Dreirad, UFO? Alle von der Fähre benötigten Methoden sind in der Klasse Fahrzeug deklariert.

Ebenius


----------



## Matt (16. Apr 2009)

Matt-Softwareschmiede hat gesagt.:


> Wie gesagt ist zwar net unbedingt verlangt in seiner Aufgabe ^^ funktionieren tut es auch so....nur für mich ist es interessant mal sowas zu wissen


hmm.....



Ebenius hat gesagt.:


> Aber ich sehe kein Problem! Wo benötige ich denn im Kontext der Fährenanwendung um die es hier geht spezielle Methoden in PKW, Fahrrad, Dreirad, UFO? Alle von der Fähre benötigten Methoden sind in der Klasse Fahrzeug deklariert.



......siehe oben......


----------



## Ebenius (16. Apr 2009)

Und die Antwort lautet: Das kann man nicht lösen. Instanz aus dem Kontainer herausholen, je nach Typ per cast-Operator konkreter machen, dann die konkreten Methoden aufrufen. Wie gesagt: Hat ja mit dem Problem nichts zu tun.

Ebenius


----------



## Murx (18. Apr 2009)

Anscheinend haben wir unserer Grundlagen Vorlesung exakt die selbe Aufgabe und ich habe hier auch eine Schwierigkeit.

Hier einmal die Aufgabenstellung 





> Auf einer Fähre werden Fahrzeuge zunächst gewogen bevor Sie die Fähre befahren dürfen. Sobald das zulässige Belastungsgewicht der Fähre überschritten ist, darf kein weiteres Fahrzeug mehr aufgenommen werden. Des Weiteren darf kein Fahrzeug mehr auffahren, wenn die Parkfläche der Fähre bereits ausgeschöpft ist.
> 
> Das Gewicht eines Fahrzeugs wird durch das Standardgewicht des Fahrzeugs und der Beladung (Gepäck, Personen) berechnet.
> Die benötigte Standfläche wird berechnet, indem die Standardfläche des Fahrzeugs mit dem Faktor 1,5 multipliziert wird.
> ...



zu erst habe ich eine Oberklasse geschrieben, welche die Gemeinsamkeiten der vier verschiedenen Fahrzeugtypen bündelt



> public abstract class Fahrzeug
> {
> //Attribute, welche die verschiedenene Fahrzeugtypen gemeinsam haben (Generalisierung)
> private float breite ;
> ...




Dann eine Beispielklasse LKW



> public class Lkw extends Fahrzeug
> {
> //Attribute, die speziell auf den Fahrzeugtyp Lkw zugeschnitten sind
> private String fahrzeugTyp = "Lkw";
> ...




und zu guter Letzt die UI um ein LKW Objekt zu erstellen.



> public class FahrzeugUI
> {
> public static void main (String args[])
> {
> ...




1. Die Klasse UI lässt sich nicht compilieren, BlueJ meckert über die Objekterzeugung.
2. Scheint es mir schwachsinnig bei dem Aufruf "Lkw einlkw" String Fahrzeugtyp nochmals zu deklarieren, da dies ja bereits aus dem Konstruktor hervorgeht, doch mir ist keine andere Möglichkeit eingefallen.

Vielen Dank für eure Mithilfe.

Hoffe wenigstens das Grundlegende Problem bei der Programmieraufgabe habe ich richtig angepackt


----------



## Murx (18. Apr 2009)

niemand eine Ahnung?


----------



## Ganzir (20. Apr 2009)

Hallo,

ich habe eine wenig weiter getüfftelt .... nun stehe ich vor dem nächsten Problem:


```
case '1': 
	        	
	        PKW einFahrzeug = new PKW(x, s, y, z, "PKW", new Person(w), new Person(v), new Person(u), new Person(t));

   case '2': 
	        	
		        LKW einFahrzeug = new LKW(x, s, y, z, "LKW", new Person(w), new Person(v), new Person(u));
```

jetzt meckert er rum, dass einFahrzeug eine doppelte belegter Variablenname ist? Kann mir jemand sagen wie ich das umgehen kann?

Greetz
Ganzir


----------



## madboy (20. Apr 2009)

@Murks: bitte Fehlermeldung posten. "BlueJ meckert" sagt mir nichts ;-)

@Ganzir: du solltest nach jedem case auch ein break einbauen. Sonst werden alle folgenden "case" auch ausgeführt. Bsp:

```
char bla = '1';
switch ( bla ) {
   case '1': System.out.println("case 1");
   case '2': System.out.println("case 2");
}
```
korrekt (bzw. so, wie du vermutlich gern hättest):

```
char bla = '1';
switch ( bla ) {
   case '1': System.out.println("case 1");
   break;
   case '2': System.out.println("case 2");
   break;
}
```

Obiges weiß auch der javac, daher "meckert" er.


----------

