FreitagsrundenWiki - Benutzerbeiträge [de]

Martin Häcker/Java Kurs/Tag 1

2006-03-17T15:00:59Z

Schneider: /* LE 2: Methoden und Schleifen (RobertB und Sven) */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 1: Hello, World! =
'''Vortragende:''' Robert Lubkoll, Felix Schwarz

== Organisatorisches ==
* Was Passiert
* Wann passiert was
* Wie passierts
* Vorstellung
* Was ist das genau
* Wer sind wir: Freiwillig, Umsonst
* Ziel des Kurses
* Was sie am Ende können sollen
* Gruppeneinteilung
** am Ende der ersten Vorlesung
** Vorher per e-mail
'''Jemand vom Rechnerbetrieb soll bitte da sein, damit wir Login-Probleme lösen können'''

== Inhalt (Vorgehen, Beispiele, Ideen) ==
=== Methodik ===

Was ist '''Programmieren?'''
* Lernende einbeziehen durch Befragung mit Zetteln, was sie sich vorstellen unter "Programmieren"
* (Ideen gesucht die nicht zu abstrakt sind) imperativ (prozedural) vs. funktionales Programmieren
** (Ideen gesucht die nicht zu abstrakt sind) relation problem <-> lösung / kochrezept
* Zustandsmaschine, (jede Befehlsausführung führt zu einem neuen Zustand)

* Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")
* TODO: zu etwas das wir einführend sagen können umformulieren.
** ''Damit ist die Philosophie von Programmieren gemeint''

*eher später, wird vom Prinzip her aber in dieser Reihenfolge eingeführt:
Drei Dinge, die wichtig sind für Programmierer (Das soll sich durch den Kurs durchziehen als roter Faden für die Sprachfeatures die wir einführen):
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

=== Java ===
==== Wie fangen wir Java an ====
* Live vorführen (Screenshots oder zur Console wechseln)

* Kommentare //, /* */, /** */
* Hello world
grobe Struktur der "Umgebung": keine .sig/.impl Datei sondern nur eine .java

system.out.println();

* compilieren:
Was passiert da, wieso erst Compilieren, dann ausführen?
javac
java

was für Fehler können auftreten?
.class
Klasse heißt anders als Datei
Compiler falsch aufgerufen

* Variablentyp (int) -> Syntax der Deklaration
Wie darf ein Variablenname aussehen? (Buchstaben,Zahlen, _ )
* Zuweisung -> Syntax
man kann Zahlen > 32 direkt eingeben !

* Werte und operatoren +,*,- -> Syntax
int zahl1 = 7;
int zahl2 = 42;
int ergebnis = zahl1 + zahl2;
System.out.println(ergebnis);

Zuweisung nach Deklaration.
Variableninhalte ändern sich durch Zuweisung. Zeigen mit sysout.

Selbse GANZ kurz nochmal mit anderen Operatoren.

* String: Vormerken, das man hier später klar macht das das auch Objekte und daher Referenzen

sind - erstmal ists aber egal, da sie eh Immutable sind

String deklarieren mit "bla" , kein Anführungszeichen im "..."

verknüpfen von Strings (+)

komplizierteres Sysout an selbem Programm

* boolean (true/false)

* if -> Syntax
Minniprogramm zur Fallunterscheidung
boolean auwahl = true;
if(auswahl) then {
System.out.println("auswahl war true");
else{
System.out.println("auswahl war false");
}

erweitertes Minniprogramm zur Fallunterscheidung
* <, >, ==, <=, >= Operatoren die boolean zurückliefern
if mit Operatoren und anderen Variablen
* Kompliziertere Bedingungen (&&, ||, !)

*(double) mit Punkt als Trennzeichen.

*Division mit / und das bei int gerundet wird

*Semikolons, Kommentare

==== Vorführung ====
'''Aufbau eines Java-Programms'''

Ein Beispiel bringen und daran erklären, was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind. Das Programm dabei langsam entwickeln und dabei vorführen. Ziel ist, das am schluss ein komplettes Beispiel da steht - also alles verwendet wird was wir erklärt haben, es aber trotzdem so einfach bleibt das es ohne viel Fehlerpotenzial später nachgemacht werden kann.
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}

=== Methodik ===

'''Sauberes Programmieren'''
* Variablen und Identifier-Namen
** Variablendeklaration - Namen vergeben für Dinge, die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 scrollen bis '''Local Names''']

'''Fehlermeldungen lesen und verstehen'''
* Klammer vergessen
* Semikolon vergessen
* Klasse heißt anders als Datei
* Compiler falsch aufgerufen

== Übungsaufgaben ==

* ''cd'' üben
* Hello World eintippen (kate, gedit, nano, ..)
* javac / java benutzen
* Ergebnisse sehen
* Fehler einbauen, Fehler finden (laufzeit/compilezeit)
* Einige Expressions angeben und die Teilnehmer sollen feststellen, was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

=== Zusätzliche Vorschläge ===
Folgendes sollte in der VL oder Übung angesprochen werden:
* [http://www.scit.wlv.ac.uk/cbook/chap5.dangling.else.html "Dangling else"-Problem]
* Semikolon hinter if (hab gelesen, dies sei ein häufiger Fehler bei Anfängern...)
-- [[Benutzer:Buchholz|Robert Buchholz]] 01:17, 17. Mär 2006 (CET)

= LE 2: Methoden und Schleifen (RobertB und Sven) =
LE2 Übung mit Zusatzaufgaben und Musterlösung und Vorlesungsfolien [http://user.cs.tu-berlin.de/~svens/files/le2.tar.gz link]

letzte änderungen: folien version1 enthalten (freitag 2006-03-17 10:44)

TODO:
* LE1 aufgabe benutzen. (delayed)
* for schleife einbauen in die folien
* testen in die folien reinbauen
* for schleife in der musterlösung verwenden

Benötigete Zeiten:

<noch niemand hats probiert?>

== Inhalt ==
=== Methodik ===
* Wichtigkeit, dass man Programme in verständliche und sinnvolle Teile unterteilt:
** dadurch verbesserte test-möglichkeiten (sprich methoden sind auch eine art von modul)
** verbesserte verständlichkeit([http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions])
* Quelltextverkürzung durch schleifen
** nicht minimierung auf kosten der verständlichkeit
** was ist aufgabe des entwicklers?
** und was ist aufgabe des compilers? (vllt. auch nicht?)
** evtl. ist eine eigene methode sinnvoller/verständlicher?

=== Java ===
* '''Typen'''
** Arrays
*** warum, wie und probleme
** void
** char?

* '''Methoden''':
** Namen
** Aufruf
** Parameter und Rückgabe -> Call by Value
** main
** return
** Nachtrag Datenstrukturen: void
** Beispiel: System.out.println()

* '''Schleifen'''
** Blöcke
** while
*** Formulieren von Bedingungen
*** Schleife als zweite Lösung für duplikation von Code
*** Diskussion Schleife <-> Rekursion

* Anwendung von Schleifen
* Rekursion <-> Schleifen (Beispiel)
* Warum/wann Schleifen?
** als Alternative zu Akkumulator Parametern (Vergleich zu OPAL)
** wenn die Anzahl der Durchläufe nicht konstant ist
** for schleife, wann und wozu, einfache beispiele: for(int i = 0; i < 3; i++)

* '''Gute Namen'''
** Abstrakter Gedanke: Für den Computer ists wurscht, wie man das was man meint aufschreibt. Wir Menschen dagegen lassen und leicht verwirren
** abwägen zwischen
*** aussagekraft des namens
*** häufigkeit im code
*** kommentar zu variable(nnamen)
*** länge des namens

* '''Testen'''
* was ist testen?
** überprüfung von einigen randwerten => nachdenken ist erforderlich um interessante fälle zu finden
** testen ist nicht verifizieren
* wie in java?
** System.out.println(..);
** auskommentieren und schrittweises testen
* was wird getestet?
** ausgabe von arrays komplex
** ausgabe von werten mit text verknüpfen
** Variablen haben unterschiedliche Werte während das Program läuft!

assert-Methode selber schreiben -> Später! (WANN?)

== Übungsaufgaben ==

* Methoden definieren, die bestimmte Eigenschaften haben
* Beispiele dann Abtippen und ausprobieren
* Sie sollen Nachfragen, wenn sie was anderes hatten (oder sowas)
* Verschiedene Eingabewerte
* erste Endlosschleife
* Fehler für die eingeführten elemente

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 4

2006-03-17T14:00:06Z

Schneider: /* Tag 4 */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= Tag 4 =

'''Komplexe Projektaufgabe als Gruppenarbeit'''

* '''Vorschlag A''': Verschlüsselung:
** Häufigkeitsanalsyse -> dann entschlüsseln, doublettenhäufigkeit, triplettenhäufigkeit
** Caesar Chifre, entschlüsseln, verschlüssseln
** Gegenseitig Verschlüsselte Texte vorgeben

* '''Vorschlag B''': Terminplaner

* '''Vorschlag C''': Schiffe Versenken

* '''Vorschlag D''': Studentenverwaltung
** ein tool mit dem man
*** studenten in gruppen verwalten kann
*** den studenten gruppenweise noten geben kann
*** für jeden studenten eine statistik in eine datei schreiben kann
*** die daten in einer datei speichern und aus einer datei laden kann
*** = vorgabe GUI

*'''Vorschlag E''': vier gewinnt
**ein spiel
*** vier gewinnt
*** highscores
*** andere scores
*** = vorgabe GUI
*** = vorgabe evtl. billige KI die man evtl. im netz findet?

*'''Vorschlag F''': eine netzwerk simulation
** routing:
*** alle nodes broadcasten entlang ihrer links ins netz mit einer nachrichten-ID
*** die erste nachricht dieser node wird mit den entlang des pfades hinzugefügten nodes in einer routing tabelle statisch eingetragen
*** falls eine node ausfällt wird dies von einer node die dies feststellt ins gesamte netz gebroadcastet
*** wenn eine nodeA an eine nodeB etwas schicken will schickt sie dies an die node die in ihrer routing tabelle dieser node zugeordnet ist, diese schickt die daten dann weiter
** für jeden link wird eine fehlerwahrscheinlichkeit eingetragen
** die daten müssen geschützt werden..
** am besten mit CRC
** weiterhin könnte man die daten bitweise verschicken und eine weile im medium belassen und so eine propagation time ins spiel bringen
** damit würden die links verschiedene qualitäten aufweisen
** = vorgaben GUI zur anzeige des netzwerks
** = das ganze müsste ja leider threadbased sein..
** = vorgaben CRC?
** zu schwer vom verständnis?

*'''Vorschlag G''': kratives zeichnen
** man gibt ihnen eine GUI auf der sie einfach pixel linien und kreise zeichnen können
** dann sollen sie möglichst kreativ irgendwelche styles darauf malen
** irgendwelche effects?
** für sowas braucht man schleifen evtl. arrays. da kann man ganz kreativ sein (was für einige leider nix ist)
** = vorgabe: GUI und interface zum malen

*'''Vorschlag H''': eine fractal-application ähnlich der aus info1
**= vorgabe: GUI und so
**zu wenig für sie zu tun?

*'''Vorschlag I''': auswerter aussagenlogischer formeln
** parsen einer DNF/KNF oder noch komplexerer logischer formeln und wahrheitswert bei (einer/allen) wahrheitsbelegung(en) untersuchen

*'''Vorschlag J''': textadventure
**ein textadventure programmieren,
**das über schnittstellen funktioniert und
** wobei dann die ergebnisse aller gruppen die fertigwerden zusammengefügt werden können

= Abschlussveranstaltung =
* Beste Lösung vorstellen
* Schaum-Schokoladen-Küsse austeilen....
* Abschließen
* Feedback einsammeln
* Ausblick
* Anbindung an die Veranstaltung Info 2

= Vielleicht noch =

= Robust Programmieren =
Vielleicht zu fortgeschritten.... Siehe auch [[Vortrag_Exceptions | unser alter Vortrag zu Exceptions]]

'''Idee von Robuster Programmierung'''
* wie kann man mit fehlern umgehen
** fehler(un)freundliche systeme (Flugzeug, Auto)
** bandbreite der fehler von lethal bis nervig, bis "man kann daraus etwas lernen" (feedback?)
** Folgekosten abschätzen
* was will man eigentlich:
** etwas für die Benutzer tun
** diese in die Lage versetzen Selbst etwas zu tun
** Das ist eine Grundsätzliche Frage die man sich bei Software (und in der tat überall) stellen muss. Gleichzeitig ist das auch das Ziel einer persönlichen Weiterentwicklung, die sich eben auch (tja) in der Software die man schreibt wiederspiegelt.

'''Problemraum'''
* Welche Fehler behandelt man?
* welche gibt man an Benutzer weiter?
* wie macht man das? (Schöne Dialogtexte, Gute Klare Fehlermeldungen)
** Apple HIG schreibt: "Provide useful error messages to users when something does go wrong. An error message should clearly convey what happened, why it happened, and the options for proceeding. Offer a workaround if one is available and do whatever you can to prevent the user from losing any data. See "Alerts" for more information on how to provide useful error messages." Siehe auch: [http://developer.apple.com/documentation/UserExperience/Conceptual/OSXHIGuidelines/XHIGWindows/chapter_17_section_6.html#//apple_ref/doc/uid/20000961-TPXREF23 Writing good Alert messages]
*** In fast allen nichttrivialen fällen, kann man den Fehler nicht selber behandeln, sondern nur dem Benutzer die Information geben sie zu beheben. (ex. "FileNotFoundException" -> "Bitte legen sie den externen Datenträger "Blub" ein, auf dem sich die Datei "Bla" befindet") Aufwendiger - ja, aber notwendig!

'''Wo treten Fehler auf:'''
* Benutzereingaben die anders sind als Vorhergedacht
* Code, der mit externen Systemen (Netzwerk, Dateisystem, Geräte, Messfühler, Benutzer) kommuniziert
* Oder Code der Fehler / Bugs enthält
** Nicht oder falsch verstandene eingabewerte für Methoden
** dynamischer OO-Code, bei dem der Compiler nicht mehr alles prüfen kann

* '''Tools'''
** Eclipse
** CVS/SVN?

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 2

2006-03-17T10:26:37Z

Schneider: /* Übungsaufgaben */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 3: Modularisierung mit Klassen und Objekten =
'''Vortragende:''' Martin, Felix
== Inhalt ==

=== Java / Methodik ===

* '''Modularisierung und Strukturierung''' -- auf allen Ebenen
** Klassen (als Strukturen)
** Methoden-Kapselung: '''Methoden-Nachtrag'''
*** Methoden als Abstraktionsmöglichkeiten -> verstecken von methoden [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_Temp_43] Bringts das an der stelle?

* '''Testen'''
** eigene assert-Funktion

'''Objektorientierung''' (Erklärungsansatz)
* Objekt, Klasse erklären als: "Klasse" Mensch
** davon dann klonen mit bestimmten Modifikationen (augenfarbe, größe, name....)
** das wäre dann klasse, objekte und konstruktoraufruf
* Objekte / Klassen erklären als
** Platonische Ideen (Pferd)
** Tatsächliches Ding (Bruno auf dem ich jeden Dienstag in Hellersdorf reite)
* Objekte als Daten mit ''Schutzschicht'' Methoden aussen herum
** Klassen als solches erst später (quasi erst prototyp und dann klassen erklären)
* Ganz anderer Ansatz: Erklären über Einheiten die sich über Nachrichten gegenseitig verständigen
* Äquivalenz zu Funktionaler Programmierung aufmachen
** Constructor: Funktion die Parameter bekommt und eine Funktion zurückgibt die diese verkapselt
** Methoden: diese Funktion kann mit dem Namen verschiedener Methoden aufgerufen werden und wird, indem es diese ausführt, zum Objekt

'''Probleme beim Erklären'''
* this, woher kommt das und wie verwendet man es!

== Übungsaufgaben ==

;Ziel
:Kleine Studentendatenbank in der Studenten eingefügt und gesucht werden können.

;Advanced
:mit löschen

;Idee
:"Statistik" : Anzahl der Studenten, durchschnittliches Alter, bla

;Aufgaben
# Schreibe eine Klasse, die Informationen wie Name, Matrikelnummer etc. über einen Studenten speichert. Erzeuge ein Objekt dieser Klasse und belege die Objektvariablen mit Werten. Lese diese Werte aus den Objektvariablen wieder aus und gib sie auf dem Bildschirm aus.
# Schreibe einen Konstruktor für deine Klasse, der die Objektvariablen des erzeugten Objekts mit Werten füllt. Erzeuge mit Hilfe dieses Konsturktors ein Objekt, lies seine Werte aus und gib sie auf dem Bildschirm aus.
# Erweitere deine Klasse um eine Methode <code>public void printMe()</code>, die die Daten des Studentenobjekts auf dem Bildschirm ausgibt. Test deine Methode!
# Lege eine Feld (Array) mit 100 Studentenobjekten an, die verschiedene Matrikelnummern haben und gib all auf dem Bildschirm aus.
# Diese Feld ist schon eine Art Studentendatenbank. Schreibe daher eine neue Klasse <code>StudentenDatenbank</code>, die eine Feld von Studentenobjekten enthält. Die Klasse soll einen Konsturktor haben, dem die Größe des zu erzeugenden Feldes übergeben wird. Implementiere auch eine Methode <code>printMe</code>, die alle Datensätze ausgeben soll, sowie eine Mehtode <code>studentHinzufuegen()</code>, die einen Studentenobjekt mit den zu übergebenen Daten anlegen soll und dieses in die Datenbank einfügen soll.
# Erweitere die Studentendatenbank um eine Methode <code>studentEntfernen()</code>, die das Studentenobjekt mit der übergebenen Matrikelnummer aus der Datenbank löschen soll. Funktionert nach dem Löschen einiger Objekte deine Ausgabemethode (<code>printMe()</code>) noch?
# Erweitere die Studentendatenbank um eine Methode <code>studentenAnzahl()</code>, die die Anzahl der in der Datenbank gespeicherten Studentenobjekte zurückliefert.

;Zeitbedarf
: Arthur: Aufgaben 1-5 zusammen ca. 1h
: Sven : Aufgaben 1-7 zusammen etwa 1h hätte ich kate+bash benutzt schätz ich mal (angenehme aufgabe)

;Fragen
: soll private / public / default / protected thematisiert werden? (Arthur+Sven)
: soll sich deren array in der DB von sich aus vergrößern? (Sven)
: evtl. verwirrend das bei den methodenNamen hinten in der aufgabe ein "()" ist obwohl ja parameter übergeben werden? (Sven)
: gibt es eine musterlösung? wäre für die übungen denke ich sinnvoll damit dort alle tutoren auf die aufgabe klarkommen.. und am ende ähnliche ergebnisse haben ;) (Sven)


= LE 4: OO-Vertiefung und Klassenbibliothek =
'''Vortragende:''' Arthur, Martin

== Inhalt ==

=== Java ===

* '''Modularisierung in Java: Klassen und Objekte'''
** Instanziierung (auch Erklärung Mehrdeutigkeit von "Objekt" für Klasse oder Instanz)
** Referenzen (Pointer)
** insb: Referenzen sind nicht Kopien
** Overloading / Polymorphie
*** Standardmethoden: toString, equals, hash, compare
** Type Casting einfacher Basistypen?

* '''Objekte vertieft''': als Ansammlung von Daten mit Methoden dazu
** Konstruktoren
** um innendrinn auswechseln zu können
** ''static''
** Static nicht static: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_3.1.2 Benefits of Local State]
** ''final''
** ''null'', ''new''
** ''this''
** static / instanz -> Ebenen modell (?)

* Java-API: Konzept '''Klassenbibliothek'''
** Javadocs finden, lesen
* JavaDoc selber schreiben und verwenden -> http://www.javadocs.org
* Input/Output (Streams, usw.) <-- großer Block
** List, ArrayList, InputReader, BufferedReader, Scanner
** Collections

== Übungsaufgaben ==
* meinPferd = deinPferd;
* Klassen benutzen:
** Input/Output üben
** Viele andere Klassen aus der Java-API finden und nutzen
** Praktische Vorgehensweise, Anleitung zum Selbstlernen, nicht so viel Vorlesung dazu

* UtilityObjekt mit readFile(aFilename) und getUserInput(aPrompt) [http://www.cs.princeton.edu/introcs/22inout/In.java.html sowas sollte rauskommen!]

* Menü Objekt, das sich leicht adaptieren lässt?
* Apfelbaum
while (Apfelbaum.hatNochAepfel) {
Apfel meinApfel = Apfelbaum.getApfel(); // Apfel pflücken
ich.esse(meinApfel);
}
* Collections, Polymorphie (Apfel mit Wurm....)

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 2

2006-03-16T23:15:02Z

Schneider: /* Übungsaufgaben */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 3: Verfeinerung Java und Klassenbibliothek =
'''Vortragende:''' Martin, Felix
== Inhalt ==

=== Java / Methodik ===

* '''Modularisierung und Strukturierung''' -- auf allen Ebenen
** Klassen (als Strukturen)
** Methoden-Kapselung: '''Methoden-Nachtrag'''
*** Methoden als Abstraktionsmöglichkeiten -> verstecken von methoden [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_Temp_43] Bringts das an der stelle?

* '''Testen'''
** eigene assert-Funktion

'''Objektorientierung''' (Erklärungsansatz)
* Objekt, Klasse erklären als: "Klasse" Mensch
** davon dann klonen mit bestimmten Modifikationen (augenfarbe, größe, name....)
** das wäre dann klasse, objekte und konstruktoraufruf
* Objekte / Klassen erklären als
** Platonische Ideen (Pferd)
** Tatsächliches Ding (Bruno auf dem ich jeden Dienstag in Hellersdorf reite)
* Objekte als Daten mit ''Schutzschicht'' Methoden aussen herum
** Klassen als solches erst später (quasi erst prototyp und dann klassen erklären)
* Ganz anderer Ansatz: Erklären über Einheiten die sich über Nachrichten gegenseitig verständigen
* Äquivalenz zu Funktionaler Programmierung aufmachen
** Constructor: Funktion die Parameter bekommt und eine Funktion zurückgibt die diese verkapselt
** Methoden: diese Funktion kann mit dem Namen verschiedener Methoden aufgerufen werden und wird, indem es diese ausführt, zum Objekt

'''Probleme beim Erklären'''
* this, woher kommt das und wie verwendet man es!

== Übungsaufgaben ==

;Ziel
:Kleine Studentendatenbank in der Studenten eingefügt und gesucht werden können.

;Advanced
:mit löschen

;Idee
:"Statistik" : Anzahl der Studenten, durchschnittliches Alter, bla

;Aufgaben
# Schreibe eine Klasse, die Informationen wie Name, Matrikelnummer etc. über einen Studenten speichert. Erzeuge ein Objekt dieser Klasse und belege die Objektvariablen mit Werten. Lese diese Werte aus den Objektvariablen wieder aus und gib sie auf dem Bildschirm aus.
# Schreibe einen Konstruktor für deine Klasse, der die Objektvariablen des erzeugten Objekts mit Werten füllt. Erzeuge mit Hilfe dieses Konsturktors ein Objekt, lies seine Werte aus und gib sie auf dem Bildschirm aus.
# Erweitere deine Klasse um eine Methode <code>public void printMe()</code>, die die Daten des Studentenobjekts auf dem Bildschirm ausgibt. Test deine Methode!
# Lege eine Feld (Array) mit 100 Studentenobjekten an, die verschiedene Matrikelnummern haben und gib all auf dem Bildschirm aus.
# Diese Feld ist schon eine Art Studentendatenbank. Schreibe daher eine neue Klasse <code>StudentenDatenbank</code>, die eine Feld von Studentenobjekten enthält. Die Klasse soll einen Konsturktor haben, dem die Größe des zu erzeugenden Feldes übergeben wird. Implementiere auch eine Methode <code>printMe</code>, die alle Datensätze ausgeben soll, sowie eine Mehtode <code>studentHinzufuegen()</code>, die einen Studentenobjekt mit den zu übergebenen Daten anlegen soll und dieses in die Datenbank einfügen soll.
# Erweitere die Studentendatenbank um eine Methode <code>studentEntfernen()</code>, die das Studentenobjekt mit der übergebenen Matrikelnummer aus der Datenbank löschen soll. Funktionert nach dem Löschen einiger Objekte deine Ausgabemethode (<code>printMe()</code>) noch?
# Erweitere die Studentendatenbank um eine Methode <code>studentenAnzahl()</code>, die die Anzahl der in der Datenbank gespeicherten Studentenobjekte zurückliefert.

;Zeitbedarf
: Arthur: Aufgaben 1-5 zusammen ca. 1h
: Sven : Aufgaben 1-7 zusammen etwa 1h hätte ich kate+bash benutzt schätz ich mal (angenehme aufgabe)

;Fragen
: soll private / public / default / protected thematisiert werden? (Arthur+Sven)
: soll sich deren array in der DB von sich aus vergrößern? (Sven)
: evtl. verwirrend das bei den methodenNamen hinten in der aufgabe ein "()" ist obwohl ja parameter übergeben werden? (Sven)



= LE 4: Wir sind alle nur Objekte =
'''Vortragende:''' Arthur, Martin

== Inhalt ==

=== Java ===

* '''Modularisierung in Java: Klassen und Objekte'''
** Instanziierung (auch Erklärung Mehrdeutigkeit von "Objekt" für Klasse oder Instanz)
** Referenzen (Pointer)
** insb: Referenzen sind nicht Kopien
** Overloading / Polymorphie
*** Standardmethoden: toString, equals, hash, compare
** Type Casting einfacher Basistypen?

* '''Objekte vertieft''': als Ansammlung von Daten mit Methoden dazu
** Konstruktoren
** um innendrinn auswechseln zu können
** ''static''
** Static nicht static: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_3.1.2 Benefits of Local State]
** ''final''
** ''null'', ''new''
** ''this''
** static / instanz -> Ebenen modell (?)

* Java-API: Konzept '''Klassenbibliothek'''
** Javadocs finden, lesen
* JavaDoc selber schreiben und verwenden -> http://www.javadocs.org
* Input/Output (Streams, usw.) <-- großer Block
** List, ArrayList, InputReader, BufferedReader, Scanner
** Collections

== Übungsaufgaben ==
* meinPferd = deinPferd;
* Klassen benutzen:
** Input/Output üben
** Viele andere Klassen aus der Java-API finden und nutzen
** Praktische Vorgehensweise, Anleitung zum Selbstlernen, nicht so viel Vorlesung dazu

* UtilityObjekt mit readFile(aFilename) und getUserInput(aPrompt) [http://www.cs.princeton.edu/introcs/22inout/In.java.html sowas sollte rauskommen!]

* Menü Objekt, das sich leicht adaptieren lässt?
* Apfelbaum
while (Apfelbaum.hatNochAepfel) {
Apfel meinApfel = Apfelbaum.getApfel(); // Apfel pflücken
ich.esse(meinApfel);
}
* Collections, Polymorphie (Apfel mit Wurm....)

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 2

2006-03-16T23:04:01Z

Schneider: /* Übungsaufgaben */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 3: Verfeinerung Java und Klassenbibliothek =
'''Vortragende:''' Martin, Felix
== Inhalt ==

=== Java / Methodik ===

* '''Modularisierung und Strukturierung''' -- auf allen Ebenen
** Klassen (als Strukturen)
** Methoden-Kapselung: '''Methoden-Nachtrag'''
*** Methoden als Abstraktionsmöglichkeiten -> verstecken von methoden [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_Temp_43] Bringts das an der stelle?

* '''Testen'''
** eigene assert-Funktion

'''Objektorientierung''' (Erklärungsansatz)
* Objekt, Klasse erklären als: "Klasse" Mensch
** davon dann klonen mit bestimmten Modifikationen (augenfarbe, größe, name....)
** das wäre dann klasse, objekte und konstruktoraufruf
* Objekte / Klassen erklären als
** Platonische Ideen (Pferd)
** Tatsächliches Ding (Bruno auf dem ich jeden Dienstag in Hellersdorf reite)
* Objekte als Daten mit ''Schutzschicht'' Methoden aussen herum
** Klassen als solches erst später (quasi erst prototyp und dann klassen erklären)
* Ganz anderer Ansatz: Erklären über Einheiten die sich über Nachrichten gegenseitig verständigen
* Äquivalenz zu Funktionaler Programmierung aufmachen
** Constructor: Funktion die Parameter bekommt und eine Funktion zurückgibt die diese verkapselt
** Methoden: diese Funktion kann mit dem Namen verschiedener Methoden aufgerufen werden und wird, indem es diese ausführt, zum Objekt

'''Probleme beim Erklären'''
* this, woher kommt das und wie verwendet man es!

== Übungsaufgaben ==

;Ziel
:Kleine Studentendatenbank in der Studenten eingefügt und gesucht werden können.

;Advanced
:mit löschen

;Idee
:"Statistik" : Anzahl der Studenten, durchschnittliches Alter, bla

;Aufgaben
# Schreibe eine Klasse, die Informationen wie Name, Matrikelnummer etc. über einen Studenten speichert. Erzeuge ein Objekt dieser Klasse und belege die Objektvariablen mit Werten. Lese diese Werte aus den Objektvariablen wieder aus und gib sie auf dem Bildschirm aus.
# Schreibe einen Konstruktor für deine Klasse, der die Objektvariablen des erzeugten Objekts mit Werten füllt. Erzeuge mit Hilfe dieses Konsturktors ein Objekt, lies seine Werte aus und gib sie auf dem Bildschirm aus.
# Erweitere deine Klasse um eine Methode <code>public void printMe()</code>, die die Daten des Studentenobjekts auf dem Bildschirm ausgibt. Test deine Methode!
# Lege eine Feld (Array) mit 100 Studentenobjekten an, die verschiedene Matrikelnummern haben und gib all auf dem Bildschirm aus.
# Diese Feld ist schon eine Art Studentendatenbank. Schreibe daher eine neue Klasse <code>StudentenDatenbank</code>, die eine Feld von Studentenobjekten enthält. Die Klasse soll einen Konsturktor haben, dem die Größe des zu erzeugenden Feldes übergeben wird. Implementiere auch eine Methode <code>printMe</code>, die alle Datensätze ausgeben soll, sowie eine Mehtode <code>studentHinzufuegen()</code>, die einen Studentenobjekt mit den zu übergebenen Daten anlegen soll und dieses in die Datenbank einfügen soll.
# Erweitere die Studentendatenbank um eine Methode <code>studentEntfernen()</code>, die das Studentenobjekt mit der übergebenen Matrikelnummer aus der Datenbank löschen soll. Funktionert nach dem Löschen einiger Objekte deine Ausgabemethode (<code>printMe()</code>) noch?
# Erweitere die Studentendatenbank um eine Methode <code>studentenAnzahl()</code>, die die Anzahl der in der Datenbank gespeicherten Studentenobjekte zurückliefert.

;Zeitbedarf
: Arthur: Aufgaben 1-5 zusammen ca. 1h
: Sven : Aufgaben 1-5 zusammen 22min (eclipse) also mit kate+bash schätz ich mal ~1h

;Fragen
: soll private / public / default / protected thematisiert werden? (Arthur+Sven)
: soll sich deren array in der DB von sich aus vergrößern? (Sven)
: evtl. verwirrend das bei den methodenNamen hinten in der aufgabe ein "()" ist obwohl ja parameter übergeben werden? (Sven)



= LE 4: Wir sind alle nur Objekte =
'''Vortragende:''' Arthur, Martin

== Inhalt ==

=== Java ===

* '''Modularisierung in Java: Klassen und Objekte'''
** Instanziierung (auch Erklärung Mehrdeutigkeit von "Objekt" für Klasse oder Instanz)
** Referenzen (Pointer)
** insb: Referenzen sind nicht Kopien
** Overloading / Polymorphie
*** Standardmethoden: toString, equals, hash, compare
** Type Casting einfacher Basistypen?

* '''Objekte vertieft''': als Ansammlung von Daten mit Methoden dazu
** Konstruktoren
** um innendrinn auswechseln zu können
** ''static''
** Static nicht static: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_3.1.2 Benefits of Local State]
** ''final''
** ''null'', ''new''
** ''this''
** static / instanz -> Ebenen modell (?)

* Java-API: Konzept '''Klassenbibliothek'''
** Javadocs finden, lesen
* JavaDoc selber schreiben und verwenden -> http://www.javadocs.org
* Input/Output (Streams, usw.) <-- großer Block
** List, ArrayList, InputReader, BufferedReader, Scanner
** Collections

== Übungsaufgaben ==
* meinPferd = deinPferd;
* Klassen benutzen:
** Input/Output üben
** Viele andere Klassen aus der Java-API finden und nutzen
** Praktische Vorgehensweise, Anleitung zum Selbstlernen, nicht so viel Vorlesung dazu

* UtilityObjekt mit readFile(aFilename) und getUserInput(aPrompt) [http://www.cs.princeton.edu/introcs/22inout/In.java.html sowas sollte rauskommen!]

* Menü Objekt, das sich leicht adaptieren lässt?
* Apfelbaum
while (Apfelbaum.hatNochAepfel) {
Apfel meinApfel = Apfelbaum.getApfel(); // Apfel pflücken
ich.esse(meinApfel);
}
* Collections, Polymorphie (Apfel mit Wurm....)

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 1

2006-03-14T17:21:23Z

Schneider: /* Java */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 1: Hello, World! =
'''Vortragende:''' Robert Lubkoll, Felix Schwarz

== Organisatorisches ==
* Was Passiert
* Wann passiert was
* Wie passierts
* Vorstellung
* Was ist das genau
* Wer sind wir: Freiwillig, Umsonst
* Ziel des Kurses
* Was sie am Ende können sollen
* Gruppeneinteilung
** am Ende der ersten Vorlesung
** Vorher per e-mail
'''Jemand vom Rechnerbetrieb soll bitte da sein, damit wir Login-Probleme lösen können'''

== Inhalt (Vorgehen, Beispiele, Ideen) ==
=== Methodik ===

Was ist '''Programmieren?'''
* imperativ (prozedural) vs. funktionales Programmieren
** relation problem <-> lösung / kochrezept
* Zustandsmaschine
* Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")
** ''Damit ist die Philosophie von Programmieren gemeint''

Drei Dinge, die wichtig sind für Programmierer (Das soll sich durch den Kurs durchziehen als roter Faden für die Sprachfeatures die wir einführen):
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

=== Java ===
==== Wie fangen wir Java an ====
* Werte und operatoren +,*,/,-, % (?)
* Wenige Variablentypen int, String, (double)
** String: Vormerken, das man hier später klar macht das das auch Objekte und daher Referenzen sind - erstmal ists aber egal, da sie eh Immutable sind
* Zuweisung
* <, >, ==, <=, >=
* if-else
* hierfür auch boolean und die operatoren && || ! != ==

* Methoden vorgeben: Input, Output

* Was passiert da, wieso erst Compilieren, dann ausführen
* Live vorführen

==== Vorführung ====
'''Aufbau eines Java-Programms'''

Ein Beispiel bringen und daran erklären, was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind. Das Programm dabei langsam entwickeln und dabei vorführen. Ziel ist, das am schluss ein komplettes Beispiel da steht - also alles verwendet wird was wir erklärt haben, es aber trotzdem so einfach bleibt das es ohne viel Fehlerpotenzial später nachgemacht werden kann.
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}

=== Methodik ===

'''Sauberes Programmieren'''
* Variablen und Identifier-Namen
** Variablendeklaration - Namen vergeben für Dinge, die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 scrollen bis '''Local Names''']

'''Fehlermeldungen lesen und verstehen'''
* Klammer vergessen
* Semikolon vergessen
* Klasse heißt anders als Datei
* Compiler falsch aufgerufen

== Übungsaufgaben ==

* ''cd'' üben
* Hello World eintippen (kate, gedit, nano, ..)
* javac / java benutzen
* Ergebnisse sehen
* Fehler einbauen, Fehler finden (laufzeit/compilezeit)
* Einige Expressions angeben und die Teilnehmer sollen feststellen, was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

= LE 2: Standardkonstrukte in Java (Robert und Sven) =
Übungs-Aufgaben inklusive Vorgaben und Musterlösung [http://user.cs.tu-berlin.de/~svens/files/le2_ue.tar.gz LE2UEB]

updated: freitag 2006-03-10 19:05

letzte änderungen: aufgabe 0 mit einigen methoden die sie fixen müssen, bzw. analyisieren sollen.

TODO: LE1 aufgabe benutzen. (delayed)

== Inhalt ==
=== Methodik ===
* Wichtigkeit, dass man Programme in verständliche und sinnvolle Teile unterteilt:
** dadurch verbesserte test-möglichkeiten (sprich methoden sind auch eine art von modul)
** verbesserte verständlichkeit([http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions])
* Quelltextverkürzung durch schleifen
** nicht minimierung auf kosten der verständlichkeit
** was ist aufgabe des entwicklers?
** und was ist aufgabe des compilers? (vllt. auch nicht?)
** evtl. ist eine eigene methode sinnvoller/verständlicher?

=== Java ===
* '''Typen'''
** Arrays
*** warum, wie und probleme
** void
** char?

* '''Methoden''':
** Namend
** Aufruf
** Parameter und Rückgabe -> Call by Value
** main
** return
** Nachtrag Datenstrukturen: void
** Beispiel: System.out.println()

* '''Blöcke'''
** if-else (das ist doch schon in LE1 enthalten!)
** while
*** Formulieren von Bedingungen
*** Schleife als zweite Lösung für duplikation von Code
*** Diskussion Schleife <-> Rekursion

* Anwendung von Schleifen
* Rekursion <-> Schleifen (Beispiel)
* Warum/wann Schleifen?
** als Alternative zu Akkumulator Parametern (Vergleich zu OPAL)
** wenn die Anzahl der Durchläufe nicht konstant ist
** for schleife, wann und wozu, einfache beispiele: for(int i = 0; i < 3; i++)

* '''Gute Namen'''
** Abstrakter Gedanke: Für den Computer ists wurscht, wie man das was man meint aufschreibt. Wir Menschen dagegen lassen und leicht verwirren
** abwägen zwischen
*** aussagekraft des namens
*** häufigkeit im code
*** kommentar zu variable(nnamen)
*** länge des namens

* '''Testen'''
* was ist testen?
** überprüfung von einigen randwerten => nachdenken ist erforderlich um interessante fälle zu finden
** testen ist nicht verifizieren
* wie in java?
** System.out.println(..);
** auskommentieren und schrittweises testen
* was wird getestet?
** ausgabe von arrays komplex
** ausgabe von werten mit text verknüpfen
** Variablen haben unterschiedliche Werte während das Program läuft!

assert-Methode selber schreiben -> Später! (WANN?)

== Übungsaufgaben ==

* Methoden definieren, die bestimmte Eigenschaften haben
* Beispiele dann Abtippen und ausprobieren
* Sie sollen Nachfragen, wenn sie was anderes hatten (oder sowas)
* Verschiedene Eingabewerte
* erste Endlosschleife
* Fehler für die eingeführten elemente

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 1

2006-03-14T17:19:35Z

Schneider:

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 1: Hello, World! =
'''Vortragende:''' Robert Lubkoll, Felix Schwarz

== Organisatorisches ==
* Was Passiert
* Wann passiert was
* Wie passierts
* Vorstellung
* Was ist das genau
* Wer sind wir: Freiwillig, Umsonst
* Ziel des Kurses
* Was sie am Ende können sollen
* Gruppeneinteilung
** am Ende der ersten Vorlesung
** Vorher per e-mail
'''Jemand vom Rechnerbetrieb soll bitte da sein, damit wir Login-Probleme lösen können'''

== Inhalt (Vorgehen, Beispiele, Ideen) ==
=== Methodik ===

Was ist '''Programmieren?'''
* imperativ (prozedural) vs. funktionales Programmieren
** relation problem <-> lösung / kochrezept
* Zustandsmaschine
* Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")
** ''Damit ist die Philosophie von Programmieren gemeint''

Drei Dinge, die wichtig sind für Programmierer (Das soll sich durch den Kurs durchziehen als roter Faden für die Sprachfeatures die wir einführen):
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

=== Java ===
==== Wie fangen wir Java an ====
* Werte und operatoren +,*,/,-, % (?)
* Wenige Variablentypen int, String, (double)
** String: Vormerken, das man hier später klar macht das das auch Objekte und daher Referenzen sind - erstmal ists aber egal, da sie eh Immutable sind
* Zuweisung
* <, >, ==, <=, >=
* if-else
* hierfür auch boolean und die operatoren && || ! != ==

* Methoden vorgeben: Input, Output

* Was passiert da, wieso erst Compilieren, dann ausführen
* Live vorführen

==== Vorführung ====
'''Aufbau eines Java-Programms'''

Ein Beispiel bringen und daran erklären, was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind. Das Programm dabei langsam entwickeln und dabei vorführen. Ziel ist, das am schluss ein komplettes Beispiel da steht - also alles verwendet wird was wir erklärt haben, es aber trotzdem so einfach bleibt das es ohne viel Fehlerpotenzial später nachgemacht werden kann.
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}

=== Methodik ===

'''Sauberes Programmieren'''
* Variablen und Identifier-Namen
** Variablendeklaration - Namen vergeben für Dinge, die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 scrollen bis '''Local Names''']

'''Fehlermeldungen lesen und verstehen'''
* Klammer vergessen
* Semikolon vergessen
* Klasse heißt anders als Datei
* Compiler falsch aufgerufen

== Übungsaufgaben ==

* ''cd'' üben
* Hello World eintippen (kate, gedit, nano, ..)
* javac / java benutzen
* Ergebnisse sehen
* Fehler einbauen, Fehler finden (laufzeit/compilezeit)
* Einige Expressions angeben und die Teilnehmer sollen feststellen, was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

= LE 2: Standardkonstrukte in Java (Robert und Sven) =
Übungs-Aufgaben inklusive Vorgaben und Musterlösung [http://user.cs.tu-berlin.de/~svens/files/le2_ue.tar.gz LE2UEB]

updated: freitag 2006-03-10 19:05

letzte änderungen: aufgabe 0 mit einigen methoden die sie fixen müssen, bzw. analyisieren sollen.

TODO: LE1 aufgabe benutzen. (delayed)

== Inhalt ==
=== Methodik ===
* Wichtigkeit, dass man Programme in verständliche und sinnvolle Teile unterteilt:
** dadurch verbesserte test-möglichkeiten (sprich methoden sind auch eine art von modul)
** verbesserte verständlichkeit([http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions])
* Quelltextverkürzung durch schleifen
** nicht minimierung auf kosten der verständlichkeit
** was ist aufgabe des entwicklers?
** und was ist aufgabe des compilers? (vllt. auch nicht?)
** evtl. ist eine eigene methode sinnvoller/verständlicher?

=== Java ===
* '''Typen'''
** Arrays
*** warum, wie und probleme
** void
** char?

* '''Methoden''':
** Namend
** Aufruf
** Parameter und Rückgabe -> Call by Value
** main
** return
** Nachtrag Datenstrukturen: void
** Beispiel: System.out.println()

* '''Blöcke'''
** if-else
*** Formulieren von Bedingungen für if, while
** while
*** Schleife als zweite Lösung für duplikation von Code
*** Diskussion Schleife <-> Rekursion

* Anwendung von Schleifen
* Rekursion <-> Schleifen (Beispiel)
* Warum/wann Schleifen?
** als Alternative zu Akkumulator Parametern (Vergleich zu OPAL)
** wenn die Anzahl der Durchläufe nicht konstant ist
** for schleife, wann und wozu, einfache beispiele: for(int i = 0; i < 3; i++)

* '''Gute Namen'''
** Abstrakter Gedanke: Für den Computer ists wurscht, wie man das was man meint aufschreibt. Wir Menschen dagegen lassen und leicht verwirren
** abwägen zwischen
*** aussagekraft des namens
*** häufigkeit im code
*** kommentar zu variable(nnamen)
*** länge des namens

* '''Testen'''
* was ist testen?
** überprüfung von einigen randwerten => nachdenken ist erforderlich um interessante fälle zu finden
** testen ist nicht verifizieren
* wie in java?
** System.out.println(..);
** auskommentieren und schrittweises testen
* was wird getestet?
** ausgabe von arrays komplex
** ausgabe von werten mit text verknüpfen
** Variablen haben unterschiedliche Werte während das Program läuft!

assert-Methode selber schreiben -> Später! (WANN?)

== Übungsaufgaben ==

* Methoden definieren, die bestimmte Eigenschaften haben
* Beispiele dann Abtippen und ausprobieren
* Sie sollen Nachfragen, wenn sie was anderes hatten (oder sowas)
* Verschiedene Eingabewerte
* erste Endlosschleife
* Fehler für die eingeführten elemente

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 1

2006-03-14T17:15:21Z

Schneider: /* Java */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 1: Hello, World! =
'''Vortragende:''' Robert Lubkoll, Felix Schwarz

== Organisatorisches ==
* Was Passiert
* Wann passiert was
* Wie passierts
* Vorstellung
* Was ist das genau
* Wer sind wir: Freiwillig, Umsonst
* Ziel des Kurses
* Was sie am Ende können sollen
* Gruppeneinteilung
** am Ende der ersten Vorlesung
** Vorher per e-mail
'''Jemand vom Rechnerbetrieb soll bitte da sein, damit wir Login-Probleme lösen können'''

== Inhalt (Vorgehen, Beispiele, Ideen) ==
=== Methodik ===

Was ist '''Programmieren?'''
* imperativ (prozedural) vs. funktionales Programmieren
** relation problem <-> lösung / kochrezept
* Zustandsmaschine
* Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")
** ''Damit ist die Philosophie von Programmieren gemeint''

Drei Dinge, die wichtig sind für Programmierer (Das soll sich durch den Kurs durchziehen als roter Faden für die Sprachfeatures die wir einführen):
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

=== Java ===
==== Wie fangen wir Java an ====
* Werte und operatoren +,*,/,-, % (?)
* Wenige Variablentypen int, String, (double)
** String: Vormerken, das man hier später klar macht das das auch Objekte und daher Referenzen sind - erstmal ists aber egal, da sie eh Immutable sind
* Zuweisung
* <, >, ==, <=, >=
* if-else
* hierfür auch boolean und die operatoren && || ! != ==

* Methoden vorgeben: Input, Output

* Was passiert da, wieso erst Compilieren, dann ausführen
* Live vorführen

==== Vorführung ====
'''Aufbau eines Java-Programms'''

Ein Beispiel bringen und daran erklären, was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind. Das Programm dabei langsam entwickeln und dabei vorführen. Ziel ist, das am schluss ein komplettes Beispiel da steht - also alles verwendet wird was wir erklärt haben, es aber trotzdem so einfach bleibt das es ohne viel Fehlerpotenzial später nachgemacht werden kann.
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}

=== Methodik ===

'''Sauberes Programmieren'''
* Variablen und Identifier-Namen
** Variablendeklaration - Namen vergeben für Dinge, die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 scrollen bis '''Local Names''']

'''Fehlermeldungen lesen und verstehen'''
* Klammer vergessen
* Semikolon vergessen
* Klasse heißt anders als Datei
* Compiler falsch aufgerufen

== Übungsaufgaben ==

* ''cd'' üben
* Hello World eintippen (kate, gedit, nano, ..)
* javac / java benutzen
* Ergebnisse sehen
* Fehler einbauen, Fehler finden (laufzeit/compilezeit)
* Einige Expressions angeben und die Teilnehmer sollen feststellen, was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

= LE 2: Standardkonstrukte in Java (Robert und Sven) =
Übungs-Aufgaben inklusive Vorgaben und Musterlösung [http://user.cs.tu-berlin.de/~svens/files/le2_ue.tar.gz LE2UEB]

updated: freitag 2006-03-10 19:05

letzte änderungen: aufgabe 0 mit einigen methoden die sie fixen müssen, bzw. analyisieren sollen.

TODO: LE1 aufgabe benutzen. (delayed)

== Inhalt ==
=== Methodik ===
* Wichtigkeit, dass man Programme in verständliche und sinnvolle Teile unterteilt: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions]

=== Java ===
* '''Typen'''
** Arrays
*** warum, wie und probleme
** void
** char?

* '''Methoden''':
** Namend
** Aufruf
** Parameter und Rückgabe -> Call by Value
** main
** return
** Nachtrag Datenstrukturen: void
** Beispiel: System.out.println()

* '''Blöcke'''
** if-else
*** Formulieren von Bedingungen für if, while
** while
*** Schleife als zweite Lösung für duplikation von Code
*** Diskussion Schleife <-> Rekursion

* Anwendung von Schleifen
* Rekursion <-> Schleifen (Beispiel)
* Warum/wann Schleifen?
** als Alternative zu Akkumulator Parametern (Vergleich zu OPAL)
** wenn die Anzahl der Durchläufe nicht konstant ist
** for schleife, wann und wozu, einfache beispiele: for(int i = 0; i < 3; i++)

* '''Gute Namen'''
** Abstrakter Gedanke: Für den Computer ists wurscht, wie man das was man meint aufschreibt. Wir Menschen dagegen lassen und leicht verwirren
** abwägen zwischen
*** aussagekraft des namens
*** häufigkeit im code
*** kommentar zu variable(nnamen)
*** länge des namens

* '''Testen'''
* was ist testen?
** überprüfung von einigen randwerten => nachdenken ist erforderlich um interessante fälle zu finden
** testen ist nicht verifizieren
* wie in java?
** System.out.println(..);
** auskommentieren und schrittweises testen
* was wird getestet?
** ausgabe von arrays komplex
** ausgabe von werten mit text verknüpfen
** Variablen haben unterschiedliche Werte während das Program läuft!

assert-Methode selber schreiben -> Später! (WANN?)

== Übungsaufgaben ==

* Methoden definieren, die bestimmte Eigenschaften haben
* Beispiele dann Abtippen und ausprobieren
* Sie sollen Nachfragen, wenn sie was anderes hatten (oder sowas)
* Verschiedene Eingabewerte
* erste Endlosschleife
* Fehler für die eingeführten elemente

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

Martin Häcker/Java Kurs/Tag 1

2006-03-14T17:05:55Z

Schneider: /* Wie fangen wir Java an */

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]

= LE 1: Hello, World! =
'''Vortragende:''' Robert Lubkoll, Felix Schwarz

== Organisatorisches ==
* Was Passiert
* Wann passiert was
* Wie passierts
* Vorstellung
* Was ist das genau
* Wer sind wir: Freiwillig, Umsonst
* Ziel des Kurses
* Was sie am Ende können sollen
* Gruppeneinteilung
** am Ende der ersten Vorlesung
** Vorher per e-mail
'''Jemand vom Rechnerbetrieb soll bitte da sein, damit wir Login-Probleme lösen können'''

== Inhalt (Vorgehen, Beispiele, Ideen) ==
=== Methodik ===

Was ist '''Programmieren?'''
* imperativ (prozedural) vs. funktionales Programmieren
** relation problem <-> lösung / kochrezept
* Zustandsmaschine
* Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")
** ''Damit ist die Philosophie von Programmieren gemeint''

Drei Dinge, die wichtig sind für Programmierer (Das soll sich durch den Kurs durchziehen als roter Faden für die Sprachfeatures die wir einführen):
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

=== Java ===
==== Wie fangen wir Java an ====
* Werte und operatoren +,*,/,-, % (?)
* Wenige Variablentypen int, String, (double)
** String: Vormerken, das man hier später klar macht das das auch Objekte und daher Referenzen sind - erstmal ists aber egal, da sie eh Immutable sind
* Zuweisung
* <, >, ==, <=, >=
* if-else
* hierfür auch boolean und die operatoren && || ! != ==

* Methoden vorgeben: Input, Output

* Was passiert da, wieso erst Compilieren, dann ausführen
* Live vorführen

==== Vorführung ====
'''Aufbau eines Java-Programms'''

Ein Beispiel bringen und daran erklären, was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind. Das Programm dabei langsam entwickeln und dabei vorführen. Ziel ist, das am schluss ein komplettes Beispiel da steht - also alles verwendet wird was wir erklärt haben, es aber trotzdem so einfach bleibt das es ohne viel Fehlerpotenzial später nachgemacht werden kann.
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}

=== Methodik ===

'''Sauberes Programmieren'''
* Variablen und Identifier-Namen
** Variablendeklaration - Namen vergeben für Dinge, die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 scrollen bis '''Local Names''']

'''Fehlermeldungen lesen und verstehen'''
* Klammer vergessen
* Semikolon vergessen
* Klasse heißt anders als Datei
* Compiler falsch aufgerufen

== Übungsaufgaben ==

* ''cd'' üben
* Hello World eintippen (kate, gedit, nano, ..)
* javac / java benutzen
* Ergebnisse sehen
* Fehler einbauen, Fehler finden (laufzeit/compilezeit)
* Einige Expressions angeben und die Teilnehmer sollen feststellen, was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

= LE 2: Standardkonstrukte in Java (Robert und Sven) =
Übungs-Aufgaben inklusive Vorgaben und Musterlösung [http://user.cs.tu-berlin.de/~svens/files/le2_ue.tar.gz LE2UEB]

updated: freitag 2006-03-10 19:05

letzte änderungen: aufgabe 0 mit einigen methoden die sie fixen müssen, bzw. analyisieren sollen.

TODO: LE1 aufgabe benutzen. (delayed)

== Inhalt ==
=== Methodik ===
* Wichtigkeit, dass man Programme in verständliche und sinnvolle Teile unterteilt: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions]

=== Java ===
* '''Typen'''
** boolean (in LE 1, weil if sonst keinen Sinn macht)
** Arrays
** was wir im ersten Teil weggelassen haben?

* '''Methoden''':
** Namend
** Aufruf
** Parameter und Rückgabe -> Call by Value
** main
** return
** Nachtrag Datenstrukturen: void
** Beispiel: System.out.println()

* '''Blöcke'''
** if-else
*** Formulieren von Bedingungen für if, while
** while
*** Schleife als zweite Lösung für duplikation von Code
*** Diskussion Schleife <-> Rekursion???

* Anwendung von Schleifen
* Rekursion <-> Schleifen (Beispiel)
* Warum/wann Schleifen?
** als Alternative zu Akkumulator Parametern (Vergleich zu OPAL)
** wenn die Anzahl der Durchläufe nicht konstant ist
** als Luxus - Bsp: for( int i = 0; i < 3; i++ )

* '''Gute Namen'''
** Abstrakter Gedanke: Für den Computer ists wurscht, wie man das was man meint aufschreibt. Wir Menschen dagegen sind von sowaas verwirrt:
class _{static long _
(long __,long ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ; }
static {int _=2 ,___
= 2;System.out.print(
"a("+_+','+___+ ")="+
_ (_, ___) ) ;System
.exit(1);}}//(C) Ulli

Wir können uns aber helfen indem wir das so schreiben:
/** @see: http://de.wikipedia.org/wiki/Ackermann-Funktion */
class AckermannFunctionDemo {
static long ackermann(long n, long m) {
if (n == 0) {
return m + 1;
}
else if (m == 0) {
return ackermann(n - 1, 1)
}
else {
return ackermann(n - 1, ackermann(n, m - 1));
}
}
static void main {
int n = 2, m = 2;
System.out.print("ackermann(" + n + ',' + m + ") = "
+ ackermann(n, m));
System.exit(1);
}
}//(C) Ulli + Martin

* Testen: wie testet man ob und wie etwas geht? (Java Ausprobieren)
** assert-Methode selber schreiben -> Später!
* Werte ausgeben! -> printf-Debugging
** Variablen haben unterschiedliche Werte während das Program läuft!

== Übungsaufgaben ==

* Methoden definieren, die bestimmte Eigenschaften haben
* Beispiele dann Abtippen und ausprobieren
* Sie sollen Nachfragen, wenn sie was anderes hatten (oder sowas)
* Verschiedene Eingabewerte
* erste Endlosschleife
* Fehler für die eingeführten elemente

[[Benutzer:Martin_Häcker/Java_Kurs | <- Zurück zur Übersicht]]