Inhaltsverzeichnis
Programmbeispiele
Lottozahlen
Beschreibung
Man kann sich mit Java ein Programm schreiben, dass sich Lottozahlen ausdenkt. In diesem Beispiel die Variante des „6 aus 49“-Lotto. Eine Superzahl wird sich auch ausgedacht. Die Zahlen (mit der Superzahl) werden auf Befehl generiert und auf Wunsch auf der Konsole ausgegeben. Doppelte Zahlen werden nicht erzeugt, da ich eine (oder mehrere) if-Funktion(en) eingebaut habe, die dieses vermeidet. Allerdings sieht das ganze sehr unübersichtlich aus..
Trotzdem viel Glück beim Lottospielen 
Das Programm
/** * Lottozahlen * Autor: JW * Datum: 2007/08 */ public class Lotto { // Instanzvariablen - es werden 7 Stueck benoetigt int a, b, c, d, e, f, g; /** * Konstruktor für Objekte der Klasse Lotto * ist in diesem Fall unwichtig */ public Lotto() { } public void denkeDirLottozahlen() { a = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken b = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken c = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken d = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken e = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken f = (int) (Math.random() * 48) +1; // Eine Zahl zwischen 1 und 49 ausdenken g = (int) (Math.random() * 10); // Eine Zahl zwischen 0 und 9 ausdenken /** * Doppelte Zahlen vermeiden -> neue ausdenken! */ if (a == b) { a = (int) (Math.random() * 48) +1;} if (a == c) { a = (int) (Math.random() * 48) +1;} if (a == d) { a = (int) (Math.random() * 48) +1;} if (a == e) { a = (int) (Math.random() * 48) +1;} if (a == f) { a = (int) (Math.random() * 48) +1;} if (b == c) { b = (int) (Math.random() * 48) +1;} if (b == d) { b = (int) (Math.random() * 48) +1;} if (b == e) { b = (int) (Math.random() * 48) +1;} if (b == f) { b = (int) (Math.random() * 48) +1;} if (c == d) { c = (int) (Math.random() * 48) +1;} if (c == e) { c = (int) (Math.random() * 48) +1;} if (c == f) { c = (int) (Math.random() * 48) +1;} if (d == e) { d = (int) (Math.random() * 48) +1;} if (d == f) { d = (int) (Math.random() * 48) +1;} if (e == f) { e = (int) (Math.random() * 48) +1;} } public void gibLottozahlen() { System.out.println("Die Lottozahlen sind: " + a + " " + b + " " + c + " " + d + " " + e + " " + f); System.out.println("Superzahl: " + g); } }
Erklärung
veraendernde Methode denkeDirLottozahlen: Hier werden den Variablen a, b, c, d, e und f Zahlen zwischen 1 und 49 zugewiesen. Die Spielmethode ist schließlich 6 aus 49.. der Befehl hier für lautet:
(int) (Math.random() * 48) +1;
Die +1 steht dafür, dass die generierte Zahl mit 1 addiert wird. So wird z.B. aus der Zahl 0 eine 1 und aus der Zahl 48 eine 49. Somit können alle Zahlen zwischen 1 und 49 vorkommen. Die Variable g erhält eine Zahl zwischen 0 und 9.
Zusätzlich zu dem Generieren kommt das Vermeiden von doppelten Zahlen mit einer Reihe von if-Funktionen.
sondierende void Methode gibLottoZahlen: In dieser Methode werden die Werte der Variablen a bis f ausgegeben. Die Zahlen 6 aus 49, also a, b, c, d, e und f, werden zusammen in einer Reihe auf der Konsole ausgegeben, während die Superzahl g nochmal extra in einer Zeile ausgegeben wird. Hierzu wird der Befehl benoetigt:
System.out.println("TEXT");
Lotto - Variante
Unter Verwendung eines Sets, lässt sich einiges an Programmieraufwand einsparen.
import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.Random; /** * @author AB */ public class Lotto { public static HashSet<Integer> generateLotto(){ HashSet<Integer> values = new HashSet<Integer>(); // Ein Set zur Vermeidung von doppelten Werten while(values.size() < 6){ // Solange neue Werte generieren, bis Set 6 values.add(new Random().nextInt(49)+1); // Werte enthält. } return values; } public static void print(Collection<Integer> values){ // Interface Collection dient zur flexiblen Nutzung. ArrayList<Integer> sortedValues = new ArrayList<Integer>(values); Collections.sort(sortedValues); // sortier-Kram Iterator<Integer> it = sortedValues.iterator(); // Ein Iterator wird beschaffen. while(it.hasNext()){ // Solange es noch ein Element in der Collection gibt, System.out.println(it.next()); // gib das nächste Element aus. } } public static void main(String[] args) { print(generateLotto()); } }
Weihnachtsbaum
Das Ziel diese Programmes ist die Erstellung eines Weihnatsbaumes mit variabler Breite,der auf die Konsole ausgegeben wird. (Aufgabe der letzten Stunde vor den Ferien)
weihnachtsbaum 1.0
Variablen Erklärung
String z; //Parameterübergabe des "zeichen"s (z als anfangsbuchstabe) String zaus; //Der Wert "z", der ausgegeben wird (z+aus(ausgabe)) String zfest; //Der Wert "z", der sich nie ändert (z+fest) String leer; //"leer" für " " (leerzeile) String leeraus; //"leeraus" ,da diese leerzeilen ausgegeben werden
int b; Parameterübergabe der „breite“(„b“ als kurzform) (auch zum ausrechnen der abstände zum rand benutzt) int bfest; b+fest —→ ändert sich nicht
int rechenb; // "rechenb" mit dieses "b" speichert die meisten zwischenrechnungen int einrückenfix; // zur übergabe von ergebnissen genutzt int forzähler; // zählt in einer bestimmten forschleife die durchgänge und errechnet so wie viel leerzeilen weniger eingerückt werden muss
0.1
-einrücken mit „ “ (noch nicht richtig eingerückt:-?)
-variables zeichen
0.2
-added Stamm
0.3
-added kommentare8-)
0.4
-linkes einrücken gut aber zulange zeilen:?:
0.5
-mit 10 als breite klappts nu^^
1.0
-sollte nu mit jeder zahl klappen
-baum wird nun sehr weit nach rechts verschoben (auch aus dem bild raus)
-hoffnungsvollerweise alles variable
-angabe der breite beim erstellen gibt die stammdicke und die breite der oberen reihe an
-beim erstellen muss auch ein zeichen angegeben werden mit dem der baum „gemalt“ wird (in üblicher »String« [zB„X“] Form)
1.1
-Variablen reset zum verhindern von zweitzeichnungen (die verzerrt gewesen wären)
- neue Methode zum nachträglichen einstellen der breite und des zeichens
-verhindern von breitenangaben unter 5 ,da diese kein vernünftiges/gutes Bild ausgeben
-sinnvollere variablen
Programm
/** * Weihnachtsbaumhalt (mit viel phantasieeeeeeeeeeeeeeeeeee) * * IB * 1.1 */ public class Baum { String z; //string variablen zum diversen speichern/bearbeiten des "zeichen"s String zaus; String zfest; String leer; String leeraus; int b; //int variablen zum rechnen bzw speichern der angegebenen "breite" int bfest; int rechenb; int einrückenfix; int forzähler; public Baum(int breite,String zeichen) //benutzer gibt gewünschte breite bzw gewünschtes zeichen an { leer = " "; //übertragen der angegeben werte/zeichen bzw =0setzung der variablen zfest = zeichen; z = zeichen; zaus = " "; leeraus = " "; rechenb = 0; bfest = breite; b = breite; einrückenfix = 0; forzähler = 0; if(breite<=5) { System.out.println("Error: Breite zu gering"); bfest = 0; b = 0; } } public void zahlentausch(int breite,String zeichen) //neue maße für den baum angeben { leer = " "; //übertragen der angegeben werte/zeichen bzw =0setzung der variablen zfest =zeichen; z = zeichen; zaus = " "; leeraus = " "; rechenb = 0; bfest = breite; b = breite; einrückenfix = 0; forzähler = 0; } public void zeichnen() //baumzeichnen { rechenb = (b*b-b)/2; //ausrechnen der anzahl der leerstellen die eingerückt werden einrückenfix = rechenb; for(int i=1;i<=rechenb;i++) //string variable "leer" wird "rechenb" mal um " " erhöht { leer = leer + " "; } for(int u=1;u<=b/2;u++) //block wird 1/2 "b" mal wiederholt { for(int y=1;y<=b;y++) // "zaus" wird "b" mal um "zfest" erhöht (speichern über "z") { zaus = z + zfest; z = zaus; } leeraus = leer; //"leeraus" wird = "leer" gesetzt System.out.println(leeraus + zaus); //Ausgabe auf die konsole forzähler = forzähler + (b); rechenb = ((bfest*bfest-b)-forzähler)/2; //rechenb mit "zeichen" startwert "bfest" bestimmen leer = " "; //variable "leer" reseten for(int i=1;i<=rechenb;i++) //"rechenb" mal "leer" um " " erhöhen { leer = leer + " "; } } for(int h=1;h<=bfest/4;h++) // 1/4"bfest" mal den nächsten block { leer = " "; for(int f=1;f<=einrückenfix;f++) //"rechenb" mal "leer" um " " erhöhen { leer = leer + " "; } zaus = zfest; //"zaus" = "zfest" setzen for(int e=1;e<=bfest;e++) //"bfest" mal "zaus" um "zfest" erhöhen { zaus = zaus + zfest; } System.out.println(leer + zaus ); //ausgabe des ergebniss leer = " "; //nullsetzen (reseten) zfest = " "; z = " "; zaus = " "; leeraus = " "; rechenb = 0; bfest = 0; b = 0; einrückenfix = 0; forzähler = 0; } } }
Ballaufgabe
Variante 1
import java.applet.*; import java.awt.*; /* IB, JM*/ public class Ball extends Applet { int x; int y; int x1; int y1; int xrandom; int yrandom; int brems; public ball() { } public void paint(Graphics g) { x= (int) (Math.random() * 400) + 1; y= (int) (Math.random() * 400) + 1; xrandom= (int) (Math.random() * 400) + 1; yrandom= (int) (Math.random() * 400) + 1; if(xrandom>=0.5) { x1=0; } if(xrandom<0.5) { x1=1; } if(yrandom>=0.5) { y1=0; } if(yrandom<0.5) { y1=1; } for(int i=0;i<=9999;i++) { brems=i/20; if(x>=400) { x1=1; } if(x<=0) { x1=0; } if(y>=400) { y1=1; } if(y<=0) { y1=0; } if(x1==1) { x=x-1; balltwo(g,x,y,brems); if(y1==1) { y=y-1; balltwo(g,x,y,brems); } if(y1==0) { y=y+1; balltwo(g,x,y,brems); } } if(x1==0) { x=x+1; balltwo(g,x,y,brems); if(y1==1) { y=y-1; balltwo(g,x,y,brems); } if(y1==0) { y=y+1; balltwo(g,x,y,brems); } } if(y1==1) { y=y-1; balltwo(g,x,y,brems); if(x1==1) { x=x-1; balltwo(g,x,y,brems); } if(x1==0) { x=x+1; balltwo(g,x,y,brems); } } if(y1==0) { y=y+1; balltwo(g,x,y,brems); if(x1==1) { x=x-1; balltwo(g,x,y,brems); } if(x1==0) { x=x+1; balltwo(g,x,y,brems); } } } } public void balltwo(Graphics g,int xOval,int yOval,int slow) { g.setColor(Color.green); g.fillRect(0,0,450,450); g.setColor(Color.black); g.fillOval(xOval,yOval,50,50); g.setColor(Color.green); g.fillOval(xOval+15,yOval+15,20,20); pause(slow); g.setColor(Color.black); g.fillRect(0,0,450,450); g.setColor(Color.green); g.fillOval(xOval,yOval,50,50); g.setColor(Color.black); g.fillOval(xOval+15,yOval+15,20,20); pause(slow); g.setColor(Color.green); g.fillRect(0,0,450,450); g.setColor(Color.black); g.fillOval(400-xOval,400-yOval,50,50); g.setColor(Color.green); g.fillOval(400-xOval+15,400-yOval+15,20,20); pause(slow); g.setColor(Color.black); g.fillRect(0,0,450,450); g.setColor(Color.green); g.fillOval(400-xOval,400-yOval,50,50); g.setColor(Color.black); g.fillOval(400-xOval+15,400-yOval+15,20,20); pause(slow); } public void ball(Graphics g,int xOval,int yOval,int slow) { g.setColor(Color.black); g.fillOval(xOval,yOval,50,50); pause(slow); g.setColor(Color.white); g.fillOval(xOval,yOval,50,50); } private void pause(int ms) { try { Thread.sleep(ms); } catch(InterruptedException e){} } }
Variante 2
import java.applet.*; import java.awt.*; /** * Guck mal ein Ball! * * @author JW * @version 21.04.2008 */ public class Ball extends Applet { // Instanzvariable - ersetzen Sie das folgende Beispiel mit Ihren Variablen private boolean xbool; private boolean ybool; public void paint(Graphics g) { // x ist die Position des Balles auf der x-Achse int x; // y ist die Position des Balles auf der y-Achse int y; // speed braucht man fuer die Geschwindigkeit double speeddouble; int speedint; // Am Anfang mal 1... speeddouble=1.0; // X und Y Anfangspositionen des Balles werden erfunden x= (int) (Math.random() * 400) + 1; y= (int) (Math.random() * 400) + 1; // Some Information ANFANG g.setColor(Color.black); // Kasten 1 g.drawRect(0, 435, 190, 70); g.drawString("Groesse des Vierecks: 450x430", 2, 450); g.drawString("Groesse des Balls: 30x30",2,462); g.drawString("Ballfarben: mal rot, mal schwarz",2,474); g.drawString("© Julian Wieland",2,486); // Kasten 2 g.drawRect(190,435,280,60); g.drawString("Nach jedem Abprallen wird der Ball langsamer",200, 450); g.drawString("Das ist doof:",200,462); g.drawString("Man muss jedes mal mit Taskmanager beenden",200,474); g.drawString("..oder lange (sehr lange) warten",200,486); // Information ENDE // Anfangsbewegungsrichtung des Balles wird erfunden int weg; weg= (int) (Math.random() * 4); switch(weg) { case 0: // wenn weg 0 xbool=true; break; case 1: // wenn weg 1 xbool=false; break; case 2: // wenn weg 2 ybool=true; break; case 3: // wenn weg 3 ybool=false; break; default: xbool=true; // sonst so } // Anfangsbewegungen ENDE while(true) { // Rahmen muss gezeichnet werden, damit man sieht wo der Ball abprallt ANFANG g.setColor(Color.black); g.drawRect(0, 0, 450, 430); // Rahmen ENDE // Alles verschwinden lassen, damit der vorher gezeichnete Ball wieder verschwindet clear(g); // Ball wird gezeichnet ANFANG ball(g,x,y); // Ball ENDE /** Langsam(er) machen.. */ // speedint bekommt durch einen TypeCast den Wert von speeddouble (sleep nimmt nur int an) speedint=(int)speeddouble; sleep(speedint); // Ausgabe des Wertes auf Bildschirm (Kasten 1) g.setColor(Color.white); g.fillRect(2,487,150,12); g.setColor(Color.black); g.drawString("Geschw. Reduzierung:"+speeddouble,2,498); if(x==0 || x==420 || y==0 || y==400) { // wenn der Ball die Waende beruehrt, wird speeddouble um 0.1 erhoeht // und speedint bekommt dann den Wert von speeddouble, damit es fuer die sleep methode anerkannt wird speeddouble=speeddouble+0.1; // speeddouble runden speeddouble= Math.round(speeddouble*100)/100.0; } /** Langsam ENDE */ /** Abfragen zum Abprallen */ if(x>=420) { // wenn x 420 ist, xbool true, also: "ja, bitte umdrehen" -> Werte verkleinern xbool=true; } if(x<=0) { // wenn x 0 ist, xbool false, also: "nein, bitte wieder wie am Anfang" -> Werte vergroessern xbool=false; } if(y>=400) { // wenn y 400 ist, ybool true, also: "ja, bitte umdrehen" -> Werte verkleinern ybool=true; } if(y<=0) { // wenn y 0 ist, ybool true, also: "nein, bitte wieder wie am Anfang" -> Werte vergroessern ybool=false; } /** Abfragen ENDE */ // Abprallen ANFANG if(xbool==true) { // wenn wahr, Werte verkleinern -> umdrehen x=x-1; } if(xbool==false) { // wenn unwahr, Werte wieder vergroessern -> wieder normal x=x+1; } if(ybool==true) { // wenn wahr, Werte verkleinern -> umdrehen y=y-1; } if(ybool==false) { // wenn unwahr, Werte vergroessern -> wieder normal y=y+1; } // Abprallen ENDE } } // Ball Methode mit Blinki (haesslich) public void ball(Graphics g,int xposball,int yposball) { //schwarzer Ball!!! g.setColor(Color.black); g.fillOval(xposball,yposball,30,30); // nein! roter Ball!! sleep(1); g.setColor(Color.red); g.fillOval(xposball,yposball,30,30); } // Ball verschwinden lassen Methode public void clear(Graphics g) { g.setColor(Color.white); g.fillRect(1,1,449,429); } /** Pause */ private void sleep(int millis) { try { Thread.sleep(millis); } catch(InterruptedException e) { } } }
Notendurchschnitt
/**
* Diese Klasse berechnet den Notendurchschnitt einer Klausur.
* Geben Sie die Anzahl der geschriebenen Noten ein, angefangen mit den Einsen,
* um den Notendurchschnitt zu berechnen.
*
* (Dies ist eine Rekonstruierung der Aufgabe 6 aus der Informatikarbeit.
* Andere Lösungswege sind denkbar.)
*
* @author (PT)
* @version (11.01.2011)
*/
public class Durchschnitt
{
double alle;
double notenanz;
double[] note;
double dschnitt;
public Durchschnitt()
{
alle=0;
notenanz=0;
note = new double[6];
for(int i=0; i<6; i++)
{
note[i]=i+1;
}
}
public double noten(double einsen, double zweien, double dreien, double vieren, double fuenfen, double sechsen)
{
notenanz=einsen+zweien+dreien+vieren+fuenfen+sechsen;
alle=note[0]*einsen+note[1]*zweien+note[2]*dreien+note[3]*vieren+note[4]*fuenfen+note[5]*sechsen;
dschnitt=alle/notenanz;
System.out.println("Der Notendurchschnitt ist:"+dschnitt);
return dschnitt;
}
}
Schülerbeiträge 2007/08
