Verständnisproblem einer Methode

[javastudent25]

public class PhoneBook {
    Entry[] entries;
    int nEntries;

    PhoneBook(int size) {
        entries = new Entry[size];
        nEntries = 0;
    }

    void enter(String name, int phone) {
        if (nEntries < entries.length && lookup(name) == -1)
            entries[nEntries++] = new Entry(name, phone);
    }

    int lookup(String name) {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++);
        if (i == nEntries)
            return -1;
        else
            return entries[i].phone;
    }
}

Ich habe da bei diesen vorgegebenen Methoden bzw. -m Programm leider ein wenig Probleme die beiden Methoden zu verstehen, was da eigentlich vor sich geht.
Bei der Zeile im lookup

for (i = 0; i < nEntries && !name.equals(entries[I][i].name); i++);

Wird die ForSchleife zuerst vollständig ausgeführt oder wird zwischendurch auch die if-Anweisung unten behandelt? Sonst würde es ja so keinen Sinn machen oder?
Ich meine, nach der For müsste doch eine geschw. Klammer kommen, nicht? {}, also der Rumpf der Schleife wo die ifs stehen

 

[kneitzel]

Die Syntax der for Schleife besagt, dass nach dem for ( ... ) ein Befehl kommt. Dies kann ein Block sein muss aber nicht. In diesem Fall ist sozusagen der leere Befehl danach (ein einfaches ; ).

Somit wird in der for Schleife nichts ausgeführt.

Und wenn man sich das anschaut, dann sieht man, dass die Abbruchbedingung nicht nur ein Endwert ist (i < nEntries) sondern dass noch eine weitere Bedingung angebunden wurde mit &&. Das ist technische möglich, aber in einem Code Review würde sowas wohl einem um die Ohren gehauen .

Anders geschrieben wäre es ein:

for(i =0; i < nEntries; i++) {
  if (name.equals(entries[i].name) break;
}

Aber ich würde hier eher eine while Schleife oder so erwarten.
Konrad

 

[Joose]

Die {} Klammern muss man nicht verwenden wenn es nur ein Statement in der for-Schleife gibt. Analog dazu die if-Bedingung nach der for-Schleife.
Dort werden auch keine {} Klammern vewendet. Würdest du im if-Zweig ein weiteres Statement hinzufügen wollen, dann müsstest du {} Klammern verwenden.
=> Verwende am Besten immer die {} Klammern! (Da kann man nichts falsch machen und auch Fehler vermeiden).

Nein die if-Bedingung wird nicht ausgeführt, diese ist nicht Teil der Schleife.
Die Schleife endet mit dem ";" hinter der Schleife.

Aber ich würde hier eher eine while Schleife oder so erwarten.

Die for-Schleife finde ich schon passend
Die for-Schleife sollte man verwenden wenn man weiß wieviele Durchläufe gemacht werden (entries.length und diese Zahl bleibt eben konstant während die Schleife durchläuft, eine richtige Zählerschleife eben).
Die while bzw. do-while Schleife läuft eben solange bis eine Bedingung nicht mehr zutrifft aber man kann eben nicht sagen wie oft sie durchlaufen wird

 

[javastudent25]

int lookup(String name){
       int i;
       for(i =0; i < nEntries &&!name.equals(entries[i].name); i++);
       if(i == nEntries)
           return-1;
       else
           return entries[i].phone;
   }

ok, wenn ich dann aber einen Namen suche, dann hiesse es:

Fall 1:
Die Schleife geht das Feld zuerst durch, das Feld ist aber leer und i ist <nEntries
if trifft zu und es wird ein -1 ausgegeben


Fall2:

Die Schleife geht das Feld zuerst durch
wenn der Name gefunden wurde, hört die Schleife auf und i hat dann vllt den Wert 8 zB
else wird ausgeführt und dann wird die nummer der Person an der iten Stelle ausgegeben. ok, das ist ja gut

Fall3:

Die Schleife geht das Feld zuerst durch
wenn der Name nicht gefunden wurde, hört die Schleife dann aufgrund von i<nEntries auf und i hat dann den höchsten Wert
else wird ausgeführt und dann wird die nummer der letzten Person an der iten Stelle ausgegeben. das wäre ja dann falsch

liege ich richtig?

 

[Joose]

Fall3:

Die Schleife geht das Feld zuerst durch
wenn der Name nicht gefunden wurde, hört die Schleife dann aufgrund von i<nEntries auf und i hat dann den höchsten Wert
else wird ausgeführt und dann wird die nummer der letzten Person an der iten Stelle ausgegeben. das wäre ja dann falsch

liege ich richtig?

Hier liegst du falsch. Die Schleife vergleicht den Namen mit den letzten Eintrag im Array, wenn dieser nicht übereinstimmt wird "i" nochmals um 1 erhöht (i++) und dann wird erst die for-Schleife verlassen weil i==nEntries und nicht mehr i < nEnrties

 

[kneitzel]

Also Du liegst falsch. Die if Schleife wird durchlaufen. Entweder wird ein Eintrag gefunden, dann ist i < nEntries oder es wird kein Eintrag gefunden, dann ist i == nEntries. Das liegt daran, dass i immer erhöht wird um eins bis es eben nicht mehr kleiner nEntries ist.

@Joose: "Die while bzw. do-while Schleife läuft eben solange bis eine Bedingung nicht mehr zutrifft aber man kann eben nicht sagen wie oft sie durchlaufen wird"
==> Genau daher würde ich die erwarten. Die Anzahl der Durchläufe ist eben nicht bekannt. Daher wurde ja in der for Schleife so ein Konstrukt gebaut. Damit packt man sehr viel Komplexität in eine einzige Zeile, die ich für zu hoch erachte. Was aber zeigt, dass es bezüglich Clean Code unterschiedliche Auffassungen geben kann

Konrad

 

[javastudent25]

Achso ok.
Das Feld hat sagen wir 10 Namen.
nEntries = 10;
Die For geht das Feld durch, wenn es Nichts findet, dann ist i==nEntries und die Anweisung ein der 1. Zeile des ifs wird ausgeführt.
Wenn was gefunden wurde, sprich 6. Stelle zB, dann kommt else..

 

[Joose]

Also Du liegst falsch. Die if Schleife wird durchlaufen.

Ich hoffe du meinst die for-Schleife und nicht die "if-Schleife"

==> Genau daher würde ich die erwarten. Die Anzahl der Durchläufe ist eben nicht bekannt. Daher wurde ja in der for Schleife so ein Konstrukt gebaut. Damit packt man sehr viel Komplexität in eine einzige Zeile, die ich für zu hoch erachte. Was aber zeigt, dass es bezüglich Clean Code unterschiedliche Auffassungen geben kann

Wie du selbst schon sagt diese for-Schleife ist sehr kurz geschrieben dafür unnötig komplex. Und natürlich gilt: Jeder darf gerne selber entscheiden was er verwenden will, da man ja jede while-Schleife in eine for-Schleife umwandeln kann bzw. umgekehrt.

Aber wie oben schon erklärt: Bei einem Array oder eine Liste kann man schon vor der Schleife wissen wie oft die Schleife (maximal) durchlaufen wird: nämlich sooft wie das Array/die Liste groß ist. (natürlich ist dies kein wirklich fixer Wert, aber er ändert sich zur Laufzeit auch nicht). Die while-Schleife passt dann eher wenn ich mir nicht sicher bin wie oft sie durchlaufen wird (zum Beispiel wenn ich in einer Ordner rekursive eine Datei suche, je nachdem wieviele Unterordner vorhanden sind kann diese Zahl Durchlaufzahl variieren.
Ist für mich auf jedenfall logischer (CleanCode eher weniger der Grund), aber zum Glück gibt es ja eben die "künstlerische Freiheit und Vielfalt"

Die For geht das Feld durch, wenn es Nichts findet, dann ist i==nEntries und die Anweisung ein der 1. Zeile des ifs wird ausgeführt.
Wenn was gefunden wurde, sprich 6. Stelle zB, dann kommt else..

Genau!

 

[VfL_Freak]

Also Du liegst falsch. Die if Schleife wird durchlaufen.

Nur mal so am Rande:
http://www.if-schleife.de/

Gruß Klaus

 

[kneitzel]

Ja, das war ein Verschreiber und natürlich meinte ich - wie schon von Joose geschrieben - die for Schleife.

Kommt davon, wenn man Antworten schnell schreibt und dabei nicht gut genug aufpasst. Die Gedanken sind halt schneller als die Finger.

Konrad

 

[javastudent25]

Ok ich habe das Ganze mal angepasst laut meiner Lernaufgabe.
Ich habe anstatt dem return -1 nun eine Exception drin.
Jetzt habe ich irgendwie mit der Methode ueberpruefe(String name) zu kämpfen und mein TestPhoneBook tut irgendwie nicht.. Bibliotheken könnens mal nicht mehr sein

Fehler angezeigt am Kopf der ueberprüfe Methode:
This method must return a result of type String

Das ist ja ein String bei return

und

bei allen 3 book.enter Zeilen im Phonebook TEst
Angela cannot be resolved to a variable
...
...

public class PhoneBook {

    Entry[] entries;
    int nEntries;
    int size;

    PhoneBook(int size) {
        this.size = size;
        entries = new Entry[size];
        nEntries = 0;
    }

    void enter(String name, int phone) throws NoPhoneNumberException, OverFlowException{
        if (phone > 9999999 || phone < 999999){       //ist die Nummer eine 7-stellige Zahl?
        throw new NoPhoneNumberException(name + "has no valid phone number!");
        }    
        if (nEntries < entries.length && ueberpruefe(name) == "empty"){
            entries[nEntries++] = new Entry(name, phone);
        }    
        if (entries.length > size){       //wenn zu viel Feldeintraege
            throw new OverFlowException ("Too much Entries, size too small!");
            }
    }

    int lookup(String name) throws NameNotFoundException {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++);
        if (i == nEntries)
            throw new NameNotFoundException("Der Name" + " " + name + " " + "couldn't be found!");    
        else
            return entries[i].phone;
    }

    String ueberpruefe(String name){
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++);
        if (i == nEntries)
            return "empty";
    
    }
}

public class Entry {
    String name;
    int phone;

    public Entry (String name, int phone){
        this.name = name;
        this.phone = phone;
    }
}

public class Test_PhoneBook {
    public static void main(String[] args) {
        PhoneBook book = new PhoneBook(50);   
        try {
            book.enter(Angela, 1547621);
            book.enter(Mark, 1234567);
            book.enter(Bruce, 2314534);
        } catch (NoPhoneNumberException noPhone) {
            System.out.println(noPhone.getMessage());
        }
    }
}

public class NoPhoneNumberException extends Exception{
    NoPhoneNumberException(String text){
        super(text);
    }
}

public class NameNotFoundException extends Exception{
    NameNotFoundException(String text){
        super(text);    
    }
}

public class OverFlowException extends Exception{
    OverFlowException (String text){
        super (text);
    }
}

 

[Joose]

Naja wenn "i == nEntries" gibst du "empty" zurück. Was gibst du zurück wenn "i != nEntries"?
Eine Methode mit Rückgabetyp != void MUSS etwas zurückgeben (ein entsprechender Wert, oder eine Exception schmeißen).

Ich nehme an du willst an die Methode "enter" einen String übergeben, dann musst diesen natürlich mit " angeben -> "Angela", ansonten glaubt die IDE es sollte eine Variable "Angela" geben.

 

[javastudent25]

ok, es hat funktioniert, danke vielmals. Das sind Dinge, die hätte ich wissen sollen...
nun meine Overflow funktioniert irgendwie nicht, wenn ich size = 2 eingebe, bei der Erstellung eines Objekts

public class PhoneBook {
    Entry[] entries;
    int nEntries;
    int size;

    PhoneBook(int size) {
        this.size = size;
        entries = new Entry[size];

        nEntries = 0;
    }

    void enter(String name, int phone) throws NoPhoneNumberException, OverFlowException {
        if (phone > 9999999 || phone < 999999) { // ist die Nummer eine
                                                    // 7-stellige Zahl?
            throw new NoPhoneNumberException(name + " has no valid phone number!");
        }
        if (nEntries < entries.length && ueberpruefe(name) == "name not included") {
            entries[nEntries++] = new Entry(name, phone);
        }
        if (entries.length > size) { // wenn zu viel Feldeintraege
            throw new OverFlowException("Too much Entries, size too small!");
        }
    }

    int lookup(String name) throws NameNotFoundException {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[I].name); i++)
            ;
        if (i == nEntries)
            throw new NameNotFoundException("The name" + " " + name + " " + "couldn't be found!");

        else
            return entries[I].phone;
    }

    String ueberpruefe(String name) {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[I].name); i++)
            ;
        if (i == nEntries) {
            return "name not included";
        }
            return "";
    }
}

public class Test_PhoneBook {
    public static void main(String[] args) {
        PhoneBook book = new PhoneBook(2);

        try {
            book.enter("Angela", 1547631);
            book.enter("Mark", 1234567);
            book.enter("Bruce", 2314534);
            book.lookup("Angelason");

        } catch (NoPhoneNumberException noPhone) {
            System.out.println(noPhone);        
        }
        catch (NameNotFoundException noName) {
            System.out.println(noName);        
        }    
        catch (OverFlowException overFlow) {        
            System.out.println(overFlow);        
        }
    }
}

 

[Joose]

        if (nEntries < entries.length && ueberpruefe(name) == "name not included") {
            entries[nEntries++] = new Entry(name, phone);
        }
        if (entries.length > size) { // wenn zu viel Feldeintraege
            throw new OverFlowException("Too much Entries, size too small!");
        }
    }

1.) Strings werden mit "equals" und nicht mit "==" verglichen
2.) "entries.length > size" wird immer false ergeben. Die Größe des Arrays legst du im Konstruktor fest und die wird auch nicht mehr geändert, bei "size" ebenso. Daher wird immer "2 > 2" verglichen. Du müsstest "nEntries" verwenden. Außerdem solltest du erst überprüfen ob du noch einen Eintrag hinzufügen kannst und ihn erst danach hinzufügen

 

[javastudent25]

danke
aber wenn ich zuerst überprüfe, ob noch Platz ist, brauche ich ja keine Exception mehr..

 

[javastudent25]

ich habe es mal angepasst und den size, habe ich noch auf 2.
Geändert hat sich daran aber noch Nichts..

public class PhoneBook {

    Entry[] entries;
    int nEntries;
    int size;

    PhoneBook(int size) {
        this.size = size;
        entries = new Entry[size];

        nEntries = 0;
    }

    void enter(String name, int phone) throws NoPhoneNumberException, OverFlowException {
        if (phone > 9999999 || phone < 999999) { // ist die Nummer eine
                                                    // 7-stellige Zahl?
            throw new NoPhoneNumberException(name + " has no valid phone number!");
        }
        if (nEntries < entries.length && ueberpruefe(name).equals("name not included")) {
            entries[nEntries++] = new Entry(name, phone);
        }

        if (nEntries > entries.length) { // wenn zu viel Feldeintraege
            throw new OverFlowException("Too much Entries, size too small!");
        }
    }

    int lookup(String name) throws NameNotFoundException {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++)
            ;
        if (i == nEntries)
            throw new NameNotFoundException("The name" + " " + name + " " + "couldn't be found!");

        else
            return entries[i].phone;
    }

    String ueberpruefe(String name) {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++)
            ;
        if (i == nEntries) {
            return "name not included";
        }
            return "";
    }

   
}

 

[Joose]

Naja dir bleiben jetzt 3 Möglichkeiten:
1) Du gibst dir in der Methode "enter" einfach mal testweise die einzelnen Werte "nEntries" usw. aus, dann siehst du welche Variable welche Wert annimmt usw.
2) Du machst einen STT (Schreibtischtest) und spielst die Methode nach
3) Du verwendest den Debugger der IDE und schaust dir die Werte zur Laufzeit an

Dabei solltest du dann auf deinen kleinen Denkfehler stoßen. Tipp: Überlege welchen Wert "nEntries" wann annimmt.

 

[javastudent25]

ich hab jetzt extra Methoden gemacht dafür.
Wie geht das mit dem Debugger von der IDE, mit der ich die Laufzeitwerte sehe?
Ich kann es immer nur ausführen irgendwie..

 

[javastudent25]

Die Werte sind gleich und können ja nur gleich gross werden mann mann
Wenn ich einen Eimer habe für 6 Liter, passen ja auch keine 7 rein oder??

Ich habe das nun so gemacht:

public class Test_PhoneBook {
    public static void main(String[] args) {
        PhoneBook book = new PhoneBook(2);

        try {
            book.enter("Angela", 1547631);
            book.enter("Mark", 1234567);
            book.enter("Bruce", 2314534);
            book.lookup("Angela");
         
            book.gibLength();         
            book.gibnEntries();

        } catch (NoPhoneNumberException noPhone) {
            System.out.println(noPhone);         
        } catch (NameNotFoundException noName) {
            System.out.println(noName);         
        } catch (OverFlowException overFlow) {         
            System.out.println(overFlow);         
        }
    }
}

public class PhoneBook {
    Entry[] entries;
    int nEntries;
    int size;

    PhoneBook(int size) {
        this.size = size;
        entries = new Entry[size];
        nEntries = 0;
    }

    void enter(String name, int phone) throws NoPhoneNumberException, OverFlowException {
        if (phone > 9999999 || phone < 999999) { // ist die Nummer eine
                                                    // 7-stellige Zahl?
            throw new NoPhoneNumberException(name + " has no valid phone number!");
        }     
        if (nEntries == entries.length) { // wenn zu viel Feldeintraege
            throw new OverFlowException("Too much Entries, size too small!");
        }
        if (nEntries < entries.length && ueberpruefe(name).equals("name not included")) {
            entries[nEntries++] = new Entry(name, phone);
        }
    }

    int lookup(String name) throws NameNotFoundException {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++)
            ;
        if (i == nEntries)
            throw new NameNotFoundException("The name" + " " + name + " " + "couldn't be found!");
        else
            return entries[i].phone;
    }

    String ueberpruefe(String name) {
        int i;
        for (i = 0; i < nEntries && !name.equals(entries[i].name); i++)
            ;
        if (i == nEntries) {
            return "name not included";
        }
            return "";
    }
 
    void gibLength(){
        System.out.println(entries.length);
    }
 
    void gibnEntries(){
        System.out.println(nEntries);
    } 
}

public class Entry {
    String name;
    int phone;
 
    public Entry (String name, int phone){
        this.name = name;
        this.phone = phone;
    }
}

public class NameNotFoundException extends Exception{ 
    NameNotFoundException(String text){
        super(text);     
    }
}

public class OverFlowException extends Exception{ 
    OverFlowException (String text){
        super (text);
    }
}

public class NoPhoneNumberException extends Exception{ 
    NoPhoneNumberException(String text){
        super(text);
    }
}

 

[Joose]

Naja kommt darauf an welche IDE du verwendest ... Eclipse, Netbeans, IntelliJ, ...
Am besten schaust du auf der Webseite der IDE nach, dort gibt es meisten gute Tutorials welche dir erklären wie man den Debugger verwenden kann. Ansonsten gibts auch sicher einige YouTube Videos.
In diesem Fall ist Videomaterial sicher verständlicher als eine Beschreibung

 

[javastudent25]

Naja kommt darauf an welche IDE du verwendest ... Eclipse, Netbeans, IntelliJ, ...
Am besten schaust du auf der Webseite der IDE nach, dort gibt es meisten gute Tutorials welche dir erklären wie man den Debugger verwenden kann. Ansonsten gibts auch sicher einige YouTube Videos.
In diesem Fall ist Videomaterial sicher verständlicher als eine Beschreibung

Danke Werd ich gleich mal machen, damit spar ich mir Zeit
Danke auch an alle anderen Freunde