Themabewertung:
  • 0 Bewertung(en) - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Beispiele aus Übungen und Praktika
#1
Hallo Leute,
hier das Beispiel von mir aus dem Info-Praktikum 5./6. DS:

.zip   ProjektToGo.zip (Größe: 3,63 KB / Downloads: 290)

MfG, Matthias
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#2
Weitere Beispiele findet ihr auch hier: https://iai82110.inf.tu-dresden.de/lehre/mw/index.html (Quelle:Vorlesung Informatik 2)

MfG, ich
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#3
Zitat:Schreibe ein Programm, welches eine ganze Zahl von der Tastatur einliest und die dazugehörige Fakultät auf der Konsole ausgibt.
Zitat: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.
Zitat:Schreibe ein Programm zum Lösen von quadratischen Gleichungen.
Zitat:Programmiere einen (normalen) Würfel.
Zitat:Simuliere eine Lottoziehung "6 aus 49". Die sechs Zahlen, die man tippt, soll man auf der Tastatur eingeben können.
Zitat: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.
Zitat:Implementiere einen Algorithmus, welcher einen einfachen Rechner (2 Operanden und 1 Operator) simuliert.
Zitat:Schreibe einen Umrechner, der zwischen Zahlendarstellungen auf 2er, 8er, 10er und 16er Basis umrechnet.
MfG, Matthias
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#4
Hi Leute,

JUDE gibt es direkt hier: JUDE

LG, ich
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#5
UML-Übersicht: http://www.oose.de/downloads/uml-2-Notat...ose.de.pdf
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#6
Lösung für Fakultät-Aufgabe:

Code:
/* 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
Code:
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);
    }
}
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#7
Neue Aufgabe zum Üben ^^


Teil 1
Zitat: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
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#8
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:
Code:
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");
        }

    }

}
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#9
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?
Fear the beard!
Zitieren
#10
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.
Zitieren
#11
Zitat: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
[SIZE="1"]Claudia[/SIZE]

[SIZE="4"]Grammatik gelernt bei Meister Yoda du hast.[/SIZE]

Verwöhn deinen Nager
Zitieren
#12
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
Code:
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
Code:
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
Code:
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
Code:
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
Code:
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.");

    }


}
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#13
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
Zitieren
#14
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
Zitat:Free-cutting, the only way to do it.
Ich spreche immernoch in der alten Rechtschreibung!!!!

Zitat:Wenn die Welt erst ehrlich genug sein wird, um Kinder vor dem 15. Jahr keinen Religionsunterricht zu erteilen, dann wird von ihr was zu hoffen sein.
Arthur Schopenhauer

Andreas Lehmann
ehemaliges FSR-Mitglied, Moderator

Zitieren
#15
Hier ein weiteres Beispiel:
  • Observer
    • Text
    • Buchstabenzaehler
  • Observable
    • TextLeser

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
Code:
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<String> list;

    // Konstruktor
    public Text() {
        this.list = new ArrayList<String>();
    } // 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
Code:
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
Code:
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
Code:
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
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#16
~up~
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren
#17
mArKuZZZ schrieb: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.
Zitieren
#18
Hier die Listings aus dem Praktikum vom 30.04.2009:

Die Klasse Antwort:
Code:
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:
Code:
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<Antwort> antworten;

    public Frage(String identifikator, String frage,
            ArrayList<Antwort> antworten) {
        id = identifikator;
        this.frage = frage;
        this.antworten = antworten;
    }

    public String getId() {
        return id;
    }

    public String getFrage() {
        return frage;
    }

    public ArrayList<Antwort> getAntworten() {
        return antworten;
    }
}

Die Klasse Fragenkatalog
Code:
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<Frage> 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<Frage>();
    }

    public Fragenkatalog(String name,
            ArrayList<Frage> 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<Frage> getFragen() {
        return fragen;
    }

    public void setFragen(ArrayList<Frage> 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
Code:
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<Antwort> antwortmoeglichkeiten = new ArrayList<Antwort>();
        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
Code:
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<Antwort> antwortmoeglichkeiten = new ArrayList<Antwort>();
        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:
Code:
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<Antwort> antworten = new ArrayList<Antwort>();

        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<Antwort>();
        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:
  1. wie kann man in der Klasse Fragenkatalog absichern, dass in einem Fragenkatalog-Objekt jede id nur einmal vorkommt (id = Primärschlüssel)?
  2. wie sieht der Sourcecode für ein Quiz aus, in dem pro Frage mehrere richtige Antworten möglich sind?
  3. welche persistente Datenquellen wären als Quelle zum Füllen des Fragenkataloges denkbar?

Viel Spass,

Matthias
Füllhöhe des Textes technisch bedingt!

----------------------------------------
Matthias Zagermann
Jünger der polyphonen PVC/PVAc-Scheiben

Zitat:Jede Entscheidung ist der Tod von Milliarden von Möglichkeiten
Zitieren


Möglicherweise verwandte Themen…
Thema Verfasser Antworten Ansichten Letzter Beitrag
  Praktika Werkstofftechnik SS12 Bombenrichter 7 7.498 17.07.2021, 13:06
Letzter Beitrag: Hedy
  Nicht bearbeitete Praktika = 5, oder nicht zur Prüfung zugelassen? sJSin 2 1.409 24.06.2016, 12:28
Letzter Beitrag: sJSin
  Notendurchschnitt aus den Praktika wilk 9 4.029 09.07.2008, 21:16
Letzter Beitrag: AudiFred
  Frage zur Prüfungszulassung => Praktika Beechjete 14 5.195 23.05.2007, 17:32
Letzter Beitrag: tigerente
  Infos zu den Praktika ChrisW 0 13.258 24.05.2005, 11:45
Letzter Beitrag: ChrisW

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste