# Probleme mit Zufallszahlen...



## proXXic (15. Oktober 2008)

Hallo,

ich habe ein kleines Problem mit Java...

Ich muss ein Programm schreiben das ein Feld mit vier zufälligen werten zwischen 0 und 9 generiert und auf dem Bildschirm ausgibt.

Mein Code sieht so aus...


```
import java.util.Random;
class RandomArray1 {


	         public static void main(String[]args) {
		getRandomArray();
		print();
	         }
	
	         public static int [] getRandomArray() {
	
	         Random random = new Random(10);	
	         for ( i=0 ; i <4 ; i++ ){
	         int zufall = random.nextInt(10);
	         return getRandomArray;}

	}
		
	public static void print(int[]array){
		
		int[] neu = new int[array];
		for(i = 0; i < blubb; i++){ 
		neu [i] = i+1;}	
	
		}
		
		System.out.print(neu);
}
```

Als Fehlermeldung wird immer 
H:\Programmieren\Übung>javac RandomArray1.java
RandomArray1.java:33: <identifier> expected
                System.out.print(neu);
                                ^
RandomArray1.java:33: <identifier> expected
                System.out.print(neu);
                                    ^
2 errors
                                             ausgegeben...

Wer kann mir bei meinem Problem helfen?
MfG Proxxic


----------



## vfl_freak (15. Oktober 2008)

Hallo,
bitte DRINGEND die Code-Tags (Button '#') benutzen - so ist das Ganze so ziemlich unleserlich ist 

Aber wenn ich das richtig sehe, ist die VAR '*neu'* innerhalb der Funktion '_print_' deklariert und kann somit außerhalb beim Aufruf von '_System.out.print_' nicht bekannt sein .....

Gruß
Klaus


----------



## proXXic (15. Oktober 2008)

Hallo Klaus,

also du meinst das ich die VAR neu im main deklarieren soll?

Das mit den Buttons hab ich nicht gewusst sorry

Hab mich erst vorner halben Stunde angemeldet xD...

MfG
Proxxic


----------



## vfl_freak (15. Oktober 2008)

Hallo proXXic,

genau - das besagt ja auch Deine Fehlermeldung, dass 'neu' an der Stelle nicht bekannt!

Zudem ist "_System.out.print()_" eine SYSTEM-Funktion und nicht etwa die von Dir deklarierte Funktion "_print_"! 

Ich vermute mal, dass Du vor hattest, den Inhalt von '_neu_', der in "_print_" gefüllt wurde auszugeben, ja? Dann musst Du mit Deiner Funktion "_print_" auch den zurückgeben und ein VAR zuweisen, die dann mit "_System.out.print()_" ausgegeben werden kann!

Gruß
Klaus

EDIT: Jau, jetzt sieht das oben schön aus -Danke .... 
EDIT-2: was ist denn "blubb"? Ist auch nicht definiert!
EDIT-3: zudem rufst Du in "main" Deine Funktion 'print' OHNE Parameter auf!


----------



## proXXic (15. Oktober 2008)

blubb ist eigentlich neu^^ hab ich vergessen zu ändern... sry xD

Das Problem ist das ich aus "public static void print" nix zurückgeben kann... da es ja void ist!

Und zu edit 3: Ich weiß einfach nicht was da das zugehörige Übergabeparameter ist...^^ ich schätze mal das es print(int[]array) sein muss...

MfG 
proXXic


----------



## vfl_freak (15. Oktober 2008)

Sowas sollte funktionieren - ist allerdings ungetestet :

  	java Code:

```
import java.util.Random;
class RandomArray1 
{
    public static void main(String[]args) 
    {
              getRandomArray();
          int[] Zahlen = new int[]array;
              print( Zahlen );
        }
 
        public static int[] getRandomArray() 
    {
        Random random = new Random(10);   
                for ( i=0 ; i <4 ; i++ )
        {
            int zufall = random.nextInt(10);
                    return getRandomArray;
        }
        }
 
        public static static int[] print(int[]array zahlen)
    {
                  int blubb = 100;
        for(i = 0; i < blubb; i++)
              {
                       zahlen = i+1;
                      System.out.print("Zahl<" + i + "> = <" + zahlen + ">");
        } 
    }
}
```
 
Gruß
Klaus


----------



## vfl_freak (15. Oktober 2008)

neuer Versuch  


```
import java.util.Random;
class RandomArray1
{
    public static void main(String[]args)
    {
        int[] Zahlen = new int[]array;
        Zahlen = getRandomArray();
        print( Zahlen );
    }

    public static int[] getRandomArray()
    {
        Random random = new Random(10);
        for( i=0 ; i <4 ; i++ )
        {
            int zufall = random.nextInt(10);
            return getRandomArray;
        }
    }

    public static void print(int[]array zahlen)
    {
        int blubb = 100;
        for(i = 0; i < blubb; i++)
        {
            zahlen[i] = i+1;
            System.out.print("Zahl<" + i + "> = <" + zahlen[i] + ">");
        }
    }
}
```
Gruß
Klaus


----------



## epic fail (15. Oktober 2008)

Eine Methode getRandomArray() ist eventuell dazu gedacht, ein Array mit Zufallszahlen zurückzugeben und nicht um sich rekusiv selbst aufzurufen, wie Du es tust, Klaus:


```
return getRandomArray;
```

Davon abgesehen, dass diese Zeile eh einen Compilerfehler erzeugt.

Und warum lässt Du ein Array, das nur 4 Stellen haben soll mit 


```
int blubb = 100;
        for(i = 0; i < blubb; i++)
        {
            zahlen[i] = i+1;
            System.out.print("Zahl<" + i + "> = <" + zahlen[i] + ">");
        }
```

100 Mal durchlaufen


----------



## proXXic (15. Oktober 2008)

Also bei mir schaut das ganze jetzt so aus...

Es werden aber immer noch Fehler angezeigt...


```
import java.util.Random;
class RandomArray1 {


	public static void main(String[]args) {
		getRandomArray();
		print(int[]array);
		
	}
	
	
	
	public static int [] getRandomArray() {
	
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	int zufall = random.nextInt(10);
	return getRandomArray;}
	
	int[] neu = new int[array];
	for(i = 0; i < neu; i++){ 
	neu [i] = i+1;}	
	return 
	
	}
		
	public static void print(int[]array){
		
		System.out.print(neu);
		
		
	}
		
		
		
	
}
```

das untere return nicht beachten das ist falsch...


----------



## epic fail (15. Oktober 2008)

```
int[] neu = new int[array];
```
Das ist keine gültige Deklaration für ein Array. In den eckigen Klammern muss die Länge des Arrays stehen.



```
for ( i=0 ; i <4 ; i++ ){
	int zufall = random.nextInt(10);
	return getRandomArray;}
```
Das ist einfach nur syntaktischer Nonsense. Was sollen diese Zeilen bewirken?


```
neu [i] = i+1;
```
Hier würde ich mal überlegen, was in das Array geschrieben wird. Im ersten Durchlauf wird z.B. folgendes geschehen:
neu[0] = 1;
Ist das die Zuweisung, die Du machen möchtest? Oder sollten da nicht Zufallszahlen rein?

Desweiteren darf es in einer Methode nur ein return-Statement geben. Bei Dir sehe ich zwei. Und beim zweiten sagst Du dem armen Compiler noch nicht mal, was er Dir den zurückgeben soll.


----------



## Orbit (15. Oktober 2008)

Du wilst die Werte aber schon einspeichern oder?


```
public static int [] getRandomArray() {	
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	int zufall = random.nextInt(10);
	return getRandomArray;
}
```
Diese Methode erzeugt 4 Zufallszahlen, speichert sie nicht und gibt ein unbekanntes Objekt zurück...

```
public static int [] getRandomArray() {
        int[] randomArray = new int[4];     // Hier werden die zahlen gespeichert
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	       randomArray[i] =random.nextInt(10);
        }
	return getRandomArray;
}
```

So wie dus vorher hattest, nämlich dass du den return Befehl schon in der forschleife hattest (Vielleicht Codebeispiel falsch zusammengeschnitten?) kann nicht funktionieren. Du würdest beim ersten Schleifendurchlauf die Methode verlassen. Da der Compiler gerRandomArray aber nicht kennt (wolltest du damit eine rekursive Funktion ausführen? dann hätte es heißen müssen getRandomArray<b>()</b>)

Ich habe das jetzt aus der forschlöeife rausgenommen. Damit macht der zweite Teil der funktion aber keinen Sinn mehr. Nach dem ersten return wird deine Funktion sofort verlassen!
Grüße,
Orbit



> Desweiteren darf es in einer Methode nur ein return-Statement geben. Bei Dir sehe ich zwei. Und beim zweiten sagst Du dem armen Compiler noch nicht mal, was er Dir den zurückgeben soll.


Eigentlich kein Problem. Man kann erstens schreiben return; aber dann müsste die Funktion void sein. Dann wird die Funtkion einfach beendet. Und es kann durchaus mehrere returns geben. Zum Beispiel mit bedingten Anweisungen (if(i==) return 5; else return 3);


----------



## epic fail (15. Oktober 2008)

Orbit hat gesagt.:


> Du wilst die Werte aber schon einspeichern oder?
> 
> 
> ```
> ...


Eh nein.


```
public static int [] getRandomArray() {
        int[] randomArray = new int[4];     // Hier werden die zahlen gespeichert
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	       randomArray[i] =random.nextInt(10);
        }
	return getRandomArray;
}
```

Ist es wirklich so schwer, ein richtiges return-Statement zu schreiben?


----------



## epic fail (15. Oktober 2008)

Orbit hat gesagt.:


> Eigentlich kein Problem. Man kann erstens schreiben return; aber dann müsste die Funktion void sein. Dann wird die Funtkion einfach beendet. Und es kann durchaus mehrere returns geben. Zum Beispiel mit bedingten Anweisungen (if(i==) return 5; else return 3);



Ok, die Preisfrage lautet: Wieviele returns werden aufgerufen?
Eins, genau. Darum ging es mir. Ob man jetzt nur eins hinschreibt, oder per if-Abfragen genau eins ausführen lässt, ist egal.


----------



## vfl_freak (15. Oktober 2008)

@epic_fail:
Hi, Du hast natürlich Recht mit dem, was Du weiter oben geschrieben - nur: ist das nicht mein Code gewesen! Den hatte ich mehr oder weniger unbesehen übernommen und ja auch nicht getestet, wie ich schrieb ... ;-)
Ok, hätte mir natürlich trozdem auffallen müssen 
Gruß
Klaus


----------



## Orbit (15. Oktober 2008)

öh, und wieviele werden hier aufgerufen?

```
public static int [] getRandomArray() {
	
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	       int zufall = random.nextInt(10);
	       return getRandomArray;
        }
	
	int[] neu = new int[array];
	for(i = 0; i < neu; i++){ 
	neu [i] = i+1;}	
	return 
	
}
```
Schreib den Code mal in Assembler um;-)
Oder denk dir die forschleife als ein Konstrukt us whileschleifen welche aus einem Sprungbefehl und einer ifanweisung besteht.
Dann steht da nix anderes als if bla return blupp;
nicht dass das sinn machen würde
Aber bis auf den fehler dass beide male irgendwie nicht das geforderte zurückgegeben wird (einmal nichts und einmal, hmm, nix bekanntes) ist die Reihenfolge der returns richtig gesetzt (syntaktisch, nicht semantisch!).

EDIT:
natürlich meinte ich mit

```
public static int [] getRandomArray() {
        int[] randomArray = new int[4];     // Hier werden die zahlen gespeichert
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	       randomArray[i] =random.nextInt(10);
        }
	return getRandomArray;
}
```
eher

```
public static int [] getRandomArray() {
        int[] randomArray = new int[4];     // Hier werden die zahlen gespeichert
	Random random = new Random(10);	
	for ( i=0 ; i <4 ; i++ ){
	       randomArray[i] =random.nextInt(10);
        }
	return randomArray;
}
```


----------



## epic fail (15. Oktober 2008)

Orbit hat gesagt.:


> Aber bis auf den fehler dass beide male irgendwie nicht das geforderte zurückgegeben wird (einmal nichts und einmal, hmm, nix bekanntes) ist die Reihenfolge der returns richtig gesetzt (syntaktisch, nicht semantisch!).


Nein, ist es eben nicht. Das zweite return ist unreachable code. Und damit falsch. Es gibt nicht eine if-Abfrage und somit ist nur ein return zulässig.

Und die Umwandlung einer for-Schleife in eine while mit if-Bedingungen würde mich echt mal interessieren... Und was das Umschreiben in Assembler bringen soll, ebenso.


----------



## Orbit (15. Oktober 2008)

Nein. Das erste return IST bedingt. und somit erkennt der Compiler nur, wenn er sieht dass die Schleife in jedem Fall einmal durchlaufen wird () nur dann wird das erste return nämlich erreicht, dass das zweite unreachable code ist.



> Und die Umwandlung einer for-Schleife in eine while mit if-Bedingungen würde mich echt mal interessieren... Und was das Umschreiben in Assembler bringen soll, ebenso.


Genau, damit du siehst dass es bedingt ist!
So und hier mal eine forschleife als Konstrukt (mit sprungmarke wie in assembler

```
int i = 0;
int max = 20;

for: tueIrgendwas
     i++;
     falls max<=i springe zu end_for;
     springe zu for
end_for: ende des beispiels.
```
Ich habe absichtlich auf assemblersyntax verzichtet. Aber das Prinzip sollte klar sein oder?

Nun folgendes:

```
void seltsam(){
for(int i = 0; i>10; i++){   // wird NIE ausgeführt; die 10 kann auch ne Variable sein, womit der Compiler dies NICHT sehen kann
     return 22;
}
tueIrgendwas();
return 345;
}
```


----------



## epic fail (15. Oktober 2008)

Aye, Du hast natürlich recht!
Dass das erste return in einer for-Schleife stand, hab ich völlig ignoriert  Sorry.

edit 


```
void seltsam(){
for(int i = 0; i>10; i++){   // wird NIE ausgeführt; die 10 kann auch ne Variable sein, womit der Compiler dies NICHT sehen kann
     return 22;
}
tueIrgendwas();
return 345;
}
```
Fällt Dir was auf


----------



## Orbit (15. Oktober 2008)

War auch ein wenig schlecht sichtbar, weil der Code in der forschleife nicht eingerückt war.
@proXXic
Genau deshalb sollte man sich an solche Konventionen halten! 
Immer mit Einrücken arbeiten und eine forschleife am besten so beenden, dass man das Semikolon am ende sieht, also in einer neuen Zeile.
Wenn du 500 Zeilen Quelltext lesen musst, ist es extrem zeitaufwendig, sich das ende einer Schleife erst suchen zu müssen!
also aus

```
for ( i=0 ; i <4 ; i++ ){
	int zufall = random.nextInt(10);
	return getRandomArray;}
```
(Achtung semantisch + syntaktisch unbrauchbar)
mache demnächst

```
for ( i=0 ; i <4 ; i++ ){
	int zufall = random.nextInt(10);
	return getRandomArray;
}
```
um Missverständnissen vorzubeugen....
Gruß,
Orbit



> edit
> 
> Code:
> 
> ...


Ähm, dass ich void angebe aber int zurückgebe?


----------

