Wiki - Jakob Raith - Paul Polak - Laura Dietrich

INHALTSVERZEICHNIS
Wiki ...................................................................................................................................... 2
1.) The way Java works .......................................................................................................5
2.) Making your first object ..................................................................................................5
3.) Arithmetic calculations ..................................................................................................6
4.) IF-Statement ....................................................................................................................6
5.) Struktogramme ...............................................................................................................8
6.) What is JUnit?...................................................................................................................8
7.) Primitive Types .................................................................................................................9
8.) "and(&&)" and "or(||)" .................................................................................................10
9.) StringToInt / IntToString..................................................................................................12
Arrays ..................................................................................................................... 13
10.) Switch Statement ........................................................................................................14
11.) Comparing Strings ......................................................................................................15
12.) References ..................................................................................................................16
13.) While loops ..................................................................................................................17
14.) 2-dimensionale Arrays ...............................................................................................18
15.) Tic Tac Toe ...................................................................................................................19
16. DOS Commands ...........................................................................................................28
17.) Exceptions ...................................................................................................................29
Alert (Handy Application) ..................................................................................30
18.) Collections...................................................................................................................30
Unterschied zwischen Array und Collection .....................................................30
Zur Colletion.........................................................................................................31
Befehle bei der Collection .................................................................................32
Befehle bei der Array List ....................................................................................33
Beispiel Collections anhand vom Average Beispiel .........................................33

19.) GUI ..............................................................................................................................34
20.) Low Level API...............................................................................................................36
Ping Pong.............................................................................................................40
WIKI_PUC Seite 1 von 44 2009/10

Jakob Raith | Paul Polak | Laura Dietrich 1 CHIF
Hallo Liebe 1CHIF!
In unserem Wiki wollen wir euch einen allgemeinen berblick ber die
Programmiersprache Java ( -> mit Java die als solche ein eingetragenes
Warenzeichen der Firma Sun Mycrosystems. Sie ist eine Komponente der Java
- Technologie. ) geben, oder besser gesagt die Teile von Java die wir im
Unterricht durchgemacht haben.
Allgemeines zum Verstndnis frs Programmieren ( mit JAVA !! )
Die 5 allgemein angestrebten Ziele in JAVA :
Sie soll eine einfache objektorientierte, verteilte und vertraute

Programmiersprache sein.
Sie soll robust und sicher sein.
Sie soll architekturneutral und portabel sein.
Sie soll hoch performant sein.

Sie soll interpretierbar sein, Parallelen beinhalten und dynamisch sein !
Was Programmieren selbst ist, dass wird hier wohl jeder wissen. Man sagt dem
Computer was er tun soll und das in einer Sprache die er verstehen kann
(oder besser sollte ), auch wenn er das geschriebene teilweise am Anfang
eher nicht versteht dann komplettiert er das geschriebene auf logischer Basis -
> das nennt sich Hotspot-Optimierung ( -> Die HotSpot-Technik ist seit der JRE

Version 1.3 verfgbar und wurde seitdem stetig weiter verbessert.)!!! Ist
manchmal sicher ganz hilfreich !! (;
Im Unterricht beschftigen wir uns mit dem objektorientierten Programmieren.

Das bedeutet, dass alle unsere Programme darauf aufbauen, dass wir
Gruppen von Objekten (genannt Klassen) erstellen und diese bestimmte
Dinge tun lassen.
Dieser Teil der Erklrung Javas beinhaltet auch glcklicherweise das Java-
Programme PLATTFORMUNABHNGIG sind, das bedeutet das diese meistens
ohne jegliche Vernderung des Codes auf jedem PC laufen !! Es gilt nur bei
verschiedenen Javaversionen aufzupassen !!
Klassen:
Eine Klasse oder ein Objektyp, fasst mehrere Objekte der selben Art
zusammen. Ein Beispiel: Du selbst bist ein Objekt der Klasse Mensch.
Objekte(auch Instanzen):
Objekte sind alle Komponenten deines Programms. Ein Objekt ist zum Beispiel
der Cube aus ex001. Du bist die Instanz "Schler" der Klasse Mensch (bildlich
gesprochen).
Eigenschaften(auch Attribute):
Natrlich hat jedes Objekt verschiedene Eigenschaften. In deinem Programm
kannst du einem Objekt so viele Eigenschaften geben wie du willst. Du, also
das Objekt Schler hat Eigenschaften wie: Augenfarbe, Krpergre, Alter,
usw.
Variablen:
Das Problem ist, dass jeder Schler eine andere Augenfarbe hat. Darum
werden die Eigenschaften durch sogenannte Variablen definiert. Die
Variablen dienen als Platzhalter, damit jede deiner Eigenschaften einen
beliebigen Wert annehmen kann. Jetzt kannst du deinem Programm sagen,
dass Schler1 blaue Augen hat, Schler2 allerdings grne.
Instanzvariablen/lokale Variablen:
Auch innerhalb der Variablen gibt es wieder Unterschiede. Auf eine
Instanzvariable zum Beispiel kann jedes deiner Objekt und jede Methode
innerhalb deiner Klasse zugreifen, whrend auf lokale Variablen nur die
Methode zugreifen kann in der sie vereinbart wurde:
int x = 0;

int f() { return x; }
int g() { int x = 1; return f(); }
Im obigen Programmfragment gibt g() immer 0 zurck (den Wert der globalen
Variablen x,nicht den Wert der lokalen Variablen x in g()). Dies ist so, weil in f()
immer nur das globale x sichtbar ist.
Instanzvariablen haben immer einen vordefinierten Wert. Wenn du der
Variable keinen Wert zuweist, oder keine Setter/Methode aufrufst, bekommt
die Variable trotzdem einen Wert:
int = 0
float/double = 0.0
boolean = false
references = null
Lokale Variablen bekommen keinen vordefinierten Wert, solltest du ihnen

keinen zuweisen. Der Compiler wird dir eine Fehlermeldung anzeigen, wenn
du eine lokale Variable nicht initialisierst.
Methoden:
Eine Methode gibt deinem Objekt kurz gesagt die Mglichkeit etwas zu tun.
Bei unserem Objekt Schler der Klasse Mensch wre eine Methode zum
Beispiel:
bewegeArm() {...}
Anweisungen:
Als Anweisung bezeichnet man einzelne Befehle die unter anderem in einer
Methode zusammengefasst werden. In dieser Form nennt man sie
Anweisungsblcke.
Schreibweise:
Im Programmieren gibt es einige Eigenheiten bei der Schreibweise. Hier ist
eine kurze Liste der Dinge die zu beachten sind:
Alle Anweisungen, Variablenvereinbarungen, usw. werden mit einem

Semikolon(;) abgeschlossen: e.g. "help=number2;" od. "private int x;"
Am Ende eines Methodennamens stehen immer zwei Klammern (): e.g.
public void calculate()
Geschwungene Klammern "{}" begrenzen immer den Inhalt einer Klasse
od. Methode und knnen zum Beispiel Anweisungsblcke enthalten:
e.g. "public void calculate() {x=a*b;}" od. public class cube {...}
Hier der Link zu einer Datei am Mail-Server die eine kleine

bersicht des eben Erklrte beinhaltet:

https://mail.htl-
kaindorf.ac.at/servlet/intranet?SITE=beforeAuth&sessionID=a0fe35e62
61c7f68d1fec01b49289465
The goal is to write one application and have it work on whatever device
your friends have.
Create a source document. Use an established protocol (in this case

the Java language)
Run your document through a source code compiler. The compiler
checks for errors and won't let you compile until it's satisfied that
everything will run correctly.
The compiler creates a new document, coded into Java bytecode.
Any device, capable of running Java will be able to interpret / translate
this file into something it can run. The compile bytecode is platform-
independent.
Your friends don't have a physical Java Machine, but they all have a
virtual Java machine running inside their electronic gadgets.
The virtual machine reads and runs the bytecode.
So what does it take to create and use an object?
You need two classes. One class for the type of object you want to use (Dog,
Alarm Clock, Television, etc.) and another class to test your new class. The
tester class is where you put the test-method and in that test () method you

create an access object of your new class type. The tester class has only
one job to try out the methods and variables of your new object class type.
Um Rechenoperationen auszufhren, bentigt man beim Programmieren

bestimmte Zeichen:
Operation Ausdruck Java

Addition 3+7 3+7
Subtraktion 6-4 6-2
Division 8:4 8/4
Multiplikation 5*9 5*9
Rest (modulo) 9 mod 3 9%3
Will man die Wurzel aus einer Zahl ziehen, braucht man diesen
Ausdruck: Math.sqrt (...);
Braucht man die Zahl Pi, bentigt man folgenden Befehl: Math.PI (...);
(Man kann natrlich auch die Zahl 3,141529... eingeben, das Ergebnis
wird dann jedoch ungenauer..)
Das if-Statement kann man sich in einem Programm wie eine Weggabelung
vorstellen. Das Programm entscheidet sich fr eine von zwei Mglichkeiten.
Natrlich tut es das nicht eigenmchtig. In einem if-Statement gibt es immer
eine Bedingung die zwei Werte(Variablen) miteinander vergleicht. Ein

einfaches Beispiel:
Du hast eine Gleichung zu rechnen. Wenn das Ergebnis der Variable x 4 ist,
hast du richtig gerechnet. Ansonsten ist die Gleichung falsch.
Java wrde diesen Satz folgendermaen ausdrcken:
if ( x = 4 )
{
Ergebnis = true;
}
else
{
Ergebnis = false;
}
Nun gibt es innerhalb einer Bedingung einige Dinge die zu beachten sind. Das
"==" zum Beispiel ist ein sogenannter "Vergleichoperator".
Davon gibt es sogar eine ganze Menge:
Schreibweise des Funktion(Aufgabe)

Operators in Java
== testet ob die zu vergleichenden
Werte gleich sind
>= testet ob der erste der zu
vergleichenden Werte grer oder
gleich gro wie der zweite Wert ist
<= testet ob der erste der zu
vergleichenden Werte kleiner oder
gleich gro wie der zweite Wert ist
!= testet ob die zu vergleichenden
Werte ungleich sind
&& ermglicht es mehrere Vergleiche in
eine Bedingung zu schreiben (beide
Bedingungen mssen erfllt sein)
ACHTUNG: KEIN
VERGLEICHSOPERATOR
|| ermglicht es mehrere Vergleiche in
eine Bedingung zu schreiben (nur
eine der Bedingungen muss erfllt
sein) ACHTUNG: KEIN
VERGLEICHSOPERATOR

Ein Struktogramm lsst sich am einfachsten als "Skizze" des Source-Codes
beschreiben. In einem Struktogramm lsst sich das gesamte Programm
darstellen und kann so eine groe Hilfe sein, wenn das Programm erst im Kopf
des Programmierers ensteht.
Hier ein einfaches Beispiel fr das Struktogramm von ex0021_PositiveSum
Sollte das Bild nicht angezeigt werden findet man es auch am "Mail-Server"
unter dem Namen "Strukted(ex0021)"!!!
Es werden 6 Zahlen darauf berprft, ob sie einen positiven Wert haben. Sollte
das zutreffen werden sie auf eine neue Variable addiert. In einem
Struktogramm kommen Bedingungen ganz ohne Klammern und ohne das
obligatorische "if" aus. Ein if-statement wird durch ein Dreieck mit einem ja-
Zweig und einem nein-Zweig dargestellt. Anweisungen bzw.
Anweisungsblcke werden in Rechtecken dargestellt. Diese Art ein Programm
zu "skizzieren" macht einem die Arbeit einfacher und bietet bessere bersicht.
JUnit is a simple, open source framework to write and run repeatable tests.
JUnit features include assertions for testing expected results:
public static void assertEquals (

double expected,
double actual,
double delta)
Assert that 2 doubles or floats are equal to within a positive delta.
delta: maximum delta between expected and actual for which both

numbers are still considered equal.
example:
0.2 -> failed

assertEquals (3.14, 3.17, 0.5);
Byte:
8 bits: -128 to 127
short:
16 bits: -32 768 to 32 767
int:
32 bits: -2 147 483 648 to 2 147 483647
long:
64 bits: huge to huge (264)

example:
int x;
x = 234;
byte b = 89
but:
int x = 24;
byte b = x;
-> You can't put a large value into a small cup.
floating point:
float ... 32 bits

double ... 64 bits
double big = 3 456 789
float f = 32.5f;
f: because Java thinks anything with a floating point is a double,

unless you use 'f' .
-) "and" gate
Mit dem "and" gate knnen mehrere Bedingungen innerhalb eines if-
statements verknpft werden. Beim "and"-gate allerdings mssen alle
Bedingungen erfllt werden, damit der Ja-Zweig des if-statements
erreicht werden kann. (Verknpfungszeichen beim "and"-gate sind
zwei kaufmnnische "und"-Zeichen: &&) SHIFT + 6

Hier knnte die Bedingung folgendermasen aussehen: if(EE1 && EE2)
{......}
-) "or" gate
Mit dem "or" gate knnen mehrere Bedingungen innerhalb eines if-
statements verknpft werden. Beim "or"-gate allerdings muss nur eine
der Bedingungen erfllt werden, damit der Ja-Zweig des if-
statements erreicht werden kann. (Verknpfungszeichen beim "or"-
gate sind zwei senkrechte Striche: || AltGr + <

Hier knnte die Bedingung folgendermasen aussehen: if(EE1 || EE2)
{......}
StringToInt:
String text = "123";
int x = Integer.parseInt (text);
text = "123.123"
double z = Double.parseDouble (text);

Manchmal brauchst du in einem Programm eine ganze Reihe von Zahlen, die
keinen bestimmten Wert annehmen mssen. Viele Zahlen also, die der User
deines Programmes ganz frei whlen kann. Diese Zahlenreihe(n) fasst du
dann in einem sogenannten Array zusammen. Ein Array ist im Grunde nichts
anderes als die Zusammenfassung mehrerer Variablen zu einem Feld. Deshalb
nennt man Arrays auch Feldvariablen. Aber Achtung! Das Array selbst ist
keinesfalls eine Variable, wie zum Beispiel ein Integer, die einen Wert enthlt.
Ein Array ist eine Objekt und enthlt nur einen Zeiger, der auf den Speicherort
verweist, an dem der Inhalt deines Arrays gespeichert ist.
Ein Beispiel: Du hast ein Array von vier Integer-Variablen.
1 2 3 4
2
Array
1 Das erstellte Array
1 2 Der Zeiger, der auf den
Speicher verweist
3 Der Speicher
Jetzt sollte man allerdings keinesfalls glauben, dass ein Array nur mit Integer
Variablen gefllt sein kann. Genauso gut knnte man ein Array aus Double
oder Float Variablen machen. Ein anderes Beispiel ist die Zeichenkette String.
Ein String ist, wie wir wissen auch nichts anderes als ein Objekt. Aber noch viel
prziser ausgedrckt, ist ein String ein Array, gefllt mit Character Variablen
(char). Vermutlich wegen der hufigen Anwendung des Strings jedoch,
vereinheitlichte man ihn als Objekt in Java.

String (123) und Int (123)
Der Computer unterscheidet niemals (unaufgefordert), ob du Ziffern oder
Buchstaben eingibst. Wenn du Buchstaben eintippst, kann der Computer
logischerweise nicht damit rechnen, allerdings wenn du Ziffern eintippst, sollte
das doch funktionieren. Falsch! Der Computer kann nicht unterscheiden, ob
du Zahlen oder Buchstaben eintippst. Er hlt deine gesamte Eingabe fr Text
und kann nicht wirklich etwas damit anfangen. Nur wie wandelt man nun
einen String (z.B. String text1 = 123 bzw. String text2 = 123.00), in einen
Integer um. Java bietet hier eine komfortable Methode an:
Integer.parseInteger(text1) bzw. Double.parseDouble(text2)
Doch fr alle, die hinter die Fassade dieser vorgefertigten Methode blicken
wollen gibt es das im Unterricht durchgenommene Bespiel ex0025_StringToInt.
+ charToInt (in value : char) : int
9 ifs .. value == 1
switch (value)
{
case 1 : help = 1;
break;
case 2 : help = 2;
break;
case 3 : help = 3;
break;
.
.
.

case 9 : help = 9;
break;
default : help = 0;
}
Whrend du mit Strings arbeitest, wirst du bemerken, dass du sie mit == und !=
vergleichen kannst. Allerdings irgt dies einige Fallen in die man nur zu leicht
hineinfallen kann.
Ein einfaches Beispiel:
String text1 = HELP!; String text2 = HELP!; boolean help;
if(text1 == text2)
{
HELP!
HELP!
wird
verglichen
help = true;
}
else
{
help = false;
}
Man sollte meinen, dass dieser Test eindeutig den Wert true ausgeben wird,

da die Strings text1 und text2 ja dieselben Wrter enthalten (HELP!)
ABER ACHTUNG!!! Ein String ist keine Variable, sondern ein Objekt/Array und
besitzt daher nicht direkt einen bestimmten Wert, sondern einen Zeiger der
auf die Inhalte des Objekts im Speicher zeigt. Ein Test zweier Strings mittels
Vergleichsoperatoren, vergleicht nicht deren Inhalt, sondern nur die Zeiger
und
somit den Speicherplatz des Inhalts.
Genau genommen wre der Vergleich aber auch nicht false sondern
unbestimmt. Strings werden nmlich in einem sogenannten String-Pool
abgespeichert und der Test vergleicht auch ob ein String schon im String-Pool
vorhanden ist. Aber das ist ein bisschen zu kompliziert um es hier zu erklren-
Strings sollte man daher mit der sogenannten equals() Methode

vergleichen:
String text1 = HELP!; String text2 = HELP!; boolean help;
if(text1 equals(text2))
{
help = true;
}
else
{
help = false;
}
Dieser Test wird jetzt sehr wohl den Wert true ausgeben, da die equals()
Methode zwei Strings auf ihre characers (char) und somit auf ihren Inhalt
vergleicht.
Anders sieht das Vergleichen von gewhnlichen Objekten (wie eir sie in
unseren
Tester classes erstellen) aus hier ist es nmlich sehr wohl erlaubt die
== und != Operatoren zu verwenden.
int x = 7; (Variable mit eindeutigem Wert)

Book b= new Book(); (Objekt mit Zeiger auf den Speicherplatz)
Book c = new Book();
if(b==c)
{|| dieser Vergleich ergibt fasle da zwei verschiedene Objekte verglivhen
werden.}
Book a = c;
if(a==c)
{|| Dieser Vergleich ergibt true, da das Objekt a alle Werte von c
bernommen hat.}
if(a==b)
{||false}
for (sum) while do-while
int i = 0;
sum = 0;
int i; int i = 0;
sum = 0; sum = 0;
do
{
for (i=0; i<nums.length; while (i<nums.length)
if (nums.length > 0)
i++) {
{
{ sum = sum + nums[i];
sum = sum + nums[i];
sum = sum + nums[i]; i++;
i++;
} }
}
while (i<nums.length);

Wir alle kennen Arrays Felder von primitiven Datentypen.
Initialisierung: int nums = new int[5]
Jetzt wird ein Array mit fnf Pltzen erzeugt.
0 0 0 0 0
Es gibt auch noch 2-dimensionale Arrays:
int nums = new int[3][3]
Es wird ein Feld mit 3 Pltzen in die x-Richtung und 3 Feldern in die y-Richtung
erstellt.
000 00 002
1
010 01 012
1
020 02 022
1
Mit einer einfachen for-Schleife kann man allen Feldern des Arrays Werte
zuweisen.
int r, c;
for(r=0; r<3; r++)
{
for(c=0; c<3; c++)
{
nums[r][c]=1;
}
}

Mithilfe von 2-dimensionalen Arrays und GUI-Applikationen haben wir den
Klassiker unter den Spielen Tic Tac Toe programmiert.
Als erstes sind einige berlegungen anzustellen um zu wissen wie man so ein
Projekt angeht. Folgendes muss beachtet werden:
Erzeugung der Spieloberflche und alle Felder auf den Wert 0 setzen.
Bei Klick auf ein Feld, dem Feld den Wert des Spielers zuweisen.
Beim erneuten Klick den Spieler wechseln und den neuen Wert zuweisen.
Kein berschreiben schon besetzter Felder zulassen.
berprfen ob die Summe einer Zeile, Spalte oder Diagonale 3 bzw. -3
betrgt.
Wenn ja, hat der Spieler dessen Summe 3 bzw. -3 ist gewonnen.
Als nchstes berlegt man sich wie man all diese Aufgaben in Methoden
aufteilt. Diese Art der Aufgabenverteilung innerhalb eines Programms nennen
wir Divide & Conquer.
Das fertige Programm sieht folgendermaen aus:
und besteht aus diesem Quellcode:
Java Class:
public class TicTacToe

{
private int[][] nums;

private int player;
private int LENGTH;
private int row, column;
public int getPlayer()

{
return player;
}
public void nextPlayer()

{
if (player == 1)
{
player = -1; // O ... -1
} else
{
player = 1; // X ... 1
}
}
public int gameOver()

{
int win = 0;
int[] row = new int[LENGTH];

int[] column = new int[LENGTH];
int d1 = 0;
int d2 = 0;
for (int i = 0; i < LENGTH; i++)

{
for (int j = 0; j < LENGTH; j++)
{
row[i] = row[i] + nums[i][j];
if (row[i] == LENGTH)
{
win = 1;
}
if (row[i] == -LENGTH)
{
win = -1;
}

}
}
for (int i = 0; i < LENGTH; i++)
{
for (int j = 0; j < LENGTH; j++)
{
column[i] = column[i] + nums[j][i];
if (column[i] == LENGTH)
{
win = 1;
}
if (column[i] == -LENGTH)
{
win = -1;
}
}
}
d1 = nums[0][0] + nums[1][1] + nums[2][2];

if (d1 == LENGTH)
{
win = 1;
}
if (d1 == -LENGTH)
{
win = -1;
}
d2 = nums[0][2] + nums[1][1] + nums[2][0];

if (d2 == LENGTH)
{
win = 1;
}
if (d2 == -LENGTH)
{
win = -1;
}
return win;
}
public boolean check(int row, int column)

{
boolean result = false;
if (nums[row][column] == 0)

{
result = true;
}
return result;
}
public void nextMove(int row, int column)

{
nums[row][column] = player;
}
public void print()

{
int r, c;
for (r = 0; r < LENGTH; r++)
{
for (c = 0; c < LENGTH; c++)
{
System.out.print(nums[r][c] + " ");
}
System.out.println(""); // Zeilenumbruch
}
}
public void init()

{
player = 1;
LENGTH = 3;
nums = new int[LENGTH][LENGTH];

int r, c;
for (r = 0; r < LENGTH; r++)
{
for (c = 0; c < LENGTH; c++)
{
nums[r][c] = 0;
}
}
}
public void calculateNextMove()

{
int[] r = new int[LENGTH];
int[] c = new int[LENGTH];
do

{
row = (int) (3 * Math.random());
column = (int) (3 * Math.random());
} while (!check(row, column));
public int getColumn()

{
return column;
}
public int getRow()

{
return row;
}
}
GUI Klasse:
public class GUI extends javax.swing.JFrame

{
private TicTacToe ttt = new TicTacToe();

private int count;
private boolean game;
/** Creates new form GUI */

public GUI()
{
initComponents();
ttt.init();
ttt.print();
setSize(300, 300);
}
public void updateView(char row, char column)
{
switch (row)
{
case '0':
if (column == '0')
{
if (ttt.getPlayer() == 1)
{
bt00.setText("X");
bt00.setEnabled(false);

} else
{
bt00.setText("O");
}
}
if (column == '1')
{
{
bt01.setText("X");
} else
{
bt01.setText("O");
}
}
if (column == '2')
{
{
bt02.setText("X");
} else
{
bt02.setText("O");
}
}
break;
case '1':
if (column == '0')
{
{
bt10.setText("X");
} else
{
bt10.setText("O");
}
}
if (column == '1')
{

{
bt11.setText("X");
} else
{
bt11.setText("O");
}
}
if (column == '2')
{
{
bt12.setText("X");
} else
{
bt12.setText("O");
}
}
break;
case '2':
if (column == '0')
{
{
bt20.setText("X");
} else
{
bt20.setText("O");
}
}
if (column == '1')
{
{
bt21.setText("X");
} else
{
bt21.setText("O");

}
}
if (column == '2')
{
{
bt22.setText("X");
} else
{
bt22.setText("O");
}
}
break;
default:
System.out.println("Fehler !!!");
}
}
public int charToInt(char c)

{
switch (c)
{
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;

}
}
private void onClick(java.awt.event.ActionEvent evt)
{
System.out.println("onClick");
System.out.println(evt.getActionCommand());
String ac = evt.getActionCommand();
char row = ac.charAt(0);
char column = ac.charAt(1);
if (ttt.check(charToInt(row), charToInt(column)) == true)

{
ttt.nextPlayer();
updateView(row, column);
ttt.nextMove(charToInt(row), charToInt(column));
ttt.print();
ttt.gameOver();
count++;
if (ttt.gameOver() != 1)
{
if (game == true)
{
ttt.nextPlayer();
ttt.calculateNextMove();
updateView(intToChar(ttt.getRow()), intToChar(ttt.getColumn()));
ttt.nextMove(ttt.getRow(), ttt.getColumn());
ttt.print();
ttt.gameOver();
count++;
}
}
}
if (count == 9 && ttt.gameOver() != 1 && ttt.gameOver() != -1)

{
JOptionPane.showMessageDialog(this, "Das Spiel ist unentschieden!!!",
"Round Finished", JOptionPane.INFORMATION_MESSAGE);
setEnabled();
}
if (ttt.gameOver() == -1)
{

JOptionPane.showMessageDialog(this, "Spieler 1 hat gewonnen!!!",
setEnabled();
}
if (ttt.gameOver() == 1)
{
JOptionPane.showMessageDialog(this, "Spieler 2 hat gewonnen!!!",
setEnabled();
}
}
public char intToChar(int value)
{
switch (value)
{
case 1:
return '1';
case 2:
return '2';
default:
return '0';
}
}
.. (2 Punkte) = Verzeichnis eine Ebene hher

. (1 Punkt) = aktuelles Verzeichnis
\ (Backslash) = Trennung zwischen Verzeichnis und Unterverzeichnis
? (Fragezeichen) = Platzhalter fr ein Zeichen
* (Stern) = Platzhalter fr unbegrenzt viele Zeichen

Befehl Beschreibung Anwendung
dir Anzeige des Verzeichnisinhaltes dir
cd
cd change directory = Verzeichnis wechseln folder1\folder2\fol
der3
wechselt in aktuelles Verzeichnis (in welches man
c:
vorher mit cd gewechselt hat)
d: c:
auf dem jeweiligen Laufwerk, wobei c: bzw. d:
usw.
fr den Laufwerksbuchstaben stehen.
mkdir,
make directory = Verzeichnis erstellen md Pfad
md
rmdir,
remove directory = Verzeichnis lschen rd Pfad
rd
ren,
ren akutellerName
renam Datei umbenennen
neuerName
e
Dateien oder Ordner verschieben bzw. move Quellpfad
move
umbenennen Zielpfad
copy Quellpfad
copy Dateien kopieren
Zielpfad
del,
delete = Dateien lschen del Pfad
erase
exit schliet die Konsole exit
try
{
f.readInput();
}
catch (NumberFormatException ex)

{
System.out.println (Falsche Eingabe); oder
System.out.println(ex.getMessage());

Alert (Handy Application)
try
{
.
.
.
}
catch (Exception ex)

{
Alert a = new Alert (FEHLER!!!);
a.setType(AlertType.ERROR);
a.setString (ex.getMessage());
display.setCurrent[a, myForm);
}
Unterschied zwischen Array und Collection
Array
Int [] nums = new int [ 10 ];
Nums [ 3 ] = 4;
/ / / 4 / /
0 1 2 3 9

Collection
Vector list = new Vector() ;
List
Vector
noch leer
Size () . 0
List.addElement ( new Integer (4));
Zur Colletion
Bsp. Zum Erstellen einer Collection mit einem Default Constructor
Private Verctor list;
Public CollectionTester()
{
List = new Vector ();
}
Public void test ()
{
Int i;
For ( i = 0; I < 10; I ++)
{
Integer obj. = new Integer ( I + 1 );
List.add ( obj. );
}
Sout ( list.size() );
Sout ( list.toString () );

0 1 9
1 2 9
Befehle bei der Collection
add ( int index, Object obj. ) -> fgt ein Element an einem best. Index
hinzu.
add (Object obj) -> fgt ein Element am Ende der Liste hinzu.
addElement ( Object obj. ) -> gleich wie 1)
clear () -> lscht den kompletten Inhalt ( Wert = 0 )
contains ( Object obj. ) -> schaut nach ob z.B. 5 enhalten ist !
elementAt ( int index ) -> auf ein Element auf einem best. Index
zugreifen
get ( int Index ) -> gleich wie 6)
insertElementAt ( object obj; int Index ) -> gleich wie 2) nur andere
Parameter Reihenfolge
isEmpty () -> schaut ob die Collection wirklich leer ist oder nicht ( true
false )
size () -> liefert die Gre der Collection
remove ( int index ) -> lscht das Element an einem best. Index
remove ( object obj. ) -> lscht nach eingegebenem Wert

Befehle bei der Array List
add ( int index, Object obj. ) -> fgt ein Element an einem best. Index
hinzu.
add (Object obj) -> fgt ein Element am Ende der Liste hinzu.
clear () -> lscht den kompletten Inhalt ( Wert = 0 )
contains ( Object obj. ) -> schaut nach ob z.B. 5 enhalten ist !
get ( int Index ) -> gleich wie 6)
isEmpty () -> schaut ob die Collection wirklich leer ist oder nicht ( true
false )
size () -> liefert die Gre der Collection
remove ( int index ) -> lscht das Element an einem best. Index
remove ( object obj. ) -> lscht nach eingegebenem Wert
Beispiel Collections anhand vom Average Beispiel
Code :
Version 1
Public double average ()

{
Double sum = 0;
Int size = list.size;
For ( int I = 0; I < = size 1; I ++ )

{
Sum = sum + list [ I ];
}
Return ( sum / size );
}
Version 2
Public double average ()

{
Double sum = 0;
Int size = list.size;
Int I = 0;

While ( I < size )
{
Sum = sum + list [ I ];
I ++;
}
Return ( sum / size );
}
Neben Applikationen fr die Konsole oder das Handy, kann man natrlich
auch die bekannten Desktop-Applikationen (GUI-Applikationen)mit Java
schreiben. In Verbindung mit 2-dimensionalen Arrays und GUI-Applikation
haben wir das Spiel Tic-Tac-Toe programmiert.
Fr eine GUI-Applikation braucht man eine Java JFrame Form Datei. Diese
Datei besteht
aus einer
Oberflche:
Diese
Oberflche
kann man mit
verschiedenen
Schaltflchen,
Anzeigen,
Mens u.a.
ausstatten.
Auerdem kann
man der

Oberflche ein sogenanntes Layout zuweisen.
Dieses Layout ist dafr verantwortlich, wie die Elemente angeordnet werden.
Zum Beispiel gibt es das Grid Layout. Bei diesem Layout werden alle Elemente
an einem einstellbaren Raster ausgerichtet. Zum Beispiel 3x3:

Hier
wurden
neun
Buttons
mittels
Grid
Layout
ausgerichtet (in einem 3x3 Raster).
Mit Low Level API Programmen kann man in Java einfache geometrische
Formen und Objekte graphisch darstellen. Dabei bedient sich Java an
Canvas, einer Code-Struktur die als eine Art Leinwand dient, um die Formen
darzustellen.
Mit einer GUI Oberflche kann man das gezeichnete auch am Bildschirm
ausgeben. Dazu bentigt man:
Zwei Klassen (GUI, Java Klasse)

Die Erweiterung extends JPanel hinter dem Klassennamen um die
Java Klasse mit der GUI zu verknpfen.
Auf Source->Insert Code->Override Method-
>paintComponent(Graphics g)

In diese Methode kommen alle Zeichenbefehle in der Form:
g.Zeichenbefehl(Koordinaten /Parameter);

Auch in der GUI sollte man einige Dinge beachten:
Ein Panel erstellen und mit dem Border Layout versehen

Bei den Eigenschaften des Panels unter dem Reiter Code Custom
Creation Code auswhlen und new Canvas(); hinzufgen um das
Panel mit der Java Klasse zu verbinden.
Die wichtigsten Zeichenbefehle in Canvas:
g.setColor(Color.FARBE);
g.drwaline(xStartKoordinate, yStartKoordinate, xEndKoordinate,
yEndKoordinate);
g.drawRect/Oval(xStartKoordinate, yStartKoordinate, Breite, Hhe);
g.fillRect/Oval(xStartKoordinate, yStartKoordinate, Breite, Hhe);

g.draw/fillArc(xStartKoordinate, yStartKoordinate, Startwinkel,
Endwinkel);

Ping Pong
Als bisheriges Highlight in Sachen Low Level API haben wir einen weiteren
Spieleklassiker programmiert. Ping Pong:
Dazu muss die Klasse mit extends GameCanvas implements Runnable

erweitern.
Danach werden die Parameter fr die Objekte am Bildschitm
festgelegt(Ball, Paddel): public Pong(MIDlet midlet).
Mithilfe von GameCanvas werden die Tastendrucke am Handy in einer

Endlosschleife berprft und auf das Display bertragen: private void
update(int keyStates).
Nun werden die Objekte gezeichnet: private void render(Graphics g).
In der Methode public void paint(Graphics g) wird private void
render(Graphics g) ausgefhrt.
Und schlielich fhrt public void run() die Schleife fr die Tastendrucke
aus und fhrt die brigen Methoden zusammen.
public class Pong extends GameCanvas implements Runnable
private int ballX, ballY, d, speedX, speedY;
private int paddleX, paddleY, padlength, padheight;
private volatile Thread gameloop;

final private GUI gui;
public Pong(MIDlet midlet)
super(true);
paddleX = (getWidth() / 2) - (padlength / 2);
paddleY = 250;
padlength = 60;
padheight = 20;
d = 40;
ballX = (getWidth() / 2) - (d / 2);
ballY = (getHeight() / 2) - (d / 2);
speedX = 1;
speedY = -1;
this.gui=null;
private void update(int keyStates)
if ((keyStates & LEFT_PRESSED) != 0)
paddleX = paddleX - 1;
if ((keyStates & RIGHT_PRESSED) != 0)

{
paddleX = paddleX + 1;
if ((keyStates & GAME_A_PRESSED) != 0)
ballX = (getWidth() / 2) - (d / 2);
ballY = (getHeight() / 2) - (d / 2);
if ((keyStates & GAME_B_PRESSED) != 0)
gui.startApp();
ballX = ballX + speedX;
ballY = ballY + speedY;
private void render(Graphics g)
g.setColor(255, 255, 255);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(255, 0, 0);
g.fillArc(ballX, ballY, 20, 20, 0, 360);
g.setColor(0, 0, 0);
g.fillRect(paddleX, paddleY, padlength, padheight);

}
public void paint(Graphics g)
render(g);
protected void showNotify()
gameloop = new Thread(this);
gameloop.start();
protected void hideNotify()
gameloop = null;
public void run()
Graphics g = this.getGraphics();
Thread t = Thread.currentThread();
while (t == gameloop)
update(getKeyStates());

render(g);
flushGraphics();
if (ballX + d / 2 == getWidth())
speedX = -1;
if (ballX - d / 2 == 0)
speedX = 1;
if (ballY - d / 2 == 0)
speedY = 1;
if (ballY + d / 2 == paddleY)
if (ballX > paddleX && ballX < paddleX + padlength)
speedY = -1;


Wiki - Jakob Raith - Paul Polak - Laura Dietrich

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Wiki - Jakob Raith - Paul Polak - Laura Dietrich

Cargado por

Copyright:

Formatos disponibles

INHALTSVERZEICHNIS

Befehle bei der Collection .................................................................................32

Befehle bei der Array List ....................................................................................33

Beispiel Collections anhand vom Average Beispiel .........................................33

WIKI_PUC Seite 1 von 44 2009/10

Allgemeines zum Verstndnis frs Programmieren ( mit JAVA !! )

Die 5 allgemein angestrebten Ziele in JAVA :

Sie soll eine einfache objektorientierte, verteilte und vertraute

Sie soll hoch performant sein.

WIKI_PUC Seite 2 von 44 2009/10

Im Unterricht beschftigen wir uns mit dem objektorientierten Programmieren.

WIKI_PUC Seite 3 von 44 2009/10

Lokale Variablen bekommen keinen vordefinierten Wert, solltest du ihnen

Alle Anweisungen, Variablenvereinbarungen, usw. werden mit einem

Hier der Link zu einer Datei am Mail-Server die eine kleine

WIKI_PUC Seite 4 von 44 2009/10

Create a source document. Use an established protocol (in this case

So what does it take to create and use an object?

WIKI_PUC Seite 5 von 44 2009/10

Um Rechenoperationen auszufhren, bentigt man beim Programmieren

Operation Ausdruck Java

WIKI_PUC Seite 6 von 44 2009/10

Java wrde diesen Satz folgendermaen ausdrcken:

Davon gibt es sogar eine ganze Menge:

Schreibweise des Funktion(Aufgabe)

WIKI_PUC Seite 7 von 44 2009/10

Hier ein einfaches Beispiel fr das Struktogramm von ex0021_PositiveSum

public static void assertEquals (

Assert that 2 doubles or floats are equal to within a positive delta.

WIKI_PUC Seite 8 von 44 2009/10

0.2 -> failed

WIKI_PUC Seite 9 von 44 2009/10

-> You can't put a large value into a small cup.

float ... 32 bits

f: because Java thinks anything with a floating point is a double,

WIKI_PUC Seite 10 von 44 2009/10

WIKI_PUC Seite 11 von 44 2009/10

WIKI_PUC Seite 12 von 44 2009/10

Ein Beispiel: Du hast ein Array von vier Integer-Variablen.

WIKI_PUC Seite 13 von 44 2009/10

Integer.parseInteger(text1) bzw. Double.parseDouble(text2)

+ charToInt (in value : char) : int

WIKI_PUC Seite 14 von 44 2009/10

Ein einfaches Beispiel:

String text1 = HELP!; String text2 = HELP!; boolean help;

WIKI_PUC Seite 15 von 44 2009/10

Strings sollte man daher mit der sogenannten equals() Methode

String text1 = HELP!; String text2 = HELP!; boolean help;

int x = 7; (Variable mit eindeutigem Wert)

WIKI_PUC Seite 16 von 44 2009/10

Book c = new Book();

{|| dieser Vergleich ergibt fasle da zwei verschiedene Objekte verglivhen

for (sum) while do-while

WIKI_PUC Seite 17 von 44 2009/10

Initialisierung: int nums = new int[5]

Jetzt wird ein Array mit fnf Pltzen erzeugt.

Es gibt auch noch 2-dimensionale Arrays:

int nums = new int[3][3]

WIKI_PUC Seite 18 von 44 2009/10

Das fertige Programm sieht folgendermaen aus:

und besteht aus diesem Quellcode:

public class TicTacToe

WIKI_PUC Seite 19 von 44 2009/10