# Ist Java zu kompliziert für Jedermann?



## Toni32 (4. Mai 2015)

Hallo,

ich habe vor kurzem angefangen mich hobbymäßig intensiv mit Java zu beschäftigen.
Meine bisherigen Erfahrungen mit Programmieren sind ziemlich gering, ganz früher mal mit Amiga Basic und Pascal etwas herumgespielt, zuletzt mit Linux Bash Skripts. Aber immerhin ist man da relativ schnell in die Grundfunktionen reingekommen und hat kleinere Dinge hinbekommen.

Bei Java jedoch schaffe ich es erstmals überhaupt gar nicht rein zu kommen! Habe mir von einem Bekannten das Buch "Java von Kopf bis Fuß" ausgeliehen und gehe dies Seite für Seite durch.

Es ist zwar gut geschrieben und ich meine mitzukommen, aber wenn dann die Beispiele kommen verstehe ich ab dem Kapitel "Objekthausen" garnichts mehr (If- und While Schleifen klappten noch gut).

Z.B. das Kapitel mit dem Ratespiel (Seite 39, falls jemand das Buch hat). Der Code ist einfach so "lang" und scheint so ineinander verschachtelt, die ganzen Klammern (die auch irgendwie nirgends wirklich erklärt werden), Variablen die gesetzt werden, an ganz anderer Stelle abgerufen werden, wieder mit anderen Begriffen verbunden, ich kapier es einfach nicht und kann die Zusammenhänge in dem ganzen Code einfach nicht auseinander halten!
Selbst wenn z.B. While und If Schleifen verschachtelt werden, fällt es mir schon schwer den Überblick zu behalten was jetzt eigentlich was bewirkt und sich worauf bezieht, wo eine Klammer anfängt und wo sie wieder geschlossen wird.

Habe jetzt auch schon etliche andere Tutorial Seiten für Anfänger angeschaut, aber ich bleibe immer wieder stecken, sobald es über Hello World und Schleifen hinausgeht.

Was soll ich noch machen um in das Thema reinzukommen? Bin jedenfalls schon ziemlich frustriert und verliere so langsam die Motivation, wenn man zum 5. Mal umsonst das selbe Kapitel liest.

Oder braucht man eine gewisse Veranlagung, um das alles klar zu sehen und ich sollte es lieber ganz lassen?

Gruß
Toni


----------



## Major_Sauce (4. Mai 2015)

Also das gewisse Etwas sollte schon vorhanden sein, das "Etwas" nennt sich logisches Denken.
Sonst sagt der name "Programmiersprache" schon recht viel, du musst einfach alle wichtigen Anweisungen und Datentypen einfach auswendig lernen.
Einfach mal die Datentypen lernen, booleans, double, int, String usw sind.
Dann vielleicht mal schauen was denn Methoden überhaubt sind, wie man sie aufruft und und und...
Falls sich noch ein oder zwei Leute finden die Interesse haben könnte ich auch eine Videoreihe machen, am bessten im Livestream wo ich euch das ganze Zeug erkläre, aber wie gesagt da müssen sich noch ein paar Interessenten finden.

mfg Major


----------



## franky27 (4. Mai 2015)

Also erstmal - es gibt keine if Schleifen. If ist eine Anweisung und dient dazu einen Ausdruck auszuwerten und je nach Auswertung dann irgendetwas zu tun. Das hat mit einer Schleife nichts zu tun.
Prinzipiell kann ich dir nicht beantworten, ob du eine "Veranlagung" dafür hast. Gibt wohl sicherlich Leute die sich mit der Denkweise schwerer tun als andere, Andererseits bin ich davon überzeugt das das im Prinzip fast jeder lernen kann, aber du brauchst halt Duchhaltevermögen. Ich würde dir raten kleinere Schritte zu machen als du es vielleicht momentan versuchst. Nicht einfach ein Buch so schnell wie möglich durchlesen wollen, sondern das nächste Kapitel wirklich erst anfangen wenn du das vorherige absolut verstanden hast. Dazu ist es imo auch extrem wichtig, dass du Beispiele und Aufgaben nicht nur durchliest sondern auf jeden Fall abtippst und versuchst Zeile für Zeile zu verstehen. Themen die du aus einem Buch nicht kapierst dann eben nochmal woanders besorgen, google, youtube etc. gibt ja genug Tutorials für fast alles. Oder du postest hier Code Ausschnitte die du nicht verstehst und lässt dir helfen. Klammern etc sind eigentlich recht einfach zu verstehen, da kannst du mal nach "Blöcke" googlen. Bei komplexen verschachtelten Klammern ist es zumeist hilfreich von aussen nach innen zu gehen um sich den Ablauf klar zu machen.


----------



## Saheeda (4. Mai 2015)

@Toni

Für mich war Java die erste richtige Programmiersprache, ich hatte vorher n paar Kurse bei CodeCademy gemacht, aber nichts Tiefergreifendes.
Die erste Zeit dachte ich permanent "WTF wollt ihr eigentlich von mir? o.0 So dämlich bin ich doch gar nicht.", aber je mehr ich damit arbeitete, desto besser und intuitiver wurde es für mich.

Beispiele aus dem Internet habe ich nicht einfach nur kopiert, sondern damit rumgespielt: Parameter verändert, Zugriffe variiert, mit dem Debugger in Eclipse Schritt für Schritt durchgegangen und Variablen beobachtet etc, bis ich der Meinung war zu verstehen, was da eigentlich passiert; ganz ganz oft irgendwelchen Code gelöscht und von vorn angefangen, weil ich es selbst nur Murks fand.

Die ersten Programme waren ganz banale Sachen: Quersumme, Durchschnitt, Potenz, Taschenrechner,...
Bei Project Euler findest du ganz ganz viele solcher Übungsaufgaben.

Ich hab viel hier im Forum mitgelesen und aus den Fehlern anderer gelernt oder mir Sachen erklären lassen, wenn ich überhaupt keinen Plan hatte, warum etwas nicht funktioniert.

Vielleicht hilft dir ja auch BlueJ weiter. Ich persönlich mag das Programm eher weniger, aber hier im Forum sind häufiger Schüler unterwegs, die das im Informatikunterricht benutzen.


----------



## Toni32 (4. Mai 2015)

Hallo,

danke schon mal für die Antworten.

@Saheeda
Genauso hab ich es bisher auch gemacht, den Code aus den Übungen selber immer etwas verändert oder Teile hinzugefügt. Nach Hello World und If-Anweisung hab ich so auch einen primitiven Taschenrechner (natürlich ohne GUI) selbst hinbekommen, wo ich schon dachte es klappt ja mit der Lernkurve.

Um nochmal auf das Buch einzugehen (welches ja auch sehr oft zum Einsteig empfohlen wird).
Die Theorie über Objekte und Klassen habe ich ja noch halbwegs verstanden, aber dann kommt ja dieses Ratespiel.

Hier mal ein Ausschnitt:


```
public class Ratespiel {
    Spieler s1;
    Spieler s2;
    Spieler s3;

public void starteSpiel()  {
    s1 = new Spieler();
    s2 = new Spieler();
    s3 = new Spieler();

    int tipp1 = 0;
    int tipp2 = 0;
    int tipp3 = 0;

    boolean s1hatRecht = false;
    boolean s2hatRecht = false;
    boolean s3hatRecht = false;

    int zielZahl = (int) (Math.random() * 10);
    System.out.println("Ich denke mir eine Zahl zwischen 0 und 9 aus");

    while(true)  {
    System.out.println("Die zu ratende Zahl ist " + zielZahl);

    s1.raten();
    s2.raten();
    s3.raten();

    tipp1 = s1.zahl;
    System.out.println ("Spieler eins tippte " + tipp1);
```

Was genau ist eigentlich "Spieler", s1 s2... sind wohl Variablen, aber wieso wird das so geschrieben und nicht z.B. String s1;?

Danach kommt dann nochmal "s1 = new Spieler();"
Ich verstehe da schon nicht was die Zeile überhaupt bewirkt und welchen Zweck haben eigentlich die () Klammern?

"boolean s1hatRecht = false;" soll ja für die Falsch oder Richtig Antwort der Spieler sein, hier wird sie aber schon auf "Falsch" gesetzt, obwohl dies im weiteren Verlauf ja noch gar nicht feststeht.

Und alles was danach kommt wird für mich noch undurchsichtiger: "while(true)" <- Es wurde nicht erklärt was true für eine Bedingung ist, "s1.raten();" verstehe ich auch nicht und wieso sind da wieder Klammern, wenn da eh nie was drinsteht?
Meine Fragen klingen vielleicht irgendwie dämlich  aber ich habe nur Fragezeichen über dem Kopf, wenn ich das immer wieder durchgehe.


----------



## Major_Sauce (4. Mai 2015)

Wie gesagt, bevor du auf sowas eingehst solltest du erst mal die Schleifen und Anweisungen beherrschen.
Ich würde einfach mal sagen dass es am effizientesten ist wenn du einfach nur mal mit Aufgaben anfängst die man in einer Methode regeln kann. Das was du hier hast ist schon relativ komplex für jemanden der nicht wirklich was von Java versteht.
Zu der Frage was "Spieler" denn ist, Spieler ist eine Klasse die mit Sicherheit irgendwo in deinem Proket liegt. Darin wird außerdem eine Methode namens "raten()" liegen, denn diese wird in deinem Beispielcode ausgeführt...

mfg Major


----------



## Saheeda (4. Mai 2015)

@Toni

Wenn du unbedingt mit Objekten arbeiten möchtest, dann fang simpler an. Erstell dir 1(!) Klasse, der du verschiedene Methoden und Eigenschaften mitgibst (nur int, float, string, boolean, double als Typen, keine anderen Objekte!) und spiele damit rum. Versteh, was ein Konstruktor ist, was der macht und wie du den aufbaust.


Ich versteh dich nur zu gut, dass du schnell irgendwas sehen willst. Aber wenn du die Grundlagen nicht richtig verstehst, fällst du später richtig auf die Nase.
Es ist übrigens eine sehr gute Idee, erstmal auf ne GUI zu verzichten und nur mit Konsole zu arbeiten.

Wenn du magst, kann ich dir auch per PN oder Skype helfen. Wenn du schon bisschen was in anderen Sprachen gemacht hast, könnte man ja vielleicht erstmal das "übersetzen", damit du die Parallelen siehst.


----------



## franky27 (4. Mai 2015)

Naja Toni, laut den Auszügen aus dem Buch hier https://books.google.de/books?id=kjtIBQAAQBAJ  ist auf den vorherigen Seiten (habs mal überflogen) zB recht eindeutig beschrieben was Klassen und deren Objekte sind. Wenn du dann nicht verstehst was ein Objekt Spieler ist, dann hast du imo einfach zu schnell gelesen und nicht wirklich verstanden was da erklärt wurde. Lass dir mehr Zeit und überflieg nicht nur was du nicht verstehst.


----------



## Toni32 (5. Mai 2015)

Ich bin jetzt nochmal ein paar Seiten zurückgegangen und versuche es nochmal.
Die reine Theorie von Objekten und Klassen verstehe ich anhand der Beispiele ja noch, nur die praktischen Code Beispiele nicht.

Z.B. hier:

```
class Film {
  String Title;
  String genre;
  void vorführen() {
    System.out.println("Führe vor");
   }
}

public class FilmTestlauf {
 public static void main(String[] args) {
   Film eins = new Film();
   eins.titel=""
   eins.genre=""
```
Wenn man die Zeile "Film eins = new Film();" mal auseinander nimmt, was ist "eins" eigentlich, ein Objekt? Und die Werte nach dem Punkt sind dann Variablen die dem Objekt zugewiesen werden? Also das der Klasse "Film" das Objekt "eins" hinzugefügt wird, verstehe ich das richtig?

Gibt es eigentlich empfehlenswerte Seiten, die das ganze auch nochmal Anfängertauglich erklären? Habe zwar schon gesucht und einiges gefunden, aber die unterschiedlichen Beispiele verwirren eher noch mehr.


----------



## Saheeda (5. Mai 2015)

Die Schreibweise für Objekte in Java sieht so aus:

[Typ] [Variablenname] = new [Typ]

Du hast also ein Objekt namens "eins" vom Typ Film.
Der Klasse selbst wird nichts hinzugefügt. Die ist nur der Bauplan für ein Objekt und "eins" ist ein konkreter Vertreter dieser Klasse.

Mit dem Punkt hinter dem Variablennamen greifst du auf die Eigenschaften zu, die in der Klasse Film deklariert sind.

Es gibt im Netz unzählige Tutorials, was für dich am besten passt, musst du selbst rausfinden.
Damit arbeiten glaube ich recht viele:
Java Tutorial interaktiv - Programmieren lernen mit Java


----------



## tommysenf (5. Mai 2015)

Stell dir eine Klasse als ein Ausstechförmchen vor, mit dem du Plätzchen(Objekte) genau dieser Form erstellen kannst. Die Klasse definiert also einen neuen Typen. In diesem Fall den Typen Film. Ein Film wird hierbei so definiert, dass er ein Attribut title und ein Attribut genre sowie die Methode vorführen. Um mit einem Film zu Arbeiten musst du erst mal ein neues Objekt dieses Typen erstellen. Der Operator hierzu ist new. Mit Film eins = new Film() legst du ein neues Objekt der Klasse Film an und benennst dieses Objekt mit dem Variablennamen eins.


----------



## coco07 (6. Mai 2015)

Hey Toni,

ich selbst habe vor 2 Jahren angefangen mich aktiv mit Java zu beschäftigen(hatte keinerlei Vorkenntnisse). Auch ich habe das gleiche Buch wie du benutzt und habe alles gleich auf Anhieb verstanden. Allerdings kamen bei den Konstruktoren auch in mir Fragen bezüglich der Syntax auf. Mittlerweile schreibe ich sehr komplizierte Spiele im Alleingang. Irgendwann ist eine Programmiersprache so sehr im Gehirn verankert wie deine Muttersprache und du denkst nicht mehr an die Syntax sondern nur noch an die Logik des Programms. Ich muss dazu sagen, dass ich sehr oft nächtelang gelernt habe,mir 5 Bücher trocken reingezogen habe und dafür auf andere Dinge verzichtet hab. Ich kann dir da den JavaVideoKurs sehr empfehlen, wo der Autor auf jedes kleine Detail eingeht und dir alles sehr verständlich beibringt. Versuche es weiter und gib nicht auf  Irgendwann springt der Funke auch bei dir über )

Grüße Fabi!


----------



## fanta5 (6. Mai 2015)

Hi Toni,

ich bin auch neu in Sachen Java und mir geht es nicht soo viel anders als Dir. (siehe meine Frage hier). 

Und ich finde (zumindest den objektorientierten) Java-Einstieg auch nicht ganz easy. Wie sagt man also so schön: Geteiltes Leid ist halbes Leid. Was mir motivationstechnisch immer wieder "über den Berg" hilft, ist, dass ich diese Art von Lernkurve schon aus anderen Bereichen kenne. Dieses "immer wieder fällt mal ein Groschen oder wenigstens ein Pfennig", das motiviert dann für die nächsten Schritte in Dachen "durchbeißen und durchhalten". 

Ich schlage Dir vor, erst nochmal ein bischen prozedural zu lernen und Dich danach erst mit OO zu beschäftigen. Das muß nichtmal in Java sein. Bei mir wars z.b C. 

Was das Lernen von Java angeht: Neben Büchern (z.b. Grundkurs Programmieren in Java) und Tutorials habe ich mehrere ganz gute Youtube Tutorial Serien gefunden. Die verbleibenden Fragen versuche ich dann hier zu stellen. Ich bin aber OO-mäßig auch noch ganz am Beginn.

2 Links noch, was die Youtube Reihen angeht. Wie gut die qualitativ sind, weiß ich auch nicht. Kannst ja mal selber hineinschauen.

https://www.youtube.com/playlist?list=PL71C6DFDDF73835C2

https://www.youtube.com/user/JavaTutorialsDE/videos?sort=dd&shelf_id=0&view=0

Ich finde übrigens die Hilfsangebote einiger Forenuser hier im Thread ganz schön nett, Hut ab!

Und der Tip, praktisch damit zu arbeiten, wäre auch mein Tip Nr. 1 gewesen. Das bringt am aller meisten.

f5


----------



## Toni32 (6. Mai 2015)

Ich glaube es fällt mir auch deshalb schwer, weil ich mich bisher nie mit dem OO Thema befasst hab. Zwar hab ich auch vorher mal ein wenig mit Programmiersprachen herumprobiert bin aber nie tiefer in die Materie eingestiegen. Aber da hatte man eben den Code und geht diesen von oben nach unten durch. Das ist auf den ersten Blick irgendwie leichter zu verstehen, als Klassen und Objekte.

Aber die Hilfe hier im Forum ist wirklich top!

Nochmal eine Frage, ich habe jetzt mal ein Beispiel selbst abgewandelt und so geschrieben:


```
class Sprecher{    
Sprecher s1;
Sprecher s2;
int zahl=0;

void aussprechen() {
    System.out.println("Guten Tag!");
    }
    
void zufallsZahl() {
    zahl = (int) (Math.random() *10);
    System.out.println("Zum" +zahl +".Mal");
    }
}

public class Testlauf {

    public static void main (String[] args) {
    Sprecher s1 = new Sprecher();
    Sprecher s2 = new Sprecher();
    int x =10;
    
    while (x>1) {
    s1.aussprechen();
    s1.zufallsZahl();
    x=x-1;
            }
    }
}
```

Die ersten zwei Zeilen "Sprecher s1" und "Sprecher s2" muss man nicht schreiben, in einem Beispiel habe ich es aber so gesehen. Wozu sind diese da?

s1 wird ja ein Objekt mit den Vorgaben der Klasse Sprecher durch die Zeile "Sprecher s1 = new Sprecher();"
Warum wird die Klasse dabei immer zweimal genannt und nicht einfach nur "s1 = new Sprecher();"


Gruß
Toni


----------



## stg (6. Mai 2015)

Nehmen wir den Ausdruck dafür mal auseinander. 
	
	
	
	





```
Sprecher s1 = new Sprecher();
```
 ist genau das gleiche, als würdest du schreiben 
	
	
	
	





```
Sprecher s1;
s1 = new Sprecher();
```
In der ersten Zeile deklarierst du einfach nur eine Variable vom Typ Sprecher mit dem Namen s1.
In der zweiten Zeile wird der Variable mit dem Namen s1 ein neues Sprecher-Objekt zugewiesen.

Hier bei diesem Beispiel erscheint das wirklich ein wenig sinnlos. Nun ist es aber so, dass alles, was du der Variable s1 zuweist auch tatsächlich ein Sprecher sein muss (weil die Variable als Typ Sprecher deklariert wurde), das was du zuweist, kann aber auch mehr sein, etwa ein Sprecher mit tollen zusätzlichen Eigenschaften.

```
Sprecher s1 = new GanzTollerSprecher();
```
Du weist hier der Variable vom Typ Sprecher nun ein Objekt vom Typ GanzTollerSprecher zu. Das geht, wenn der GanzTollerSprecher genau das gleiche machen kann, wie der normale Sprecher. GanzTollerSprecher IST_EIN Sprecher, aber umgekehrt Sprecher IST_NICHT_EIN GanzTollerSprecher...
 Das klingt zunächst vielleicht auch noch ein wenig sinnfrei, interessant ist das aber, wenn Funktionalität anders realisiert werden, auch wenn sie nach außen hin das gleiche Ergebnis liefern.

Zum Beipsiel Listen. Eine LinkedList und eine ArrayList sind beides Listen. Folgendes wären also beides möglich.

```
List l1 = new LinkedList();
List l2 = new ArrayList();
```
Gemeinsamkeit ist, dass du bei einer Liste z.B. auf das Element an einer beliebigen Stelle X in der Liste zugreifen kannst. Bei einer ArrayList erfordert dies eine konstante Zugriffszeit, unabhängig von der Größe der Liste, bei einer LinkedList wächst die Zugriffszeit im Mittel aber linear mit der Größe der Liste. Das kann sich im späteren Verlauf deutlich auf die Laufzeit des Codes auswirken. Da du aber von Anfang an nur gegen den allgemeinen Typ List programmiert hast, kannst du später ganz einfach den konkreten tatsächlich verwendeten Datentyp austauschen.


----------



## Toni32 (6. Mai 2015)

Ist Sprecher denn eine Variable UND eine Klasse? Ich dachte es wäre damit nur die Klasse gemeint und durch "Sprecher s1 = new Sprecher();" wird alles was in der Klasse Sprecher definiert wurde, (also z.B. die Methode Text auszugeben oder die int Variable "zahl" zu definieren) wird dadurch sozusagen auf das Objekt s1 aufgeprägt oder weitergegeben (wie das Beispiel mit der Kuchenform, Sprecher ist die Form, s1 der Kuchen).


----------



## fanta5 (6. Mai 2015)

Toni32 hat gesagt.:


> Ist Sprecher denn eine Variable UND eine Klasse? Ich dachte es wäre damit nur die Klasse gemeint und durch "Sprecher s1 = new Sprecher();" wird alles was in der Klasse Sprecher definiert wurde, (also z.B. die Methode Text auszugeben oder die int Variable "zahl" zu definieren) wird dadurch sozusagen auf das Objekt s1 aufgeprägt oder weitergegeben (wie das Beispiel mit der Kuchenform, Sprecher ist die Form, s1 der Kuchen).



Sprecher s1 = new Sprecher(); bedeutet (nach meinem Kenntnissstand):

Es wird eine neue Instanz vom Typ "Sprecher" gebildet (diese Instanz nennt man konkret Objekt -- es wird auf dem Heap liegen) und über die Referenz s1 kannst Du es ansprechen. Man möge mich korrigieren, wenn ich falsch liege...

f5


----------



## Saheeda (6. Mai 2015)

Sprecher ist NUR die Klasse, aber NICHT die Variable. Deine IDE sollte es dir sogar anmeckern, wenn du versuchst, Spieler als Variablennamen zu benutzen.

Wie du schon selbst geschrieben hast: Die Klasse ist die Kuchenform, s1 ein konkreter Kuchen, z.B. ein Schokokuchen.


----------



## Toni32 (6. Mai 2015)

Ok danke, dann hab ichs doch richtig verstanden.
Bin jetzt gerade dabei dieses Ratespiel aus dem Buch mal selbst umzuschreiben, in eine Lottoziehung 6 aus 49. Mal sehen wie weit ich komme.


----------



## KSG9|sebastian (7. Mai 2015)

So wie ich deine Fragen lese fehlen dir definitiv die Grundlagen. Gerade die Unterscheidung zwischen Klasse, Objekt, Variable, Methode, Typ ist absolut elementar. Wenn du das nicht verstanden hast brauchst du nicht weiter mit dem OO-Kapitel machen...


----------



## ARadauer (7. Mai 2015)

Das hört sich etwas krass an aber... sorry nicht jeder kann Programmieren lernen. Quäl dich nicht damit.
Das ist ok, man sieht das immer wieder bei Studenten. Manche quälten sich mit den einfachsten Beispielen, weil einfach eine gewisse Abstraktionsfähigkeit fehlt oder es einfach nicht klick macht.
Ist wie singen... im Grunde ist es nicht schwer, aber manche könnens einfach nicht. 


```
class Sprecher{    
Sprecher s1;
Sprecher s2;
int zahl=0;
```
Das "Ding" Sprecher hat zwei Sprecher?


----------



## fanta5 (7. Mai 2015)

ARadauer hat gesagt.:


> Das hört sich etwas krass an aber... sorry nicht jeder kann Programmieren lernen. Quäl dich nicht damit.
> Das ist ok, man sieht das immer wieder bei Studenten. Manche quälten sich mit den einfachsten Beispielen, weil einfach eine gewisse Abstraktionsfähigkeit fehlt oder es einfach nicht klick macht.
> Ist wie singen... im Grunde ist es nicht schwer, aber manche könnens einfach nicht.



Aaach, Vorsicht. Auch wenn Du natürlich grundsätzlich recht damit hast, kannst Du das nicht an 3-4 Posts eines Neulings hier fest machen. Schau Dir meine Posts hier mal an, das sieht auch teilweise unbehofen aus. Dabei habe ich durchaus richtig große Anwendungen modelliert, programmiert und implementiert. Also die ganze Palette, von der Planung bis zum Produktivprodukt. Aber eben prozedural. Und objektorientiert empfinde ich dennoch schwierig, wenn man damit beginnt. Ich kann mir gut vorstellen, dass das für wirkliche Programmiereinsteiger (ich zitiere Dich mal) "krass" ist. Das muß aber nicht zwingend heißen, dass das nichts werden kann (oder gar wird).

f5


----------



## Toni32 (7. Mai 2015)

Ich glaube mein Hauptproblem ist, dass ich von mir erwarte sehr schnell Ergebnisse zu liefern. Und wenn das Anfangs auch noch klappt, man dann aber hängen bleibt, werde ich sofort ungeduldig 

Aber heute hatte ich ein kleines Erfolgserlebnis, ich habe jetzt mal selbstständig ein "Lotto Programm" geschrieben, welches folgendes tun soll: 6 Zufallszahlen werden bestimmt, 6 Zufallszahlen getippt und nach x Durchläufen soll dann irgendwann angezeigt werden, dass man 6 Richtige hat und die Zahl der Durchläufe.

Ich bin mir ziemlich sicher, dass man das viel eleganter und wohl auch kürzer schreiben kann, aber dafür kenne ich noch nicht genug Befehle.
Vor allem gibt es das Problem, dass Zahlen mehrfach vorkommen können, dass könnte man verhindern, in dem man nochmal eine if-Anweisung einfügt (wenn Zahl schon vorkommt, nochmal eine neue generieren). Ich glaube aber dass es da auch irgendwie eine bessere Lösung für gibt.

Wäre dankbar für Tipps, was man verbessern könnte, auch was die einzelnen Klassen und die Aufteilung des Codes untereinander angeht. Vielleicht ist das ja auch alles lächerlich kompliziert geschrieben und viel einfacher zu realisieren (Vor allem die If-Anweisung, die immer mit allen Zahlen einzeln vergleicht.


```
class Spielstarter {    
    public static void main(String[]args){
    
    Spieler spieler1 = new Spieler();
    Ziehung ziehung = new Ziehung();
    
    boolean sechsRichtige=false;
    int count=1;
    
    while (sechsRichtige==false) {
    
    spieler1.tippen();
    ziehung.ziehen();
    
    boolean tipp1Richtig=false;
    boolean tipp2Richtig=false;
    boolean tipp3Richtig=false;
    boolean tipp4Richtig=false;
    boolean tipp5Richtig=false;
    boolean tipp6Richtig=false;
        
    count=count+1;
        
    if (spieler1.tipp1==ziehung.zahl1||spieler1.tipp1==ziehung.zahl2||spieler1.tipp1==ziehung.zahl3||spieler1.tipp1==ziehung.zahl4||spieler1.tipp1==ziehung.zahl5||spieler1.tipp1==ziehung.zahl6) {
        System.out.println("1. Zahl richtig getippt!");
        tipp1Richtig=true;
    }
    if (spieler1.tipp2==ziehung.zahl1||spieler1.tipp2==ziehung.zahl2||spieler1.tipp2==ziehung.zahl3||spieler1.tipp2==ziehung.zahl4||spieler1.tipp2==ziehung.zahl5||spieler1.tipp2==ziehung.zahl6) {
        System.out.println("2. Zahl richtig getippt!");
        tipp2Richtig=true;
    }
    if (spieler1.tipp3==ziehung.zahl1||spieler1.tipp3==ziehung.zahl2||spieler1.tipp3==ziehung.zahl3||spieler1.tipp3==ziehung.zahl4||spieler1.tipp3==ziehung.zahl5||spieler1.tipp3==ziehung.zahl6) {
        System.out.println("3. Zahl richtig getippt!");
        tipp3Richtig=true;
    }
    if (spieler1.tipp4==ziehung.zahl1||spieler1.tipp4==ziehung.zahl2||spieler1.tipp4==ziehung.zahl3||spieler1.tipp4==ziehung.zahl4||spieler1.tipp4==ziehung.zahl5||spieler1.tipp4==ziehung.zahl6) {
        System.out.println("4. Zahl richtig getippt!");
        tipp4Richtig=true;
    }
    if (spieler1.tipp5==ziehung.zahl1||spieler1.tipp5==ziehung.zahl2||spieler1.tipp5==ziehung.zahl3||spieler1.tipp5==ziehung.zahl4||spieler1.tipp5==ziehung.zahl5||spieler1.tipp5==ziehung.zahl6) {
        System.out.println("5. Zahl richtig getippt!");
        tipp5Richtig=true;
    }
    if (spieler1.tipp6==ziehung.zahl1||spieler1.tipp6==ziehung.zahl2||spieler1.tipp6==ziehung.zahl3||spieler1.tipp6==ziehung.zahl4||spieler1.tipp6==ziehung.zahl5||spieler1.tipp6==ziehung.zahl6) {
        System.out.println("6. Zahl richtig getippt!");
        tipp6Richtig=true;
    }
    
    if (tipp1Richtig==true&&tipp2Richtig==true&&tipp3Richtig==true&&tipp4Richtig==true&&tipp5Richtig==true&&tipp6Richtig==true) {
    System.out.println("6 RICHTIGE!!!  im" +count+".Durchlauf");
    sechsRichtige=true;
        }
    
    }
    
        }
    }
                    
class Ziehung {
    
    int zahl1, zahl2, zahl3, zahl4, zahl5, zahl6;
    
    void ziehen() {
    zahl1 = (int) (Math.random()*49+1);
    zahl2 = (int) (Math.random()*49+1);
    zahl3 = (int) (Math.random()*49+1);
    zahl4 = (int) (Math.random()*49+1);
    zahl5 = (int) (Math.random()*49+1);
    zahl6 = (int) (Math.random()*49+1);
    System.out.println("Gezogen wurden:" +zahl1+" "+zahl2+" "+zahl3+" "+zahl4+" "+zahl5+" "+zahl6);
    }
}    


class Spieler {
    
    int tipp1, tipp2, tipp3, tipp4, tipp5, tipp6;
    
    void tippen() {
        tipp1 = (int) (Math.random()*49+1);
        tipp2 = (int) (Math.random()*49+1);
        tipp3 = (int) (Math.random()*49+1);
        tipp4 = (int) (Math.random()*49+1);
        tipp5 = (int) (Math.random()*49+1);
        tipp6 = (int) (Math.random()*49+1);
        System.out.println("Getippt wurden:  "+tipp1+ " "+tipp2+" "+tipp3+" "+tipp4+" "+tipp5+" "+tipp6);
    }
    
}
```


----------



## Saheeda (7. Mai 2015)

Schau dir mal Arrays oder Listen an. 6 Elemente per Hand zu schreiben, geht noch irgendwie, 100 oder mehr willst du definitiv nicht alle einzeln schreiben.


----------



## Gucky (7. Mai 2015)

Ja die bessere Lösung gibt es: Du schreibst alle Zahlen in ein Array, greifst zufällig auf dieses Array zu und setzt die gezogenen Zahlen auf 0. Wenn ein Zugriff eine 0 ergibt, generierst du einen neue Zahl oder du arbeitest mit Listen, was weniger performant ist aber dafür besser aussieht.
Allerdings kämen dafür wieder mindestens eine Sache hinzu: Arrays, deren Anwendung gar nicht so einfach ist oder Listen, die Klassen und Objekte fremder Programmierer sind.

Ich habe einmal zu Lehrzwecken ein Programm zusammengeschrieben, in dem Schleifen, Methoden, ifs, eine API Klasse und Arrays enthalten sind. Es ist eine Art erweitertes Hallo Welt Programm. Vielleicht hilft es dir:


```
import java.util.Random;

public class Lotto { //Klassendefinition Lotto
	private int[] zahlen; //neue, jedoch noch nicht belegte Variable vom Typ int Array
	
	public Lotto(){ //Konstruktor von Lotto
		zahlen = new int[49]; //zahlen wird mit einem int Array der Länge 49 belegt
	}
	
	public int[] machLotto(){//eine Methode zum erfragen der gezogenen Lottozahlen
		initZahlen();
		return zieheZahlen();
	}
	
	
	private int[] zieheZahlen(){//eine Methode zum Ziehen von Zahlen. Wurde eine Zahl gezogen, wird sie auf 0 gesetzt und somit "gelöscht"
		int[] gezogen = new int[9];
		int anzGezogen = 0;
		Random rand = new Random();
		int aktIndex = 0;
		for (int i = 0; i < 9; i++){
			do{ //mach mindestens ein mal
				aktIndex = rand.nextInt(49);
			} while (zahlen[aktIndex] == 0); //aber so lange, wie das hier erfüllt ist
			gezogen[anzGezogen] = zahlen[aktIndex];
			anzGezogen += 1;
			zahlen[aktIndex] = 0;
		}
		return gezogen; //gibt gezogen an den Aufrufer zurück. Dabei wird nur die Variable übergeben (also ein Schild, auf dem steht, wo das Array zu finden ist)
	}
	
	private void initZahlen(){ //eine Methode zum initialisieren des Arrays
		for (int i = 0; i < zahlen.length; i++){
			zahlen[i] = (i + 1);
		}
	}
	
	public static void main (String args[]){//der Einstiegspunkt des Programmes
		Lotto lot = new Lotto();
		int[] zahlen = lot.machLotto();
		for (int zahl : zahlen){
			System.out.print(" " + zahl);
		}
	}
}
```


----------



## Dompteur (8. Mai 2015)

@TE:
Ich weiß nicht, ob du bei deiner Einarbeitung in die Sprache schon die Container durchgemacht hast.

Wenn nicht, dann heb dir dieses Beispiel auf, bis du das Set-Interface durch hast. Danach implementier es neu.
Du wirst sehen, wie du durch die Wahl der richtigen (verfügbaren) Klassen, deine Arbeit erleichtern kannst und dein Code auf wenige Zeilen schrupften wird.


----------



## Toni32 (8. Mai 2015)

Danke schon mal für die Tipps.
Da ist natürlich noch eine Menge drin, was ich noch nicht nachvollziehen kann, aber ich hoffe das kommt noch.

Ist mein Code was die Objektorientierte Strukturierung angeht denn soweit ok? In den Beispielen im Buch wird die main Methode nämlich meist nur verwendet, um die Anwendung zu starten, sonst steht da nichts drin.

Wo ich das größte Problem mit habe, ist einen richtigen Anfang zu finden, sowohl beim Schreiben als auch beim Lesen. 

Wenn ich z.B. irgendwas fertig habe, wie das Lottoprogramm, dann muss ich schon am nächsten Tag wieder überlegen was jetzt nochmal welche Funktion wie und wo abruft, da die Klassen ja alle miteinander verknüpft sind.
Methode "ziehen", wo war die noch und was macht die nochmal? Ach ja da unten in der Klasse! Und wo kommt die andere Zahl jetzt nochmal her? Ah da oben! Und was war das andere noch?

Und schon wirds immer komplizierter und ich verliere den Blick fürs Ganze.
Gibts da einen Trick, wie geht ihr vor, bzw. wie fangt ihr an zu schreiben/zu lesen?


----------



## Saheeda (8. Mai 2015)

Vieles ist Übung.
Aber meine Klassen sind z.B immer ähnlich aufgebaut.
Ganz oben die Instanzvariablen, darunter Konstruktoren, wobei ich die gern nach der Anzahl der Parameter sortiere. Darunter stehen die Methoden in der Reihenfolge ihrer Aufrufe. Wenn ich z.B in Methode A auf Werte aus Methode B zugreife, steht A weiter oben als B.

Dann sollten die Methoden natürlich auch logisch in die Klasse passen. "SagDasWetter()" hat innerhalb einer Lottoziehung nichts verloren. Eine klare Benennung hilft auch ungemein. Int a, int b, String text sind ganz doofe Namen.

Du kannst dir auch alle Methoden dokumentieren, indem du drüber schreibst, was sie tut, was sie erwartet und zurück gibt.

Und zu guter Letzt: Wenn eine Variable nur ein einziges Mal irgendwo auftaucht, definiere die auch in der Methode und nicht im "Klassenrumpf".


----------



## Gucky (8. Mai 2015)

Zum Dokumentieren gibt es JavaDoc. Guck dir das mal an. Viele IDEs unterstützen das auch, sodass du nur mit dem Mauszeiger über einen Methodenaufruf gehst und dann wird die schon angezeigt, was im JavaDoc zu dieser Methode steht.


----------



## coco07 (9. Mai 2015)

Wenn du weitere Hilfe benötigst, darfst du mir auch gerne eine PN schicken. Ich helfe gerne auch per Messenger.. 


Grüße Fabian!


----------



## Toni32 (17. Mai 2015)

Ich habe in der letzten Woche nochmal viel gelesen und das mit den Objekten und Klassen auch endlich richtig kapiert 

Ich habe nur immer noch Probleme "Im Kopf" zu compilieren. Also Code zu schreiben und vor allem zu lesen und zu wissen was am Ende herauskommt, die ganzen Variablen, Methodenaufrufe, Schleifen usw., könnt ihr das eigentlich so einfach, durchlesen und man weiß was herauskommt? Vielleicht fehlt mir auch einfach noch die Übung, hoffe ich jedenfalls.

Aber nun was anderes, ich versuche gerade mein Lottoprogramm mal verbessern und mit Arrays zu versehen und habe dabei das Problem einen "ArrayIndexOutOfBoundsException" Fehler zu bekommen.


```
class Ziehung {

public void ziehen(){

int[] alleZahlen = new int[49];
int[] gezogeneZahlen = new int[6];
int a = 0;                            //Indexzahl für gezogeneZahlen Array
int x;

for(int i=0; i<49; i++) {        // Array mit 49 Zahlen erzeugen
alleZahlen[i]=i+1;
}


for (int j=0; j<6; j++) {
    x = (int) (Math.random() *49);   // x zieht eine Zufallszahl aus dem Array
    gezogeneZahlen[a]=alleZahlen[x];
    a=a+1;
    }
    
    
    for (int k=0; k<gezogeneZahlen.length; k++){
    System.out.print(gezogeneZahlen [a] +" " );
        }
        
    }
}


class Ausfuehrung {

public static void main(String[]args){

Ziehung z = new Ziehung();
z.ziehen();
    }
}
```

x ist eine Zufallszahl aus dem 49'er Array, diese soll in das Array gezogeneZahlen geschrieben werden, welches in der for Schleife mit 0 anfängt und dann um jeweils +1 erhöht wird. 
Kann mir jemand sagen wo da bei mir der Fehler liegt?


----------



## Saheeda (17. Mai 2015)

Du solltest dein Lottospiel vielleicht in ein eigenes Thema auslagern, das hat nicht mehr so viel mit deiner Ausgangsfrage zu tun.


Zum Lottospiel:
IndexOutOfBounds heißt, dass du auf eine Stelle zugreifen möchtest, die nicht existiert.

In der 2. for-Schleife erhöhst du a schrittweise um 1, nach der letzten Iteration hat a also den Wert 6.

In der 3. for-Schleife greifst du jetzt auf gezogeneZahlen[6] zu. Da dieses Array aber nur 6 Felder lang ist und man bei 0 anfängt zu zählen, hat der letzte Eintrag den Index 5.


----------



## Tobse (17. Mai 2015)

> Ich habe nur immer noch Probleme "Im Kopf" zu compilieren. Also Code zu schreiben und vor allem zu lesen und zu wissen was am Ende herauskommt, die ganzen Variablen, Methodenaufrufe, Schleifen usw., könnt ihr das eigentlich so einfach, durchlesen und man weiß was herauskommt? Vielleicht fehlt mir auch einfach noch die Übung, hoffe ich jedenfalls.



Das kommt mit der Zeit, keine Bange. Ich programmiere jetzt schon seit mehr als 6 Jahren fast täglich; Wenn ich (oder irgendjemand anderes mit änlicher Erfahrung, hier im Forum sind einige unterwegs) 100 Zeilen Code schreibe, dann weiss ich vor dem ersten compilieren ziemlich genau, was am Ende bei rauskommt.

Bei fremden Code kann ich (klare strukturen und aussagekräftige Kommentare an den wichtigen Stellen vorrausgesetzt) den meissten Code nach dem zweiten oder dritten mal lesen auch ziemlich treffsicher voraussagen.

Je mehr du übst desto mehr gehen dir die Basics, die dir gerade erarbeitest, in Fleisch und Blut über. Und dann ist das verstehen von Code irgendwann nurnoch eine Sache der Konzentration.


----------



## Toni32 (18. Mai 2015)

Ab wann sollte man sich eigentlich mit einer IDE wie Eclipse beschäftigen?
Ich nutze bisher ausschließlich Notepad++, in vielen Tutorials wird auch von den komplexen IDE's als Anfänger abgeraten.


----------



## stg (18. Mai 2015)

Toni32 hat gesagt.:


> Ab wann sollte man sich eigentlich mit einer IDE wie Eclipse beschäftigen?



Ab dem Zeitpunkt, an dem man es auch ohne könnte, wenn man müsste


----------



## Gucky (19. Mai 2015)

Ich programmiere nun seit ungefähr zwei Jahren erst schulisch und jetzt hobbymäßig und ich habe gleich mit eclipse angefangen. Ich hatte nie Probleme damit oder sonst irgendwelche Schwierigkeiten.
Die verbreitete Meinung ist aber, dass erst Java und dann eine IDE kommt. Der Meinung bin ich jedoch nicht.


----------



## stg (19. Mai 2015)

Gucky hat gesagt.:


> Ich programmiere nun seit ungefähr zwei Jahren erst schulisch und jetzt hobbymäßig und ich habe gleich mit eclipse angefangen. Ich hatte nie Probleme damit oder sonst irgendwelche Schwierigkeiten.
> Die verbreitete Meinung ist aber, dass erst Java und dann eine IDE kommt. Der Meinung bin ich jedoch nicht.



Eine IDE nimmt einem ja auch eine Menge ab und erleichtert die Arbeit ungemein. Ich will nicht pauschal sagen, dass es keine gute Idee ist, direkt mit einer gescheiten IDE einzusteigen. Jedoch weiß man diese gerade zu Beginn auch eigentlich gar nicht so recht zu benutzen und wird von der Fülle an Möglichkeiten nahezu erschlagen und weiß gar nicht, was das alles überhaupt sein soll 

Ich bin jedoch hartnäckiger Vertreter der Meinung, dass man zum Einstieg ausschließlich kleine, einfach Konsolenanwendungen schreiben sollte, und dafür braucht man wirklich keine IDE. Sofern man hier ohne IDE arbeitet versteht man dann meiner Meinung nach auch besser grundlegende Dinge, wie etwa den Compile/Build-Vorgang, package-Strukturen usw.. und ohne IDE ist man gezwungen "ordentlichen" Code zu schreiben, wenn man sich später noch zurecht finden will 

Wenn die grundlegenden Dinge sitzen und man _dann_ in die GUI- oder Enterprise-Entwicklung einsteigen möchte, _dann_ ist eine gescheite IDE unabdingbar, aber auch erst dann. 

Genauso, aber das ist schon wieder ein anderes Thema (aber die gleiche Problematik), sollte niemand, der nicht wenigstens einmal eine komplette Liste, HashMap usw selbst programmiert hat, die fertigen Implementierungen benutzen...


----------



## Gucky (19. Mai 2015)

Ich kann nur mich selbst als Beispiel nehmen und mein erstes Programm war ein Smiley in AWT.
Dann kam ein Gitter und ein Kreis, der sich darin bewegen kann und dann eine einfach verkettete Liste. Ich habe noch nie in Java eine Konsolenanwendung programmiert und ich würde das nicht als Nachteil bezeichnen.

Ein Beispiel: Um Auto zu fahren muss ich nicht wissen, wie der Motor funktioniert sondern nur wo die Pedalen sind und wo der Schalthebel ist. Wenn mir Autofahren und Autos allgemein Spaß machen, kommt das Ganze von allein, weil ich daran rumschrauben werde, ich werde kleinere Mängel selber beseitigen und irgendwann könnte ich den Motor selber bauen.
Wenn ich allerdings zuerst den Motor verstehen muss, bevor ich fahren darf, würde mich das abschrecken.


----------



## stg (19. Mai 2015)

Das Resultat ist dann aber auch, um bei deiner Analogie zu bleiben, dass gleich der Pannendienst gerufen wird (hier in Form von haarsträubenden Forenbeiträgen), obwohl nur Öl nachgefüllt werden müsste. Manch einer kauft dann sogar gleich ein ganz neues Auto, auch wenn nur die Reifen abgefahren sind 
Und eine IDE wie Eclipse oder NetBeans ist dann vielleicht doch noch eher mit nem Flugzeug-Cockpit vergleichbar, in dem man pllötzlich sitzt..

Klar, sicher verstehe ich deinen Standpunkt und das kann natürlich auch gut gehen, aber die Erfahrung zeigt doch ... blablabla ... ich will gar nicht genau wissen, wie oft ich hier schon Fragen von Leuten gesehen habe, die sich ohne gefestigte Grundlagen an fortgeschrittene Themen gewagt haben und dann an einfachsten Dingen gescheitert sind, wie z.B. Namenskonflikte, Fließkommaarithmetik, Unterschied zw. Identität und Gleichheit, ExceptionHanling usw... 

Klar, man muss nicht wissen, wie ein Motor im Auto genau funktioniert, aber man sollte wenigstens wissen, dass es einen Motor gibt und wofür er da ist. Außerdem die grundlegenden Verkehrsregeln und auch, dass ein Auto Benzin, Öl usw braucht..  

Naja, zusammengefasst: Kann gut gehen und manch einer wird vielleicht auch Berufskraftfahrer, aber die meisten landen dann doch immer wieder im Straßengraben


----------



## Gucky (19. Mai 2015)

Dann halten wir fest, dass ich anscheinend ein überragendes Ausnahmetalent bin. 

Das Problem mit den haarsträubenden Forenbeiträgen kenne ich leider zu gut.

Dann sollte man aber zumindest Programme mit Syntaxhighlighting und vielleicht JavaDoc verwenden.


----------



## fanta5 (19. Mai 2015)

Hi,

ich habe Java ja auch erst vor ein paar Wochen angefangen und hab mir gleich Eclipse hergenommen. Und ich bin ausgesprochen begeistert von Eclipse, ich hatte selten so wenig Einstiegsprobleme, was eine neue umfangreichere Software angeht, wie mit Eclipse.

f5


----------



## LionAge (22. Mai 2015)

Zum Thema IDE kann ich auch nur sagen, ist vielleicht einfach Geschmackssache. Ich programmiere unter linux gerne mit Geany, man hat nicht zu viel SchnickSchnack für den Anfang und muss manchmal selber noch etwas mehr nachdenken, was einen so ein bischen am "rumprobieren ohne nachzudenken" hindert. Und man muss gerade wo am Anfang die Programme ja doch recht klein sind, nicht jedes mal erst ein Projekt erstellen etc... aber wie gesagt, Geschmackssache.

Zum Üben des erlernten Wissen, sei es durch ein Buch oder durch Video-Tutorials kann ich auch wirklich nur Seiten wie:
Java Tutorial interaktiv - Programmieren lernen mit Java
project-euler.net

empfehlen. Dort kann man das gelernte nochmal anhand von Programmieraufgaben üben, denn ohne selber programmieren wird man es nicht lernen.

use it, or loose it


----------



## kaoZ (23. Mai 2015)

Bevor du anfängst irgendwelche Beispiel Aufgaben umzuschreiben solltest du dich mit den absoluten Basics auseinandersetzen.... das was du da machst schlägt schon im Ansatz fehl.......

- Was sind Klassen, was sind Objekte, Datentypen, primitive Datentypen..... Attribute und Eigenschaften, wie erstelle ich eigene Methoden, wozu dienen diese bzw. was kann ich damit machen ? Vererbung und Polymorphie.... all diese Dinge würde ich mir einprägen bevor ich anfangen würde irgendwelche Beispielaufgaben umzuschreiben.

Bilde erst einmal ein Grundverständniss dafür worum es in der OO Programmierung geht, und wenn das vorhanden ist geht das ganze fast wie von selbst !

Sicher lernt man am besten Programmieren wenn man eben Programmiert, allerdings musst du halt erstmal verstehen wie sich das in der OO Welt verhält, und wann du was nutzten musst, wie z.B Interfaces oder Abstrakte Klassen und wann diese dann wirklich Sinn machen.....

Wichtig ist für den Einstieg auf jeden Fall erstmal zu wissen das du alles, egal ob Real oder Fantasie auf Objekte abbilden kannst, egal ob es ein Auto, eine Person oder ein Raumschiff ist....... Klassen sind dabei der Bauplan und umschreiben/legen Fest welche Eigenschaften und Funktionen die Entitäten (Dinge) dann später haben müssen.


----------



## fanta5 (24. Mai 2015)

kaoZ hat gesagt.:


> Wichtig ist für den Einstieg auf jeden Fall erstmal zu wissen das du alles, egal ob Real oder Fantasie auf Objekte abbilden kannst, egal ob es ein Auto, eine Person oder ein Raumschiff ist....... Klassen sind dabei der Bauplan und umschreiben/legen Fest welche Eigenschaften und Funktionen die Entitäten (Dinge) dann später haben müssen.



Diesen Satz halte ich für gleichermaßen wichtig wie auch schwierig. Und hier habe ich auch meine größten Problemchen, was OO angeht.

Um den Thread mit meiner nachfolgenden Frage nicht völlig zu verunstalten, mache ich mal einen neuen Thread hierfür auf...

f5


----------

