Code Analyse

paco89

Bekanntes Mitglied
hi,


ich muss in dem folgendem Code die fehler rausfinden. bevor ich das machen wollte, habe ich zunächst den code in meinen eigenen worten kommentiert und wollte wissen, ob ich das so richtig gemacht habe....

Java:
public class FehlerT {
 
 private int a;           // Deklaration einer Variablen a vom Typ int
 private static int b;   // Deklaration einer statischen Variablen b vom Typ int  
 private int c;           // Deklaration einer Variablen c vom Typ int


/**
Methode "method1" mit Rückgabewert int und einem formalen Parameter a vom Typ double


*/
 public int method1 ( double a) {         // Methodenkopf
 b = a - 2;                                 
                                            /* der Wert von a (fomaler Par.) wird 
                                             * um 2 verrimgert und der statischen 
                                             * Varible zugewiesen
                                             */
                                                       
                                            
 for ( int c = 0, i = 0; c < a; c ++) {    /* for-schleife;   
                                             * Variablen c und i vom Typ int werden
                                             * mit 0 deklariert; 
                                             * c wird um 1 erhöht, 
                                             * denn Postfix-operator c++ <=> c=c+1;
                                             * und wir gehen in die Schleife rein, wenn
                                             * c<a gilt   
                                             */ 
                                                 
 a -= 1;                                    /* die Variable a wird bei jedem Schleifendurchlauf
                                             * um 1 verringert, denn a-=1 bedeutet
                                             * a-=1 <=> a= a-1;
                                            */
                                            
 i ++;                                     // die Variable i wird auch immer um 1 erhöht
 } 
 
 a += ( float )c;                         /**
                                           * ist die Bedingung c<a nicht mehr erfüllt so, 
                                           * so  können wir nicht mehr in die Schleife rein,
                                           * also machen wir jetzt ab hier weiter; die Zeile 38
                                           * ist eine verkürzte Form von a = a + (float) c; 
                                           * d.h. der Wert von c wird zunächst explizit in
                                           * in einen float-Wert gecastet und der Variablen a
                                           * zugewiesen 
                                           */ 
 
                                           
 a += i;                                    // a wird immer um i erhöht
 return ( int )a + b;                      /* a+b wird berechnet in einen int-Wert gecastet und
                                             * wiedergegeben  
                                             */
}

 
 
 
 
 public static void method2 ( int a) {     /** Methodenkopf; Methodendeklaration
                                               * Methode method2 hat als Rückgabewert void;
                                               * also gibt sie nichts zurück;
                                               * sie hat den eine variable a vom typ int als 
                                                 formalen Parameter
                                              */
 int a = 1;                                  // der lokalen Variable a wird der wert 1 zugewiesen
 b = a;                                      // hier bekommt die Variable b den wert von a
 }

 public static void method3 ( int a) {    /** 
                                              * Method3 hat auch als Rückgabewert void;
                                              * d.h. sie gibt nichts zurück; hat auch einen 
                                              * formalen Parameter a vom Typ int
                                             */
                                             
 c = b;                                      // hier wird der Variablen c der Wert von b zugeweisen
 }

 }
 
manche bzw. die meisten Kommentare wie
> Deklaration einer Variablen a vom Typ int
> die Variable i wird auch immer um 1 erhöht
> [a += ( float )c ist] verkürzte Form von a = a + (float) c
> Method3 hat auch als Rückgabewert void; d.h. sie gibt nichts zurück; hat auch einen formalen Parameter a vom Typ int

bringen die Welt doch nun wirklich keinen Schritt weiter, oder?
das kannst du ja separat irgendwo aufschreiben wenn es aus unerfindlichen Gründen heißt 'erkläre jedes Wort der Syntax eines Java-Programms',
aber damit kommentierst du nicht die tatsächliche Funktionsweise/ den Sinn eines Programms

was das Programm tatsächlich macht ist im Moment entsprechend noch unklar,
erst wenn man das ganze Rauschen entfernt kann man anfangen, irgendetwas zu erkennen

Java:
class FehlerT {
    private int a;
    private static int b;
    private int c;

    public int method1(double a) {
        b = a - 2;
        for (int c = 0, i = 0; c < a; c++)   {
            a -= 1;
            i++;
        }
        a += (float)c;
        a += i;
        return (int)a + b;
    }

    public static void method2(int a) {
        int a = 1;
        b = a;
    }

    public static void method3(int a)  {
        c = b;
    }
}
nachdem was mein Compiler sagt geht es allerdings nicht um den Sinn sondern um ganz einfache Fehler wie doppelt definierte Variablen,
dazu wäre dein Ansatz in der Tat nicht ganz schlecht

allerdings hat dir das anscheinend auch nicht geholfen, etwa bei method2() zu erkennen, dass es einen Parameter a gibt und dann noch eine neu definierte lokale Variable a,
beides zusammen geht nicht, doppelt
 
Soweit hast du alle teile richtig erklärt bis auf folgendes:
Java:
for ( int c = 0, i = 0; c < a; c ++) {    /* for-schleife;   
                                            * Variablen c und i vom Typ int werden
                                            * mit 0 deklariert; 
                                            * c wird um 1 erhöht, 
                                            * denn Postfix-operator c++ <=> c=c+1;
                                            * und wir gehen in die Schleife rein, wenn
                                            * c<a gilt   
                                            */
Streng genommen wird die Variable c erst am erst am Ende der Schleife(nach dem durchlaufen) um eins erhöht.
 
danke, für die kommentare.

@slaterB : ich bin noch ein anfänger. hab erst vor kurzem angefangen, zu programmieren. deshalb ist mir wichtig ersteinmal den code richtig zu lesen bzw. die einzelteile zu verstehen. deshalb habe ich meine ergebnisse als kommentare hier gepostet, um zu sehen, ob ich die bestandteile des codes richtig verstanden hab. es ging mir im mom nicht um die fehler. jetzt nachdem ich weiß, dass ich bis auf die schleife allles richtig kommentiert habe, wollte ich mich auf die suche nach fehlern machen.
schade, dass du mir schon einen fehler genannt hast 😉. ich wollte eigtl. selber daraufkommen. aber trotzdem danke.


edit: hey oben im code:

b ist doch eine statische Variable, oder? d.h. doch, dass sie überall in der klasse sichtbar ist und somit eine Klassenvariable darstellt. ich habe nämlich den abschnitt "Unterschied zwischen lokalen Variablen und Klassenvariablen" gelesen.....daher wollte ich nur mal kurz fragen, ob ich das auch so richtig verstanden habe.
 
Zuletzt bearbeitet:
hallo, die fehler, die ich gefunden habe, sind folgende: (dabei habe ich mich auf den unkommentierten code von SlaterB bezogen, weil ich auch der meinung dass er übersichtlicher ist)


also :

- die zeile 22 : müsste der variablen b nicht der formale parameter zugewiesen werden? wieso wird c=b geschrieben und nicht c = a ?

- zeile 17 : der formale Parameter int a heißt genauso wie die lokale variable? anschließend wird b=a geschrieben. welcher wert soll jetzt der variablen b zugewiesen werden? der formale parameter oder die 1 ?


- zeile 13 : hier bin ich mir nicht sicher, was der wert von i sein soll? ist das nicht falsch, weil i gar nicht deklariert wird, außer in der schleifenbedingung und ich weiß nicht, ob die variable i auch nach dem ende der schleife immer noch sichtbar ist...
 
- die zeile 22 : müsste der variablen b nicht der formale parameter zugewiesen werden? wieso wird c=b geschrieben und nicht c = a ?
Wie "SlaterB" bereits erwähnte:
was das Programm tatsächlich macht ist im Moment entsprechend noch unklar
Jedoch sollten Methoden die mit Parametern aufgerufen werden natürlich auch benutzt werden.

- zeile 17 : der formale Parameter int a heißt genauso wie die lokale variable? anschließend wird b=a geschrieben. welcher wert soll jetzt der variablen b zugewiesen werden? der formale parameter oder die 1 ?
Das hast du richtig erkannt, es ist nicht möglich beiden Variablen den selben Namen zu vergeben.

- zeile 13 : hier bin ich mir nicht sicher, was der wert von i sein soll? ist das nicht falsch, weil i gar nicht deklariert wird, außer in der schleifenbedingung und ich weiß nicht, ob die variable i auch nach dem ende der schleife immer noch sichtbar ist...
Genau,
Code:
i
ist nur innerhalb der for-Schleife "sichtbar".
 
Was Zeile 22 angeht habt ihr beide das wesentliche übersehen.
[c]c[/c] ist nämlich als Instanzvariable definiert, während [c]methode3[/c] statisch ist.
 
ja, also vielen dank für die beiträge. hat mich gefreut zu sehen, dass die Fehler, die ich gefunden habe die richtigen waren....habt ihr noch andere vorschläge oder waren das schon die einzigen fehler in dem code?

ach ja, noch n satz zu dem punkt, dass man nicht erkennen kann, was das programm tut...in der aufgabenstellung stand, dass man die syntaktischen Fehler dieser Java Klasse herausfinden soll.
 
b ist doch eine statische Variable, oder? d.h. doch, dass sie überall in der klasse sichtbar ist und somit eine Klassenvariable darstellt. ich habe nämlich den abschnitt "Unterschied zwischen lokalen Variablen und Klassenvariablen" gelesen.....daher wollte ich nur mal kurz fragen, ob ich das auch so richtig verstanden habe.

Das mit static ist für Anfänger immer sehr schwer zu verstehen. Nachdem dein code nicht so aussieht als ob ihr schon irgendwas mit Objektorientierung durchgemacht habt, würde ich mir an deiner Stelle darüber noch nicht den Kopf zerbrechen.
 

Zurück
Oben