# Illegal Start of Type, wie finde ich den fehler



## Linux (2. Aug 2010)

Hallo, 
ich habe grad ein Problem mit meinem Programm, der zeigt mir einen "illegal start of type" an. Ich habe davor ein paar kleine änderungen am programm vorgenommen und vor den änderungen hat es mir das alles korrekt compiliert.
ich weiß nicht, wie ich das jetzt korrigieren soll, damits funktioniert.
Der Fehler wird  in der Methode"freieNachbarposition()" angezeigt.
also in der Zeile mit if: if(feld[position.gibZeile()][position.gibSpalte()] == null) {
                              return position;
                              }  Hat jemand eine Idee?
ich entschuldige mich für den langen Quellcode, aber man weiß ja nie wo der fehler steckt...http://1.1.1.4/bmi/www.java-forum.org/images/smilies/eek.gif

[Java]
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Random;
import java.util.List;

/**
 * Ein rechteckiges Gitter von Feldpositionen.
 * Jede Position kann ein einzelnes Tier aufnehmen.
 */
public class Feld
{
    private static final Random rand = new Random();

    // Die Tiefe und die Breite des Feldes
    private int tiefe, breite;
    // Speicher für die Tiere
    private Object[][] feld;

    /**
     * Erzeuge ein Feld mit den angegebenen Dimensionen.
     * @param tiefe die Tiefe des Feldes.
     * @param breite die Breite des Feldes.
     */
    public Feld(int tiefe, int breite)
    {
        this.tiefe = tiefe;
        this.breite = breite;
        feld = new Object[tiefe][breite];
    }

    /**
     * Räume das Feld.
     */
    public void raeumen()
    {
        for(int zeile = 0; zeile < tiefe; zeile++) {
            for(int spalte = 0; spalte < breite; spalte++) {
                feld[zeile][spalte] = null;
            }
        }
    }

    /**
     * Platziere das gegebene Tier an der angegebenen Position.
     * Wenn an der Position bereits ein Tier eingetragen ist,
     * geht es verloren.
     * @param tier das Tier das platziert werden soll.
     * @param zeile die Zeilenkoordinate der Position.
     * @param spalte die Spaltenkoordinate der Position.
     */
    public void platziere(Object tier, int zeile, int spalte)
    {
        platziere(tier, new Position(zeile, spalte));
    }

    /**
     * Platziere das gegebene Tier an der angegebenen Position.
     * Wenn an der Position bereits ein Tier eingetragen ist,
     * geht es verloren.
     * @param tier das Tier, das platziert werden soll.
     * @param position die Position, an der das Tier platziert werden soll.
     */
    public void platziere(Object tier, Position position)
    {
        feld[position.gibZeile()][position.gibSpalte()] = tier;
    }

    /**
     * Liefere das Tier an der angegebenen Position, falls vorhanden.
     * @param position die gewünschte Position.
     * @return das Tier an der angegebenen Position oder null, wenn
     *         dort kein Tier eingetragen ist.
     */
    public Object gibObjektAn(Position position)
    {
        return gibObjektAn(position.gibZeile(), position.gibSpalte());
    }

    /**
     * Liefere das Tier an der angegebenen Position, falls vorhanden.
     * @param zeile die gewünschte Zeile.
     * @param spalte die gewünschte Spalte.
     * @return das Tier an der angegebenen Position oder null, wenn
     *         dort kein Tier eingetragen ist.
     */
    public Object gibObjektAn(int zeile, int spalte)
    {
        return feld[zeile][spalte];
    }

    /**
     * Wähle zufällig eine der Positionen, die an die gegebene Position
     * angrenzen, oder die gegebene Position selbst.
     * Die gelieferte Position liegt innerhalb der gültigen Grenzen
     * dieses Feldes.
     * @param position die Position, von der ein Nachbar zu wählen ist.
     * @return eine gültige Position innerhalb dieses Feldes. Das kann
     *         auch die gegebene Position selbst sein.
     */
    public Position zufaelligeNachbarposition(Position position)
    {
        int zeile = position.gibZeile();
        int spalte = position.gibSpalte();
        // Zufällig eine Abweichung von -1, 0 oder +1 für Zeile und Spalte wählen.
        int naechsteZeile = zeile + rand.nextInt(3) - 1;
        int naechsteSpalte = spalte + rand.nextInt(3) - 1;
        // Prüfen, ob die neue Position außerhalb der Feldgrenzen liegt.
        if(naechsteZeile < 0 || naechsteZeile >= tiefe
           || naechsteSpalte < 0 || naechsteSpalte >= breite) {
            return position;
        }
        else if(naechsteZeile != zeile || naechsteSpalte != spalte) {
            return new Position(naechsteZeile, naechsteSpalte);
        }
        else {
            return position;
        }
    }

    /**
     * Versuche, eine freie Nachbarposition zur gegebenen Position zu
     * finden. Wenn es keine gibt, liefere die gegebene Position, wenn
     * sie selbst frei ist. Ansonsten liefere null.
     * Die gelieferte Position liegt innerhalb der Feldgrenzen.
     * @param position die Position, für die eine Nachbarposition
     *                 zu liefern ist.
     * @return eine gültige Position innerhalb der Feldgrenzen. Das
     *         kann die gegebene Position selbst sein oder null, wenn
     *         alle Nachbarpositionen und die Position selbst belegt sind.
     */
    public Position freieNachbarposition(Position position)
    {
        //Iterator nachbarn = nachbarpositionen(position);
        Iterator nachbarn = nachbarpositionen(position).iterator();
        while(nachbarn.hasNext()) {
            Position naechste = (Position) nachbarn.next();
            if(feld[naechste.gibZeile()][naechste.gibSpalte()] == null)
            //das heißt wenn da kein Tier eingetragen ist{
                return naechste;
            }
        }
        // Prüfen, ob die gegebene Position selbst frei ist.
        //prüfen, da im vorgehenden schritt die nächste position nicht frei war.
        if(feld[position.gibZeile()][position.gibSpalte()] == null) {
            return position;
        } 
        else {
            return null;
            //weder die gegebene Position noch die Nachbarpsoitionen sind frei
        }
    }

    /**
     * Erzeuge einen Iterator über eine gemischte Liste von Nachbarpositionen
     * zu der gegebenen Position. Diese Liste enthält nicht die gegebene 
     * Position selbst. Alle Positionen liegen innerhalb des Feldes.
     * @param position die Position, für die Nachbarpositionen zu liefern sind.
     * @return ein Iterator über Nachbarpositionen zur gegebenen Position.
     */
    //public Iterator nachbarpositionen(Position position)
    public List nachbarpositionen(Position position)
    {
        int zeile = position.gibZeile();
        int spalte = position.gibSpalte();
        LinkedList positionen = new LinkedList();
        for(int zDiff = -1; zDiff <= 1; zDiff++) {
            int naechsteZeile = zeile + zDiff;
            if(naechsteZeile >= 0 && naechsteZeile < tiefe) {
                for(int sDiff = -1; sDiff <= 1; sDiff++) {
                    int naechsteSpalte = spalte + sDiff;
                    // Exclude invalid locations and the original location.
                    if(naechsteSpalte >= 0 && naechsteSpalte < breite && (zDiff != 0 || sDiff != 0)) {
                        positionen.add(new Position(naechsteZeile, naechsteSpalte));
                    }
                }
            }
        }
        Collections.shuffle(positionen,rand);
        //return positionen.iterator();
        return positionen;
    }

    /**
     * @return die Tiefe dieses Feldes.
     */
    public int gibTiefe()
    {
        return tiefe;
    }

    /**
     * @return die Breite dieses Feldes.
     */
    public int gibBreite()
    {
        return breite;
    }
}
[/Java]


----------



## andiv (2. Aug 2010)

Die Klammer am Ende von Zeile 139 sieht verdächtig aus...


----------



## madboy (2. Aug 2010)

```
if(feld[naechste.gibZeile()][naechste.gibSpalte()] == null)
            //das heißt wenn da kein Tier eingetragen ist{
                return naechste;
            }
```
Du musst die geschweifte Klammer auch öffnen, die du schließt ;-)


----------



## Linux (3. Aug 2010)

AHHHH; ok danke, ich war wohl etwas zu müde...
aber ich habe noch eine kleine Frage zu den abstrakten methoden, hier ein Quellcode einer sogenannten Superklasse "Tier" und ihre Subklasse "Hase". Warum zeigt mein Compiler ein Fehler an, wenn ich versuche die abstrakten Methoden protected zu deklarieren und die gleichnamigen überschreibenden Methoden in der Subklasse ebenfalls protected mache? Das mache ich doch nur, damit diese vererbenden Klassen nur unter sich zugreifen können und damit die Kopplung lose bleibt.

```
import java.util.List;
import java.util.Random;

/**
 * Tier ist eine abstrakte Superklasse für Tiere. 
 * Sie verwaltet Eigenschaften, die alle Tiere gemein haben,
 * wie etwas das Alter oder eine Position.
 */
public abstract class Tier
{

    // Das Alter, in dem ein Hase gebärfähig wird.
    private static int GEBAER_ALTER;
    // Das Alter dieses Tieres.
    private int alter;
    // Ist dieses Tier noch lebendig?
    private boolean lebendig;
    // Die Position dieses Tieres.
    private Position position;
    private static final Random rand = new Random();

    /**
     * Erzeuge ein Tier mit Alter Null (ein Neugeborenes).
     */
    public Tier()
    {
        alter = 0;
        lebendig = true;
    }
    
    /**
     * Lasse dieses Tier agieren - es soll das tun, was
     * es tun muss oder möchte.
     */
    abstract public void agiere(Feld aktuellesFeld, 
                             Feld naechstesFeld, List neueTiere);
    
    /**
     * Prüfe, ob dieses Tier noch lebendig ist.
     * @return true wenn dieses Tier noch lebendig ist.
     */
    public boolean istLebendig()
    {
        return lebendig;
    }

    /**
     * Signalisiere diesem Tier, dass es gestorben ist.   :-(
     */
    public void setzeGestorben()
    {
        lebendig = false;
    }
    
    /**
     * Liefere das Alter dieses Tieres.
     * @return das Alter dieses Tieres.
     */
    public int gibAlter()
    {
        return alter;
    }

    /**
     * Setze das Alter dieses Tieres.
     * @param alter das Alter dieses Tieres.
     */
    public void setzeAlter(int alter)
    {
        this.alter = alter;
    }
    
    /**
     * Liefere die Position dieses Tieres.
     * @return die Position dieses Tieres.
     */
    public Position gibPosition()
    {
        return position;
    }

    /**
     * Setze die Position dieses Tieres.
     * @param zeile die vertikale Koordinate der Position.
     * @param spalte die horizontale Koordinate der Position.
     */
    public void setzePosition(int zeile, int spalte)
    {
        this.position = new Position(zeile, spalte);
    }

    /**
     * Setze die Position dieses Tieres.
     * @param position die Position dieses Tieres.
     */
    public void setzePosition(Position position)
    {
        this.position = position;
    }
    /**
     * Eine abstrakte Methode, die in den Subklassen 
     * redefiniert wird, da jede Subklasse ihre speziellen werte 
     * für "Gebäralter" hat.
     */
    abstract public int gibGebaerAlter();
    
    /**
     * Diese Methode kann von allen Klassen aufgerufen werden
     * liefert ein booleschen Wert als Methodenergebnis
     */
    public boolean kannGebaeren()
    {
        return gibAlter() >= gibGebaerAlter();
    }
   
    /**
     * Erhöhe das Alter dieses Hasen.
     * Dies kann zu seinem Tod führen.
     * Diese Methode ist nur zum internen Aufruf gedacht, 
     * kann von anderen Klassen nicht aufgerufen werden, deshalb private.
     */
    public void alterErhoehen()
    {
        setzeAlter(gibAlter()+1);
        if(gibAlter() > gibHoechstalter()) {
            setzeGestorben();
        }
    }
    /**
     * Gebäre Nachwuchs, wenn dieses Tier gebärfähig ist.
     * @return die Anzahl der Neugeborenen (kann Null sein).
     * Für den Aufruf in den Subklassen muss diese Methode als private deklariert sein.
     */
    public int gebaereNachwuchs()
    {
        int geburten = 0;
        if(kannGebaeren() && rand.nextDouble() <= gibGebaerwahrscheinlichkeit()) {
            geburten = rand.nextInt(gibWurfGroesse()) + 1;
        }
        return geburten;
    }
    /**
     * Diese Methode wird in den Subklassen redefiniert
     */
    abstract protected double gibGebaerwahrscheinlichkeit();
    /**
     * Diese Methode wird in den Subklasse redefiniert
     */
    abstract protected int gibWurfGroesse();
     /**
     * Diese Methode wird in den Subklassen 
     * redefiniert, da jede Subklasse einen unterschiedlichen 
     * Wert für max_alter hat.
     */
    abstract protected int gibHoechstalter();
    /**
     * Hinweis: eine abstrakte Methode kann nicht private sein, da sie
     * nicht von den subklasse überschrieben werden könnte.
     * Eine abstrakte Methode kann nur public oder protected sein.-->stimmt nicht ganz.
     */
    
}
```
Sowie die Subklasse Hase:

```
import java.util.List;
import java.util.Random;

/**
 * Ein einfaches Modell eines Hasen.
 * Ein Hase altert, bewegt sich, gebärt Nachwuchs und stirbt.
 */
public class Hase extends Tier
{
    // Eigenschaften aller Hasen (statische Datenfelder).

    // Das Alter, in dem ein Hase gebärfähig wird.
    private static final int GEBAER_ALTER = 5;
    // Das Höchstalter eines Hasen.
    private static final int MAX_ALTER = 50;
    // Die Wahrscheinlichkeit, mit der ein Hase Nachwuchs gebärt.
    private static final double GEBAER_WAHRSCHEINLICHKEIT = 0.15;
    // Die maximale Größe eines Wurfes (Anzahl der Jungen)
    private static final int MAX_WURFGROESSE = 5;
    // Ein Zufallsgenerator, der die Geburten beeinflusst.
    private static final Random rand = new Random();
    
    // Individuelle Eigenschaften eines Hasen (Instanzfelder).
    
    /**
     * Erzeuge einen neuen Hasen. Ein Hase kann das Alter 0 
     *(neu geboren) oder ein zufälliges Alter haben.
     * @param zufaelligesAlter soll der Hase ein zufälliges Alter haben?
     */
    public Hase(boolean zufaelligesAlter)
    {
        super();
        if(zufaelligesAlter) {
            setzeAlter(rand.nextInt(MAX_ALTER));
        }
    }
    
    /**
     * Das was ein Hase die meiste Zeit tut - er läuft herum.
     * Manchmal gebärt er Nachwuchs und irgendwann stirbt er
     * an Altersschwäche.
     */
    public void agiere(Feld feld, Feld naechstesFeld, List neueTiere)
    {
        alterErhoehen();
        if(istLebendig()) {
            int geburten = super.gebaereNachwuchs();
            for(int b = 0; b < geburten; b++) {
                Hase neuerHase = new Hase(false);
                neueTiere.add(neuerHase);
                neuerHase.setzePosition(naechstesFeld.zufaelligeNachbarposition(gibPosition()));
                naechstesFeld.platziere(neuerHase);
            }
            Position neuePosition = naechstesFeld.freieNachbarposition(gibPosition());
            // nur in das nächste Feld setzen, wenn eine Position frei istik
            if(neuePosition != null) {
                setzePosition(neuePosition);
                naechstesFeld.platziere(this);
            }
            else {
                // weder Bleiben noch Gehen möglich - Überpopulation - kein Platz 
                setzeGestorben();
            }
        }
    }
    /**
     * Diese Methode gibt das Alter des Hasen als Zeichenkette aus.
     */
     public String toString()
    {
        return "Hase, Alter " + gibAlter();
    }
    
    /**
     * Diese Methode redefiniert die gleichnamige abstrakte Methode 
     * in der Klasse Tier.
     */
    protected int gibHoechstalter()
    {
        return MAX_ALTER;
    }
    /**
     * Diese Methode redefiniert die gleichnamige in der Superklasse
     */
    protected double gibGebaerwahrscheinlichkeit()
     {
         return GEBAER_WAHRSCHEINLICHKEIT;
     }
     /**
      * Diese Methode redefiniert die gleichnamige in der Superklasse
      */
     protected int gibWurfGroesse()
     {
         return MAX_WURFGROESSE;
     }
    
    
    /**
     * Redefinierende Methode der gleichnamigen abstrakten
     * Methode in der Klasse Tier
     * Das Alter, ab dem ein Hase gebären kann.
     */
     protected int gibGebaerAlter()
     {
         return GEBAER_ALTER;
     }
     /**
      * diese redefinierenden Methoden dürfen nicht private sein, 
      * da sie sonst nicht von der superklasse aufgerufen werden könnten, 
      * geht aber sowieso nicht weil die methodensignatur einer abstrakten klasse 
      * in der superklasse private nicht zulässt.
      */
    
}
```


----------



## eRaaaa (3. Aug 2010)

Sollte eig. gehen (vergrößern geht, Sichtbarkeit verkleinern nicht), allerdings habe ich zumindest einen Fall gefunden wo du einmal public und einmal protected verwendest, das geht nicht!


```
abstract public int gibGebaerAlter();
// &
 protected int gibGebaerAlter()
```


----------

