[Java] versteh den Code (für totale Anfänger)

Code:

---

public class übung1 {

    /**
    * @param args
    */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       
        int t = 10;
        String[] z = {"ha"," we","hall","low","elt","lt","llo"," we","ll","hall","0","lowe"," we"};

        for( int x = 0; x < t ; x++ ){
              if( x == 2 | x == 4 | x == 6 | x == 8 | x == 10 )
                  {
                  x = x - 3;
                System.out.print( z[x]);
                }
                  else if (x == 1 | x == 3 | x == 5 | x == 7 | x == 9 )
                {
                    x = x + 5;
                System.out.print( z[x]);
                }
                else
                {
                System.out.print(z[x]);
                }
               
              }
        System.out.print(z[5]);

    }

}

---

Nachdem mein letzter Thread ein ziemlicher Fail war, probiere ich es noch einmal mit einem selbst geschriebenen Code.
Wieder geht es darum das ihr den Code versteht.
Das Ergebnis ist vllt schon absehbar.
Also wer einfach nur ausprobieren mag ob er einfach JAvacode versteht kann ja mal Schritt für Schritt aufschreiben was in dem Code passiert.
Da es recht einfacher Code, ist es etwas für Anfänger

Ist nicht sonderlich schwer zu verstehen, aber das hast du ja auch bereits gesagt! ;)

Hier mal die Lösung:

Der Sinn des Programmes ist es dem User "hallo welt" ausgeben zu lassen.
Hierzu hast du "Wortfetzen" in ein Array gepackt, wobei das erste "ha" den index 0 trägt und das letzte " we" den index 12.
Nun kommen wir zur Schleife, in der du x=0 deklariert hast und den Code in der Schleife solange aufrufen lässt, wie x < t ist.
Als nächstes trifft man auf ein paar Bedingungen. Was Bedingungen sind weiß glaube ich jeder (und wenn nicht, dann kann jeder "if" übersetzen bzw. übersetzen lassen :D ), das einzige was man vielleicht dazu erwähnen könnte wäre das "|", denn das steht für "oder". :)

Nun muss man eigentlich nurnoch gucken welchen Wert x immer trägt. Weil ich keine Bock habe jeden Durchlauf zu erklären, werde ich jetzt nur den Inhalt von "z[x]" nach jedem durchlauf posten :):

1.Durchlauf (index=0): "ha"
2.Durchlauf (index=6): "llo"
3.Durchlauf (index=12):" we"

Nun springt er aus der Schleife raus weil 12 größer als "t" ist ("t" ist ja 10^^).
Durch den Befehl:

Code:

---

System.out.print(z[5]);

---

wird die Ausgabe nun vollständig, denn diese gibt den Index 5 des Arrays wieder und da steht "lt" drin.

Für mögliche Rechtschreibfehler oder Tippfehler bei den Indizes möchte ich mich jetzt zu so später Stunde schonmal entschuldigen! :D

mfg

Barny

Hier mal eine etwas schwierigere Variante:

Code:

---

import java.math.BigDecimal;
import java.math.RoundingMode;

public class understandme
{
        final static int n = 12;
        final static int scale = 10;
       
        public static void main(String arg[])
        {
                BigDecimal A[][] = new BigDecimal[n][n];
                BigDecimal L[][] = new BigDecimal[n][n];
                BigDecimal R[][] = new BigDecimal[n][n];
                BigDecimal y[] = new BigDecimal[n];
                BigDecimal x[] = new BigDecimal[n];
                BigDecimal b[] = new BigDecimal[n];
                BigDecimal tmp;
                int i, j, k, l, m;
                int A_int[][] = {
                        {0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0},
                        {0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0},
                        {0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0},
                        {1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0},
                        {0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0},
                        {0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0},
                        {1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0},
                        {1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0},
                        {1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0},
                        {0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0},
                        {0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0},
                        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
                };
                int b_int[] = {344, 420, 581, 865, 693, 323, 667, 463, 524, 528, 455, 10};
               
                for(i = 0; i < n; i++)
                {
                        for(j = 0; j < n; j++)
                                A[i][j] = new BigDecimal(A_int[i][j]);
                        b[i] = new BigDecimal(b_int[i]);
                        x[i] = new BigDecimal(0);
                        y[i] = new BigDecimal(0);
                }
               
                for(j = 0; j < n-1; j++)
                {
                        for(m = j; m < n; m++)
                                if (A[m][j].doubleValue() != 0.0f) break;
                        if (m == n) return;
                        for(l = 0; l < n; l++)
                        {
                                tmp = A[m][l]; A[m][l] = A[j][l]; A[j][l] = tmp;
                        }
                        tmp = b[m]; b[m] = b[j]; b[j] = tmp;
                        for(k = j+1; k < n; k++)
                        {
                                A[k][j] = A[k][j].divide(A[j][j], scale, RoundingMode.HALF_UP);
                                for(i = j+1; i < n; i++)
                                        A[k][i] = A[k][i].subtract(A[k][j].multiply(A[j][i]));
                        }
                }
                for(i = 0; i < n; i++)
                {
                        for(j = 0; j < n; j++)
                        {
                                R[i][j] = L[i][j] = new BigDecimal(0);
                                if (i == j) L[i][j] = new BigDecimal(1);
                                if (i <= j) R[i][j] = A[i][j];
                                else L[i][j] = A[i][j];
                        }
                }
               
                for(k = 0; k < n; k++)
                {
                        for(j = 0; j < k; j++)
                                y[k] = y[k].add(L[k][j].multiply(y[j]));
                        y[k] = b[k].subtract(y[k]).divide(L[k][k], scale, RoundingMode.HALF_UP);
                }
                for(k = n-1; k >= 0; k--)
                {
                        for(j = k+1; j < n; j++)
                                x[k] = x[k].add(R[k][j].multiply(x[j]));
                        x[k] = y[k].subtract(x[k]).divide(R[k][k], scale, RoundingMode.HALF_UP);
                }
                for(i = 0; i < n; i++)
                        System.out.print((char) Math.round(x[i].doubleValue()));
        }
       
}

---

n und scale werden als statische und finale Variablen vom Typ INT definiert. sie können also nicht überschattet werden.
Dann werden A,R,L als Array vom Typ BigDecimal deklariert mit der Länge n, Und jedes Element ist wiederum ein Array mit der Länge n.
x,y,z werden auch als Array vom Typ BigDecimal deklariert mit der Länge n.
Dann wird tmp als BigDecimal Variable deklariert die ncoph keinen Wert hat.
i,j,k,l,m werden als Int Variable deklariert.
Dann wird ein Int Array deklariert dessen Elemente wiederum Arrays sind die 0 und 1 als Elemente haben.
b_Int wir wiederum als Int Array deklariert.
Dann kommt eine erste For-Schleife,zuerst i den Anfangswert 0 zuweist und die so lange läuft wie i<12 ist und bei jedem Durchlauf i um eins erhöt
in der For-Schleife(1) kommt eine weitere For-Schleife die j den Anfangswert 0 zuweist , die solange läuft wie j<12 ist und j bei jedem Durchlauf j um 1 erhöt.
in der For-Schleife bekommt A die Werte von A_Int zugewiesen. For-Schleife(1) ende
b bekommt die werte von b_Int zugewiesen und alle Elemente von x und y werden gleich 0 gesetzt.


bis jetzt richtig? ist ja erst 1/4 vom code oder so

Hmm leider keine Zeilennummern, aber läuft dieser Code überhaupt :-D

in der for schleife:
if(x==2){
x=x-3; (somit ist x=-1)
System.out.println(z[x]) <-- Index out of Bounds?!
}

Hab das ganze nicht ausprobiert, sagt mir wenn ich da falsch liege

x wird in der Schleife nie == 2 werden.

Du hast aber allgemein recht, dass der Index nicht negativ werden kann.