Bombentrichter
Archiv => 1./2. Semester => Praktikum 1./2. Semester => Topic started by: tiefenbass on April 22, 2008, 05:47:50 pm
-
Hallo Leute,
hier das Beispiel von mir aus dem Info-Praktikum 5./6. DS:
[attachment=1668]
MfG, Matthias
-
Weitere Beispiele findet ihr auch hier: https://iai82110.inf.tu-dresden.de/lehre/mw/index.html (Quelle:Vorlesung Informatik 2)
MfG, ich
-
Schreibe ein Programm, welches eine ganze Zahl von der Tastatur einliest und die dazugehörige Fakultät auf der Konsole ausgibt.
Schreibe ein Programm, welches die verwendeten Buchstaben einer beliebigen per Tastatur eingegebenen Zeichenkette auszählt und zu jedem der verwendeten Buchstaben die Anzahl auf der Konsole ausgibt.
Zusatz: es sollen nur die Buchstaben angezeigt werden, die auch verwendet wurden.
Schreibe ein Programm zum Lösen von quadratischen Gleichungen.
Programmiere einen (normalen) Würfel.
Simuliere eine Lottoziehung "6 aus 49". Die sechs Zahlen, die man tippt, soll man auf der Tastatur eingeben können.
Schreibe ein Programm, welches einen zufälligen Hexadezimalschlüssel (128bit) für WEP generiert und auf der Konsole ausgibt.
Zusatz: lass den Nutzer die Länge (64 oder 128 bit) und Anzahl benötigter Schlüssel angeben.
Implementiere einen Algorithmus, welcher einen einfachen Rechner (2 Operanden und 1 Operator) simuliert.
Schreibe einen Umrechner, der zwischen Zahlendarstellungen auf 2er, 8er, 10er und 16er Basis umrechnet.
MfG, Matthias
-
Hi Leute,
JUDE gibt es direkt hier: JUDE (http://jude-users.com/edujjude/jude-community-5_5.zip)
LG, ich
-
UML-Übersicht: http://www.oose.de/downloads/uml-2-Notationsuebersicht-oose.de.pdf
-
Lösung für Fakultät-Aufgabe:
/* Schreibe ein Programm, welches eine ganze Zahl von der
* Tastatur einliest und die dazugehörige Fakultät auf
* der Konsole ausgibt.*/
public class Fakultaet {
public static void main(String[] args) {
for (int i = 1; i < 6; i++) {
System.out.println(fakultaet1(i));
System.out.println(fakultaet2(i) + "\n");
}
}
/*
* 1. Beispiel: Berechnung mittels einer Zählschleife
*/
private static int fakultaet1(int n) {
int f = 1;
for (int i = 1; i < n; i++) {
f = f * (i + 1);
}
return f;
}
/*
* 2. Beispiel: Berechnung mittels rekursiver Methode
*/
private static int fakultaet2(int n) {
if (n < 2)
return n;
return n * fakultaet2(n - 1);
}
}
Version 2009
import java.util.Scanner;
public class Zahllesen {
/**
* Aufgabe:
* Schreibe ein Programm, welches eine ganze Zahl von der Tastatur einliest
* und die dazugehörige Fakultät auf der Konsole ausgibt.
*/
public static void main(String[] args) {
// es wird ein Objekt vom Typ Scanner deklariert und initialisiert.
Scanner scanner = new Scanner(System.in);
// nur deklarieren
int zahl;
// nur initialisieren
zahl = 0;
/*
* hier wird der Wert der Zahl ausgegeben danach erfolgt die Ausgabe der
* Aufforderung
*
*/
System.out.println(zahl);
System.out.println("bitte eine ganze positive Zahl eingeben:");
// mittels dem Objekt scanner wird ein Integer-Wert eingelesen
zahl = scanner.nextInt();
int ergebnis = 1;
// eine for-Schleife, wie sie am meisten benutzt wird
for (int i = 0; i < zahl; i++) { // i=i+1 ist das gleiche wie i++
ergebnis = ergebnis * (i + 1);
}
// ergebnis wird ausgegeben
System.out.println(ergebnis);
}
}
-
Neue Aufgabe zum Üben ^^
Teil 1
Folgendes ist gegeben:
von einer abstakten Klasse "Spielkarte" sollen Karten für verschiedene Kartenspiele spezifiziert werden.
Schreibe die Klasse "Spielkarte", und die Klassen für normale Spielkarten, für Uno-Karten und einem weiteren Kartenspiel.
Entwerfe die die Benötigten Klassen und stelle sie in in geeigneter Form in UML dar.
Erzeuge mit einer Testumgebung einen Kartensatz für "Rommé", Doppelkopf", "Uno" und einem weiterem Kartenspiel deiner Wahl.
MfG, ich
-
Hier ein Beispiel, wie man Mehrdimensionales realisieren kann. Als Beispiel wurden hier Arrays genommen. Im Grundprinzip funktioniert das Schema mittels Verschachtelung von anderen Listen (Hier wieder Arrays).
Weiteres Beispiel zum weiterdenken: eine Liste kann als Einzelelement eine weitere Liste beinhalten...
BeispielCode:
public class Mehrdimensionales {
public static void main(String[] args) {
// Dimensionalität von Arrays
// Es werden diverse Arrays deklariert
// und mit Werten initialisiert.
// eindimensionales Array
String[] dim1 = new String[4];
for (int i = 0; i < dim1.length; i++) {
dim1[i] = " " + (i + 1) + " ";
}
// zweidimensionales Array
String[][] dim2 = new String[5][2];
for (int i = 0; i < dim2.length; i++) {
for (int j = 0; j < dim2[i].length; j++) {
dim2[i][j] = " " + (i + 1) + "," + (j + 1) + " ";
}
}
// dreidimensionales Array
String[][][] dim3 = new String[2][3][8];
for (int i = 0; i < dim3.length; i++) {
for (int j = 0; j < dim3[i].length; j++) {
for (int k = 0; k < dim3[i][j].length; k++) {
dim3[i][j][k] = " " + (i + 1) + "," + (j + 1) + ","
+ (k + 1) + " ";
}
}
}
// vierdimensionales Array mit einer initialisierung
String[][][][] dim4 = new String[4][2][3][2];
for (int i = 0; i < dim4.length; i++) {
for (int j = 0; j < dim4[i].length; j++) {
for (int k = 0; k < dim4[i][j].length; k++) {
for (int l = 0; l < dim4[i][j][k].length; l++) {
dim4[i][j][k][l] = " " + (i + 1) + "," + (j + 1) + ","
+ (k + 1) + "," + (l + 1) + " ";
}
}
}
}
// Arrays durchlaufen, um an alle Elemente heranzukommen
// eindimensionales array
System.out.println("Eindimensionales Array:");
for (int i = 0; i < dim1.length; i++) {
System.out.println(dim1[i]);
}
// zweidimensionales array
System.out.println("Zweidimensionales Array:");
// Erste Dimension durchlaufen
for (int i = 0; i < dim2.length; i++) {
// zweite Dimension von Element i durchlaufen
for (int j = 0; j < dim2[i].length; j++) {
System.out.print(dim2[i][j] + " ");
}
System.out.print("\n");
}
// dreidimensionales array
System.out.println("dreidimensionales Array:");
// Erste Dimension durchlaufen
for (int i = 0; i < dim3.length; i++) {
// zweite Dimension durchlaufen
for (int j = 0; j < dim3[i].length; j++) {
// dritte Dimension durchlaufen
for (int k = 0; k < dim3[i][j].length; k++) {
System.out.print(dim3[i][j][k] + " ");
}
System.out.print("\n");
}
System.out.print("\n");
}
// vierdimensionales Array
System.out.println("vierdimensionales Array:");
// Erste Dimension durchlaufen
for (int i = 0; i < dim4.length; i++) {
// zweite Dimension durchlaufen
for (int j = 0; j < dim4[i].length; j++) {
// dritte Dimension durchlaufen
for (int k = 0; k < dim4[i][j].length; k++) {
// vierte Dimension durchlaufen
for (int l = 0; l < dim4[i][j][k].length; l++) {
System.out.print(dim4[i][j][k][l] + " ");
}
System.out.print("\n");
}
System.out.print("\n");
}
System.out.print("\n");
}
}
}
-
ich hätte mal ne gerelle frage zum informatik praktikum programmieren. ist die abgabe der bearbeiteten aufgaben in irgendeiner weise verpflichtend und voraussetzung für die zulassung zur prüfung?
wenn ja, müssen wir unsere lösungen vor irg einem gremium verteidigen / erklären?
-
Hi Leute,
hier ein Hinweis von mir:
java 5 (Version 1.5.x) und java 6 (version 1.6.x) besitzen einige kleine Unterschiede.
von daher passt bitte auf mit welchen Java ihr eure Source compiliert.
Solange alles auf dem gleichen Rechner bleibt, ist es halb so wild, sobalt man allerdings sein Projekt irgendwohin mitnimmt, kann es zu "unerklärlichen" (sind aber eben nicht unsinnig) Compilerfehler z.B. à la "Rückgabetyp-Fehler" geben
Beispiel:
Rückgabetyp der Methode remove (K key) von HashMap: war es bis Java 5 ein Boolean (true wenn der Key gefunden und damit auch entfernt wurde), so ist es ab Java 6 der Value des zu löschenden Keys.
LG, ich
PS: Es nützt nix, den Compiler eines Java 6 per Eclipse-Projekteinstellungen auf Compilerstufe von Java 5 zu zwingen. das Einzige was da hilft ist eine Installation eines Java 5 und dann die JRE-Einstellung von Eclipse auf diese Installation verweisen zu lassen
also immer schön aufpassen.
-
Rückgabetyp der Methode remove (K key) von HashMap: war es bis Java 5 ein Boolean (true wenn der Key gefunden und damit auch entfernt wurde), so ist es ab Java 6 der Value des zu löschenden Keys.
Da muss ich wiedersprechen. Wenn ich die api richtig lese, ist der Rückgabetyp bei beiden der Value, also java 5 und java 6
-
hi,
hier der Code vom beispiel aus dem Praktikum.
viel Spass damit,
MfG, ich
Ausführbare Klasse, führt von jeder Datei jeweils eine Instanz aus
import lib.Demo;
import lib.Demo2;
public class DemoTest {
/**
* @param args
*/
// Demo wird gestartet
public static void main(String[] args) {
new Demo();
new Demo2();
}
}
Die Klasse Demo.java
package lib;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
// Beispiel mit dem "Beobachter" vom Typ KeyListener -> überwacht Tastatureingaben zur Lebenszeit des Objektes dieser Klasse
// Diese Klasse Demo ist gleichzeitig ein konkreter Beobachter vom Typ KeyListener
public class Demo extends JFrame implements KeyListener {
// ein eingabefeld für Fenster-Applikationen (hier Swing)
private JTextField testeingabe;
public Demo() {
// folgende Zeilen einfach mal als gegeben hinnehmen (nicht wichtig für
// Demo!)
// Programm beenden beim klicken auf das Fenster-X
this.addWindowListener(new WindowAdapter() {
/*
* (Kein Javadoc)
*
* @see java.awt.event.WindowListener#windowClosing(java.awt.event.WindowEvent)
*/
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// attribut initialisieren
this.testeingabe = new JTextField();
// Abmaße setzen (x,y,länge, höhe)
this.testeingabe.setBounds(20, 20, 300, 40);
// jetzt WICHTIG: ich melte an dem Beobachter das Subjekt testeingabe
// an!
this.testeingabe.addKeyListener(this);
// ich will keinen Layoutmanager -> ich setz den auf null
this.getContentPane().setLayout(null);
// textfeld dem Fenster hinzufügen
this.getContentPane().add(this.testeingabe);
this.setTitle("Demo Observer");
this.setSize(600, 400);
this.setLocation(0, 0);
this.setResizable(true);
this.setVisible(true);
}
// Methoden die man gemäß dem Interface Keylistener implementieren muss
// methodennamen und Signaturen werden vom KeyListener vorgeschrieben!
// Beschreibung siehe KeyListener in der Java API
public void keyPressed(KeyEvent arg0) {
// soll nix machen, wenn eine Taste gerade gedrückt wird (also
// implementiere ich hier nix)
}
public void keyReleased(KeyEvent arg0) {
// soll nix machen, wenn eine Taste gerade losgelassen wird (also
// implementiere ich hier nix)
}
public void keyTyped(KeyEvent wasIstPassiert) {
// soll eingegebene taste auf Konsole ausgeben
// war noch nicht fertig ^^
System.out.println("gedrückte Taste auf tastatur: " + wasIstPassiert.getKeyChar());
}
}
Klasse Demo2.java
package lib;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class Demo2 extends JFrame {
// Beispiel mit dem "Beobachter" vom Typ KeyListener -> überwacht
// Tastatureingaben zur Lebenszeit des Objektes dieser Klasse
// Diese Klasse Demo ist gleichzeitig ein konkreter eobachter vom Typ
// KeyListener
// ein eingabefeld für Fenster-Applikationen (hier Swing)
private JTextField testeingabe;
// ein separater konkreter Beobachter
private KonkreterBeobachter keyboard;
// ein zweiter Beobachter für Ziffern
private KonkreterBeobachterZahl ziffer;
public Demo2() {
this.keyboard = new KonkreterBeobachter();
this.ziffer = new KonkreterBeobachterZahl();
// folgende Zeilen einfach mal als gegeben hinnehmen (nicht wichtig
// für
// Demo!)
// Programm beenden beim klicken auf das Fenster-X
this.addWindowListener(new WindowAdapter() {
/*
* (Kein Javadoc)
*
* @see java.awt.event.WindowListener#windowClosing(java.awt.event.WindowEvent)
*/
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// attribut initialisieren
this.testeingabe = new JTextField();
// Abmaße setzen (x,y,länge, höhe)
this.testeingabe.setBounds(20, 20, 300, 40);
// jetzt WICHTIG: ich melte an dem Beobachter das Subjekt
// testeingabe
// an!
this.testeingabe.addKeyListener(keyboard);
this.testeingabe.addKeyListener(ziffer);
// ich will keinen Layoutmanager -> ich setz den auf null
this.getContentPane().setLayout(null);
// textfeld dem Fenster hinzufügen
this.getContentPane().add(this.testeingabe);
// und ein bisschen dekorieren
this.setTitle("irgendwie was mit Beobachter");
this.setSize(600, 400);
this.setLocation(0, 0);
this.setResizable(true);
this.setVisible(true);
}
}
Die Klasse KonkreterBeobachterZahl.java
package lib;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class KonkreterBeobachterZahl implements KeyListener {
public void keyPressed(KeyEvent arg0) {
}
public void keyReleased(KeyEvent arg0) {
}
public void keyTyped(KeyEvent eingegebeneTaste) {
if(Character.isDigit(eingegebeneTaste.getKeyChar())){
System.out.println("KonkreterBeobachterZahl: Das war ne Ziffer!");
}
}
}
Die Klasse KonkreterBeobachter.java
package lib;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
public class KonkreterBeobachter implements KeyListener{
// Methoden die man gemäß dem Interface Keylistener implementieren muss
// methodennamen und Signaturen werden vom KeyListener vorgeschrieben!
// Beschreibung siehe KeyListener in der Java API
public void keyPressed(KeyEvent arg0) {
}
public void keyReleased(KeyEvent arg0) {
}
public void keyTyped(KeyEvent wasIstPassiert) {
System.out.println("KonkreterBeobachter: \'"+wasIstPassiert.getKeyChar()+"\' wurde eingegeben.");
}
}
-
Servus Mitstreiter,
ich bin gerade am Programmieren meines (unseres) Info-Projektes. Jedoch komme ich bei Aufgabe 1 nicht auf eine Lösung, warum es dort zwei verschiedene Arten von Katalogen gibt. Eine Produktionskatalog und einen Musterkatalog. Im Prinzip reicht es doch aus wenn es einen gibt der ständig gepflegt und aktualisiert wird, oder?
Was ist der Sinn dahinter? Vll kann mir ja einer von euch weiterhelfen...
MfG, Der Felix
-
Den Produktionskatalog musst du dir wie den Katalog vorstellen, den der Auftraggeber bekommt und wo alle zu bestellenden Produkte drin stehen. Im Musterkatalog stehen dagegen zu jedem möglichen Teil, dass zum Produzoeren benötigt wird ein Muster, also zu den Produkten, Einzelteilen, Baugruppen, Halbzeugen.
Ich hoff ich konnt helfen
Grüße Andreas
-
Hier ein weiteres Beispiel:
kurze Erläuterung:
Die Klasse TextLeser hat eine Methode, welche einen String von der Tastatur einliest und diesen in ihrem String-Attribut zeile speichert. Mit jedem neuen Aufruf der Methode liesZeileEin() bekommt zeile eine neue String-Objekt-Referenz zugewiesen.
Weiterhin gibt es die Klassen Buchstabenzaehler und Text. Buchstabenzaehler soll die Anzahl der Character im eingelesenen String ermitteln, und Text soll alle eingegebenen Zeilen speichern.
Das Observer-Design-Pattern sorgt hier für die Kommunikation zwischen den drei Klassen:
die letzten beiden Code-Zeilen (Kommentare werden nicht berücksichtigt) der Methode liesZeileEin() von Klasse TextLeser sind hier entscheidend, um die angemeldeten Observer zu benachrichtigen. Mit super.notifyObservers() wird in allen angemeldeten Observern die Methode update() aufgerufen.
Klasse Text
package neugierde;
import java.util.*;
// eine Klasse, die eine andere Klasse beobachtet und selbst noch andere Funktionen hat
public class Text implements Observer {
// attribut zum Speichern aller eingegebenen zeilen
private List list;
// Konstruktor
public Text() {
this.list = new ArrayList();
} // Text ende
// holt die gespeicherten Zeilen aus dem Attribut und gibt ihn als String
// zurück
public String getText() {
String result = "";
for (int i = 0; i < this.list.size(); i++) {
result = result + this.list.get(i) + "\n";
}
return result;
} // getText ende
// wird aufgerufen, wenn die Observer benachrichtigt werden
public void update(Observable subjekt, Object objekt) {
// ersmal schauen ob es eine Instanz von TextLeser war
if (subjekt instanceof TextLeser) {
// von Observable auf TextLeser casten, um auf die Methoden von
// TextLeser (z.B. auch die Getter) zugreifen zu können
TextLeser textLeser = (TextLeser) subjekt;
// der list die Zeile aus dem TextLeser hinzufügen
this.list.add(textLeser.getZeile());
}
} // update ende
} // Text ende
Klasse Buchstabenzaehler
package neugierde;
import java.util.Observable;
import java.util.Observer;
// ein "reiner" Observer
public class Buchstabenzaehler implements Observer {
// wird aufgerufen, wenn die Observer benachrichtigt werden
public void update(Observable o, Object arg) {
// war der Verursacher eine Instanz von TextLeser?
if (o instanceof TextLeser) {
// soll einfach die Anzahl der eingegebenen Zeichen ausgeben
System.out.println("Buchstabenzähler: \tDer String bestand aus "
+ ((TextLeser) o).getZeile().length() + " Zeichen");
}
} // update ende
} // Klasse Buchstabenzaehler ende
Klasse TextLeser
package neugierde;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Observable;
public class TextLeser extends Observable {
// attribut, worin die letzte eingegebene Zeile gespeichert wird
private String zeile;
// eine Methode zum einlesen einer Zeile von der Tastatur (= ein String)
public void liesZeileEin() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String result = null;
try {
result = br.readLine();
} catch (IOException e) {
// falls mal n Fehler kommt
e.printStackTrace();
}
// alten Wert in einer anderen Variable speichern
String alterWert = "" + this.zeile;
// neu eingelesenen Wert in zeile speichern
this.zeile = result;
// Änderung wird hier in Standard-Ausgabe (Konsole) ausgegeben
System.out.println("Textleser: \t\t" + alterWert + " -> " + result);
// Flagge hissen in der Superklasse Observable (Bedeutung: "ich habe
// mich verändert")
super.setChanged();
// hier werden dann die angemeldeten Observer benachrichtigt
super.notifyObservers();
} // liesZeileEin ende
// Getter für die eingelesene zeile
public String getZeile() {
return zeile;
} // getZeile ende
} // Klasse TextLeser ende
Testumgebung NeugierdeTest
import neugierde.Buchstabenzaehler;
import neugierde.Text;
import neugierde.TextLeser;
// eine Testumgebung
public class NeugierdeTest {
/**
* @param args
*/
public static void main(String[] args) {
// erstmal neue Instanzen erzeugen
Text text=new Text();
Buchstabenzaehler buchstabenzaehler=new Buchstabenzaehler();
TextLeser textLeser=new TextLeser();
// die beiden Observer dem TextLeser hinzufügen
textLeser.addObserver(text);
textLeser.addObserver(buchstabenzaehler);
// n Zeilen abfragen
int n=3;
for (int i = 0; i < n; i++) {
textLeser.liesZeileEin();
}
// den kompletten Text (alle Zeilen) ausgeben lassen
System.out.println("\n\ngespeicherter Text\n------------------------------");
System.out.println(text.getText());
}
}
Ausgabe auf Konsole:
hallo Welt
Textleser: null -> hallo Welt
Buchstabenzähler: Der String bestand aus 10 Zeichen
Kaffee gibt es in der Kantine
Textleser: hallo Welt -> Kaffee gibt es in der Kantine
Buchstabenzähler: Der String bestand aus 29 Zeichen
GmbH - >
Textleser: Kaffee gibt es in der Kantine -> GmbH - >
Buchstabenzähler: Der String bestand aus 8 Zeichen
gespeicherter Text
------------------------------
hallo Welt
Kaffee gibt es in der Kantine
GmbH - >
soweit dazu,
MfG ich
-
~up~
-
ich hätte mal ne gerelle frage zum informatik praktikum programmieren. ist die abgabe der bearbeiteten aufgaben in irgendeiner weise verpflichtend und voraussetzung für die zulassung zur prüfung?
wenn ja, müssen wir unsere lösungen vor irg einem gremium verteidigen / erklären?
offtopic aber:
* Jein.
CIWler müssen abgeben um die Prüfungsvoraussetzung zu haben.
MBler, WWler, VTler und CIWler müssen abgeben weil die Statistik gegen ein bestehen ohne Punkte aus dem Praktikum spricht.
* Nein.
-
Hier die Listings aus dem Praktikum vom 30.04.2009:
Die Klasse Antwort:
package de.tudresden.praktikum2009.lib;
/* Diese Klasse stellt das Modell für eine einzelne Antwort. Sie enthält
* den Text und den Wahrheitsgehalt. Beide Werte sollen nach Erstellen
* eines Objektes nur noch ausgelesen werden können.*/
public class Antwort {
private String antworttext;
private boolean richtig;
// Konstruktor, für Initialisierung der Daten
public Antwort(String antworttext, boolean richtigeAntwort) {
this.antworttext = antworttext;
this.richtig = richtigeAntwort;
}
public String getAntworttext() {
return antworttext;
}
/*
* abweichend hier:bei boolschen Werten fängt der Standard-Getter mit is
* statt mit get an
*/
public boolean isRichtig() {
return richtig;
}
/*
* eine Version des Getters, welcher vor Rückgabe eine Modifizierung von
* Daten, hier der Typ und Wert, vornimmt
*/
public String getRichtig() {
if (this.richtig) {
return "wahr";
} else {
return "falsch";
}
}
}
Die Klasse Frage:
package de.tudresden.praktikum2009.lib;
import java.util.ArrayList;
/* Eine Frage soll eindeutig identifizierbar sein,
* den Frage-Text beinhalten und kann mehrere
* Antwortmöglichkeiten haben. Und auch hier sollten
* die Attribute eines Objektes nur ausgelesen werden
* können*/
public class Frage {
private String id;
private String frage;
/* ArrayList -> siehe Collection-Framework */
private ArrayList antworten;
public Frage(String identifikator, String frage,
ArrayList antworten) {
id = identifikator;
this.frage = frage;
this.antworten = antworten;
}
public String getId() {
return id;
}
public String getFrage() {
return frage;
}
public ArrayList getAntworten() {
return antworten;
}
}
Die Klasse Fragenkatalog
package de.tudresden.praktikum2009.lib;
import java.util.ArrayList;
/* Der Fragenkatalog enthält eine Menge von Fragen und hat
* auch eine Bezeichnung */
public class Fragenkatalog {
private ArrayList fragen;
private String name;
/* es ist möglich, gleichnamige Konstruktoren (und
* auch Methoden) mit voneinander verschiedenen
* Signaturen zu definieren */
public Fragenkatalog(String name) {
this.name = name;
this.fragen = new ArrayList();
}
public Fragenkatalog(String name,
ArrayList existierendeFragen) {
this.name = name;
this.fragen = existierendeFragen;
}
/* fügt eine neue(?) Frage dem Katalog hinzu*/
public void addFrage(Frage frage) {
this.fragen.add(frage);
}
/* entfernt eine Frage mit entsprechender id aus
* dem Katalog*/
public boolean delFrage(String id) {
for (int i = 0; i < this.fragen.size(); i++) {
if (this.fragen.get(i).getId().equals(id)) {
this.fragen.remove(i);
return true;
}
}
return false;
}
public ArrayList getFragen() {
return fragen;
}
public void setFragen(ArrayList fragen) {
this.fragen = fragen;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
und nun ein paar Tests:
Test der Klasse Antwort
package de.tudresden.praktikum2009;
import java.util.ArrayList;
import de.tudresden.praktikum2009.lib.Antwort;
public class TestAntwort {
/**
* @param args
*/
public static void main(String[] args) {
// 5 Objekte vom Typ Antwort erstellt
Antwort aw1 = new Antwort("ein grüner Kreis.", true);
Antwort aw2 = new Antwort("ein grünes Dreieck.", false);
Antwort aw3 = new Antwort("ein grüne Figur.", true);
Antwort aw4 = new Antwort("ein grünes Pfeil.", true);
Antwort aw5 = new Antwort("ein blauer Kreis.", false);
// die Objekte zu einer Liste zusammenführen
ArrayList antwortmoeglichkeiten = new ArrayList();
antwortmoeglichkeiten.add(aw1);
antwortmoeglichkeiten.add(aw2);
antwortmoeglichkeiten.add(aw3);
antwortmoeglichkeiten.add(aw4);
antwortmoeglichkeiten.add(aw5);
//ein einzelnes Antwort-Objekt auslesen
System.out.println(aw3.getAntworttext());
System.out.println("Diese Antwort ist " + aw3.isRichtig() + ".");
// udn jetzt mit einem zufälligen Antwort-Objekt
int n = (int) (Math.random() * antwortmoeglichkeiten.size());
System.out.println("Zufallszahl: " + n);
System.out.println("jetzt ein zufälliges Antwortobjekt aus der Liste:");
System.out.println(antwortmoeglichkeiten.get(n).getAntworttext());
System.out.println("Diese Antwort ist "
+ antwortmoeglichkeiten.get(n).isRichtig() + ".");
}
}
test der Klasse Frage
package de.tudresden.praktikum2009;
import java.util.ArrayList;
import de.tudresden.praktikum2009.lib.Antwort;
import de.tudresden.praktikum2009.lib.Frage;
public class TestFrage {
// eine kleine Testumgebung
public static void main(String[] args) {
Antwort aw1 = new Antwort("ein grüner Kreis.", true);
Antwort aw2 = new Antwort("ein grünes Dreieck.", false);
Antwort aw3 = new Antwort("ein grüne Figur.", true);
Antwort aw4 = new Antwort("ein grünes Pfeil.", true);
Antwort aw5 = new Antwort("ein blauer Kreis.", false);
ArrayList antwortmoeglichkeiten = new ArrayList();
antwortmoeglichkeiten.add(aw1);
antwortmoeglichkeiten.add(aw2);
antwortmoeglichkeiten.add(aw3);
antwortmoeglichkeiten.add(aw4);
antwortmoeglichkeiten.add(aw5);
//wir erzeugen uns 3 Objekte vom Typ "Frage"
Frage f1 = new Frage("A001", // eine (eindeutige) ID
"Was sind gängige Ampelsignale für das fahren/gehen?", // die Frage
antwortmoeglichkeiten); // die Antwortmöglichkeiten
Frage f2 = new Frage("A002",
"blablabla...", antwortmoeglichkeiten);
Frage f3 = new Frage("65003",
"blubb", antwortmoeglichkeiten);
System.out.println(f1.getId());
System.out.println(f1.getFrage());
System.out.println(f1.getAntworten());
System.out.println(f3.getId());
System.out.println(f3.getFrage());
System.out.println(f3.getAntworten());
}
}
und nun ein ganz kleines Quiz mit 2 Fragen:
package de.tudresden.praktikum2009;
import java.util.ArrayList;
import java.util.Scanner;
import de.tudresden.praktikum2009.lib.*;
// hier für 1 richtige Antwortmöglichkeit
public class Quizshow {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// Code wurde in eine Methode ausgelagert
Fragenkatalog fk = initFK();
// jetzt wird eine Frage aus allen möglichen ausgewählt
int n = (int) (Math.random() * fk.getFragen().size());
// Frage und Antwortmöglichkeiten auf Konsole ausgeben
System.out.println("Beantworte bitte folgende Frage:");
System.out.println(fk.getFragen().get(n).getFrage());
/*
* besser als direkte Ausgabe der einzelnen Antworten, da man die anzahl
* der möglichen Antworten als unbekannt voraussetzen sollte
*/
for (int i = 0; i < fk.getFragen().get(n).getAntworten().size(); i++) {
System.out.println((i + 1)
+ " - "
+ fk.getFragen().get(n).getAntworten().get(i)
.getAntworttext());
}
// nutzer darf sich entscheiden
int wahl = sc.nextInt();
/*
* Gültigkeit der Auswahl abprüfen (Schutz vor zu große/zu kleine
* Zahlen)
*/
if ((wahl) > 0 && wahl <= fk.getFragen().get(n).getAntworten().size()) {
System.out.println("diese Antwort ist "
+ fk.getFragen().get(n).getAntworten().get(wahl - 1)
.getRichtig());
} else {
System.out
.println("deine Auswahl lag ausserhalb der Antwortmöglichkeit");
}
}
// erstellt einen Fragekatalog und füttert ihn mit 2 Fragen
private static Fragenkatalog initFK() {
Fragenkatalog fk = new Fragenkatalog("lustigerName");
ArrayList antworten = new ArrayList();
Antwort a1 = new Antwort("5", false);
antworten.add(a1);
antworten.add(new Antwort("7", true));
antworten.add(new Antwort("8", false));
Frage frage = new Frage("A", "Wieviel Tage hat eine Woche?", antworten);
fk.addFrage(frage);
/*
* Neu-Initialisierung des Objektes -> es sind ab hier wieder 0 Elemente
* enthalten ("Variablen-Recycling")
*/
antworten = new ArrayList();
antworten.add(new Antwort("H2O", true));
antworten.add(new Antwort("H2O2", false));
antworten.add(new Antwort("HO2", false));
frage = new Frage("B", "Was ist die chemische Formel von Wasser",
antworten);
fk.addFrage(frage);
return fk;
}
}
Ihr könnt euch ja über folgende Sachen mal Gedanken machen:
[LIST=1]
- wie kann man in der Klasse Fragenkatalog absichern, dass in einem Fragenkatalog-Objekt jede id nur einmal vorkommt (id = Primärschlüssel)?
- wie sieht der Sourcecode für ein Quiz aus, in dem pro Frage mehrere richtige Antworten möglich sind?
- welche persistente Datenquellen wären als Quelle zum Füllen des Fragenkataloges denkbar?
Viel Spass,
Matthias