Hi,
das ist mein erster Post also biite nicht gleich schimpfen.
Ich studiere Wirtschaftsinformatik in Berlin und muss sehr viel in Java programmieren.
Ich musste nun ein Projekt abgeben und mir wurde vorgeworfen das ich prozedural programmiere.
Nur leider kann ich mir nix weiter unter OOP vorstellen. Könnt ihr mir vllt. dabei helfen?
Achja meine Dokumentation wurde auch bemängelt. Habe schon viel bei google.de gesucht und viel nachgelesen. Nur leider weiß ich auch nicht, wie ich was richtig kommentieren soll.
Für eure hilfreichen Tipps würde ich euch sehr dankbar seine.
Ich stelle mal mein Programm hier rein.
Klasse Generator
Klasse GeneratorMain
Klasse MeineAusgabe
Klasse MeineEingabe
Klasse MeinRandom
Klasse Variablen
MfG
BoZA
das ist mein erster Post also biite nicht gleich schimpfen.
Ich studiere Wirtschaftsinformatik in Berlin und muss sehr viel in Java programmieren.
Ich musste nun ein Projekt abgeben und mir wurde vorgeworfen das ich prozedural programmiere.
Nur leider kann ich mir nix weiter unter OOP vorstellen. Könnt ihr mir vllt. dabei helfen?
Achja meine Dokumentation wurde auch bemängelt. Habe schon viel bei google.de gesucht und viel nachgelesen. Nur leider weiß ich auch nicht, wie ich was richtig kommentieren soll.
Für eure hilfreichen Tipps würde ich euch sehr dankbar seine.
Ich stelle mal mein Programm hier rein.
Klasse Generator
Code:
import java.io.IOException;
/** Die Klasse [i]Generator[/i]
* Ist die Klasse in der das Objekte Var sowie Ran anlegt wird
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version Aufgabe xy */
public class Generator
{ /** Das private Attribut [i]Variablen[/i] erzeugt das neue Objekt [i]Var[/i] mit dem Startwert "null" */
private Variablen Var = null;
/** Das private Attribut [i]MeinRandom[/i] erzeugt das neue Objekt [i]Ran[/i] mit dem Startwert "null" */
private MeinRandom Ran = null;
/** Das private Attribut [i]ZufallX[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int ZufallX = 0;
/** Das private Attribut [i]ZufallY[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int ZufallY = 0;
/** Das private Attribut [i]AdditionsErgebnis[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int AdditionsErgebnis = 0;
/** Das private Attribut [i]MultiplikationsErgebnis[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int MultiplikationsErgebnis = 0;
/** Der Oeffentliche Konstruktor [i]Generator[/i] legt die folgenden Methoden an
* trageRanAngabenEin(); trageRandomEin(); legeAdditionAn(); legeMultiplikationAn(); schreibeRechnungen(); legeGroesserKleinerAn(); legeUngleichAn();
* trageVarAngabenEin() sowie VergleicheErgebnisse();*/
public Generator() throws IOException
{
trageRanAngabenEin();
trageRandomEin();
legeAdditionAn();
legeMultiplikationAn();
schreibeRechnungen();
legeGroesserKleinerAn();
legeUngleichAn();
trageVarAngabenEin();
VergleicheErgebnisse();
}
/** Die Oeffentliche Methode [i]schreibeRechnungen[/i] besitzt Attribute der MeineAusgabe.Class um die Rechnung auszugeben */
public void schreibeRechnungen() throws IOException
{
MeineAusgabe.schreibeString("Ich habe zwei ganze Zahlen x und y zwischen 1 und 20 erzeugt!\n\n");
MeineAusgabe.schreibeString("Es ist x + y = ");
MeineAusgabe.schreibeInt(AdditionsErgebnis);
MeineAusgabe.schreibeString(".\nEs ist x * y = ");
MeineAusgabe.schreibeInt(MultiplikationsErgebnis);
MeineAusgabe.schreibeString(".\nEs ist x ");
}
/** Die private Methode [i]legeAdditionAn[/i] rechnet [i]AdditionsErgebnis = ZufallX + ZufallY[/i]*/
private void legeAdditionAn() throws IOException
{
AdditionsErgebnis = ZufallX + ZufallY;
}
/** Die private Methode [i]legeMultiplikationAn[/i] rechnet [i]MultiplikationsErgebnis = ZufallX * ZufallY[/i]*/
private void legeMultiplikationAn() throws IOException
{
MultiplikationsErgebnis = ZufallX * ZufallY;
}
/** Die private Methode [i]legeGroesserKleinerAn[/i] beinhaltet 4 if Bedingungen von der bei Übereinstimmung ein Ergebnis ausgegeben wird[/i]*/
private void legeGroesserKleinerAn() throws IOException
{
if(ZufallX < ZufallY)
{
MeineAusgabe.schreibeString("< y.\n");
}
else if(ZufallX <= ZufallY)
{
MeineAusgabe.schreibeString("<= y.\n");
}
else if(ZufallX > ZufallY)
{
MeineAusgabe.schreibeString("> y.\n");
}
else if(ZufallX >= ZufallY)
{
MeineAusgabe.schreibeString(">= y.\n");
}
}
/** Die private Methode [i]legeUngleichAn[/i] beinhaltet 1 if Bedingung und eine else Bedingung von der bei Übereinstimmung ein Ergebnis ausgegeben wird[/i]*/
private void legeUngleichAn() throws IOException
{
if(ZufallX != ZufallY)
{
MeineAusgabe.schreibeString("Es ist x != y.\n\n");
}
else if(ZufallX == ZufallY)
{
MeineAusgabe.schreibeString("Es ist x = y.\n\n");
}
}
/** Die Oeffentliche Methode [i]legeVergleicheErgebnisse[/i] beinhaltet 1 if Bedingung und eine else Bedingung von der bei Übereinstimmung ein Ergebnis ausgegeben wird[/i]*/
public void VergleicheErgebnisse() throws IOException
{
if(ZufallX==Var.liefereX() && ZufallY==Var.liefereY())
{
MeineAusgabe.schreibeString("Sehr gut! Sie haben die Zahlen erraten!");
}
else
{
MeineAusgabe.schreibeString("Ihre Antwort ist leider flasch! Hier ist die richtige Antwort: (");
MeineAusgabe.schreibeInt(ZufallX);
MeineAusgabe.schreibeString(",");
MeineAusgabe.schreibeInt(ZufallY);
MeineAusgabe.schreibeString(")");
}
}
/** Die private Methode [i]trageRandomEin[/i] erzeugt die Zufallszahlen[/i]*/
public void trageRandomEin() throws IOException
{
ZufallX = Ran.nextInt(1,20);
ZufallY = Ran.nextInt(1,20);
}
/** Die Private Methode [i]trageVarAngabenEin[/i] legt das neue Objekt [i]Var[/i] der Klasse [i]Variablen[/i] an */
private void trageVarAngabenEin() throws IOException
{
Var = new Variablen();
}
/** Die Private Methode [i]trageRanAngabenEin[/i] legt das neue Objekt [i]Ran[/i] der Klasse [i]MeinRandom[/i] an */
private void trageRanAngabenEin() throws IOException
{
Ran = new MeinRandom();
}
}
Code:
import java.io.IOException;
/** Die Klasse [i]GeneratorMain[/i]
* Ist die Hauptklasse in der das Objekte Gen anlegt wird
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version xy */
public class GeneratorMain
{ /** Die statische Methode [i]main[/i] dient als Startpunkt der Applikation
* Der Java-Interpreter lädt beim Starten das angegeben Klassenobjekt.
* In diesem Fall [i]new Gleichung[/i]
*/
public static void main(String[] args) throws IOException
{
Generator Gen = new Generator();
}
}Klasse MeineAusgabe
Code:
import java.text.DecimalFormat;
/** Die Klasse [i]MeineAusgabe[/i]
ist die Klasse, die den eingegebene Text ausgibt
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version xy */
public class MeineAusgabe
{ /** Die Oeffentliche statische Methode [i]DecimalFormat[/i] erstellt die Variable [i]zahlAchtstellen[/i] welche das
* Objekt [i]new DecimalFormat("#.#")[/i]*/
private static DecimalFormat zahlZweistellen = new DecimalFormat("#.#");
/** Die statische Methode [i]schreibeString(String Text)[/i] [i]---- Gibt die Anweisung,
* den Text auf dem Bildschrim auszugeben[/i] */
public static void schreibeString(String text)
{
System.out.print(text);
}
/** Die statische Methode [i]schreibeDouble(double zahl)[/i] [i]---- Gibt die Anweisung,
* die Zahl auf dem Bildschrim auszugeben[/i] */
public static void schreibeDouble(double zahl)
{
System.out.print(zahlZweistellen.format(zahl));
}
/** Die statische Methode [i]schreibeInt(int zahl)[/i] [i]---- Gibt die Anweisung,
* die Zahl auf dem Bildschrim auszugeben[/i] */
public static void schreibeInt(int zahl)
{
System.out.print(zahlZweistellen.format(zahl));
}
}Klasse MeineEingabe
Code:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
/** Die Klasse [i]MeineEingabe[/i]
* Kann Eingaben einlesen
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version xy */
public class MeineEingabe
{/** Die statische Methode [i]BufferedReader[/i] ist ein Filter der die Performance beim Lesen von ext. Datein erhöht */
private static BufferedReader eingabe =
new BufferedReader(new InputStreamReader(System.in));
/** Die statische Methode [i]erfasseText[/i][i] Kann den Text einlesen[/i]*/
public static String erfasseText() throws IOException
{
return eingabe.readLine();
}
/** Die statische Methode [i]erfasseInt[/i][i]Kann ganze Zahlen einlesen[/i]*/
public static int erfasseInt() throws IOException
{
return Integer.parseInt(erfasseText());
}
/** Die statische Methode [i]erfasseDouble[/i][i]Kann Komma Zahlen einlesen[/i]*/
public static double erfasseDouble() throws IOException
{
return Double.parseDouble(erfasseText());
}
}Klasse MeinRandom
Code:
import java.util.Random;
/** Die Klasse [i]MeinRandom[/i]
* Ist die Klasse die Zufallszahlen ermittelt werden
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version xy */
public class MeinRandom extends Random
{/** Der Oeffentliche Konstruktor [i]MeinRandom[/i] legt die folgenden Methoden an
* super();[/i]*/
public MeinRandom()
{
super();
}
/** Die Oeffentliche Methode [i]nextInt[/i] erzeugt die Zufallszahl*/
public int nextInt(int min, int max)
{
return this.nextInt(max - min + 1) + min;
}
}Klasse Variablen
Code:
import java.io.IOException;
/* Die Klasse [i]Variablen[/i]
* Ist die Klasse in der die privaten Atrribute x, y,exsistieren
* [i]----- Kurzbeschreibung der Klasse -----[/i]
* @author xy
* @version xy */
public class Variablen
{ /** Das private Attribut [i]x[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int x = 0;
/** Das private Attribut [i]y[/i] hat den Datentyp [i]int[/i] und den Startwert [i]"0"[/i]*/
private int y = 0;
/** Der Oeffentliche Konstruktor [i]Variablen[/i] legt die folgenden Methoden an
* [i]leseXEin[/i], [i]leseYEin[/i]*/
public Variablen() throws IOException
{
leseXEin();
leseYEin();
}
/** Die Oeffentliche Methode [i]liefereX[/i] gibt den Rückgabewert von [i]x[/i] an*/
public int liefereX()
{
return x;
}
/** Die Oeffentliche Methode [i]liefereY[/i] gibt den Rückgabewert von [i]y[/i] an*/
public int liefereY()
{
return y;
}
/** Die private Methode [i]leseXEin[/i] liest [i]x[/i] ein */
private void leseXEin() throws IOException
{
MeineAusgabe.schreibeString("Welchen Wert hat x? ");
x = MeineEingabe.erfasseInt();
}
/** Die private Methode [i]leseYEin[/i] liest [i]y[/i] ein */
private void leseYEin() throws IOException
{
MeineAusgabe.schreibeString("Welchen Wert hat y? ");
y = MeineEingabe.erfasseInt();
}
}MfG
BoZA
