Beispiele aus Übungen und Praktika

[tiefenbass]

Hallo Leute,
hier das Beispiel von mir aus dem Info-Praktikum 5./6. DS:
[attachment=1668]

MfG, Matthias

[tiefenbass]

Weitere Beispiele findet ihr auch hier: https://iai82110.inf.tu-dresden.de/lehre/mw/index.html (Quelle:Vorlesung Informatik 2)

MfG, ich

[tiefenbass]

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

[tiefenbass]

Hi Leute,

JUDE gibt es direkt hier: JUDE

LG, ich

[tiefenbass]

UML-Übersicht: http://www.oose.de/downloads/uml-2-Notationsuebersicht-oose.de.pdf

[tiefenbass]

Lösung für Fakultät-Aufgabe:

Code: [Select]

/* 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: [Select]

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);
}
}


[tiefenbass]

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

[tiefenbass]

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: [Select]

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");
}

}

}


[mArKuZZZ]

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?

[sanileo]

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.

[mermaid]

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

[tiefenbass]

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: [Select]


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: [Select]


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: [Select]


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: [Select]


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: [Select]


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.");

}


}


[werfel]

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

[Mind Eraser]

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

[tiefenbass]

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: [Select]


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

Code: [Select]

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: [Select]

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: [Select]

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