# Bitte um Hilfe



## Anfänger22 (21. Okt 2011)

a) Die Klasse Converter kann verwendet werden um Umrechnungen zwischen zwei
beliebigen Maßeinheiten zu ermöglichen (z.B. km nach cm oder g nach kg). Im Code
wird allgemein von einer Einheit A und einer Einheit B gesprochen, die durch den Wert
rateAB ineinander umgewandelt werden können (Z.B. A=m, B=cm, dann ist
rateAB=100).

```
public class Converter {
private double rateAB;
public Converter(double rateAB) {
this.rateAB=rateAB;
}

public double convertAtoB(double amount) {
return amount*rateAB;
}
public double convertBtoA(double amount) {
return amount/rateAB;
}
}
```


Programmieren Sie eine Klasse EURDMConverterImpl, die die Umrechnung von
Euro nach DM und umgekehrt ermöglicht. Diese Klasse soll die Klasse Converter
kapseln (has-a-Beziehung) und ihre Funktionalität nutzen. Des Weiteren soll die Klasse
das Interface EURDMConverter implementieren. Realisieren Sie die beiden Methoden
zur Umrechnung von DM nach EUR und anders herum unter Verwendung der Klasse
Converter. Sehen Sie in Ihrer Klasse geeignete Attribute und Konstruktoren vor! Der
Umrechnungsfaktor von Euro nach DM ist 1,95583 (rateAB).

```
public interface EURDMConverter {
//Umrechnung von Euro nach DM
public double convertEUR2DM(double amount);
//Umrechnung von DM nach Euro
public double convertDM2EUR(double amount);
```

b) Programmieren Sie eine Klasse ConverterMain, die in ihrer main-Methode die
Umrechnung von DM nach EUR oder anders herum ausführt. Die Klasse soll dazu die
Klasse EURDMConverterImpl aus Teilaufgabe a) verwenden. Die Klasse erhält Ihre
Eingabe über die Kommandozeilenargumente. Im ersten Argument („args[0]“) soll der
Betrag, im zweiten Argument („args[1]“) die Währung übergeben werden. Die
angegebene Währung bestimmt die Richtung der Umrechnung (Fallunterscheidung!).
Das Programm soll sich wie folgt verhalten:
Beispiel Aufrufe mit Ausgaben:


```
java 100 DM
100.0 DM = 51.1291881196 EUR
java 100 EUR
100.0 EUR = 195.583
Auf eine Fehlerbehandlung in der Klasse können Sie verzichten!
```


FOLGENDES HABE ICH HINBEKOMMEN

```
public interface EURDMConverter {
//Umrechnung von Euro nach DM
public double convertEUR2DM(double amount);
//Umrechnung von DM nach Euro
public double convertDM2EUR(double amount);
}

public class EURDMConverterImpl implements EURDMConverter {
	private double amount;
	@Override
	public double convertEUR2DM(double amount) {
		return  amount/ 1.95583;
	}

	@Override
	public double convertDM2EUR(double amount) {
	 return 1.95583 * amount;
	}

}
```


----------



## Marcinek (21. Okt 2011)

Und was ist die Frage?

Ich kann die gegen Geld eine Lösung schicken für die Aufgabe. Schreibe mir einfach eine PM.


----------



## Anfänger22 (21. Okt 2011)

Marcinek hat gesagt.:


> Und was ist die Frage?
> 
> Ich kann die gegen Geld eine Lösung schicken für die Aufgabe. Schreibe mir einfach eine PM.



sonst gehts dir gut oder???

lies dir die aufgabenstellung durch! ob es soweit in ordnung ist.


----------



## Marcinek (21. Okt 2011)

Anfänger22 hat gesagt.:


> lies dir die aufgabenstellung durch! ob es soweit in ordnung ist.



Ich finde die Aufgabenstellung ok. Ein wenig ungenau hinsichtlich des Aufrufs der Methode.

Deine Lösung ist aber unvollständig und dazu noch falsch.


----------



## Anfänger22 (21. Okt 2011)

Marcinek hat gesagt.:


> Ich finde die Aufgabenstellung ok. Ein wenig ungenau hinsichtlich des Aufrufs der Methode.
> 
> Deine Lösung ist aber unvollständig und dazu noch falsch.



kannst du mir vllt mal beim lösen der aufgabe helfen?

also die berechnung ist mir egal nur ich möchte wissen wie ich das mit dem aufrufen hinbekomme

beispiel 100 "DM"

dm ist string. muss ich das dann auch implementieren?


----------



## maki (21. Okt 2011)

So, bitte höflich bleiben und keine anderen User beleidigen.

*verschoben*


----------



## Marcinek (21. Okt 2011)

Die Klasse 
	
	
	
	





```
EURDMConverterImpl
```
 soll die Funktionen von 
	
	
	
	





```
Converter
```
 nutzen.

Du musst also in 
	
	
	
	





```
EURDMConverterImpl
```
 ein neues Objekt von Converer machen.

Dann brauchst einen Stück Code, der erkennt, ob man 100 DM oder EUR schreibt.

wenn du java MeinConverer 100 DM schreibst, dann kannst du dir in der mail die args[] ausgeben lassen um zu sehen, wo das EUR steht.


----------



## Anfänger22 (21. Okt 2011)

maki hat gesagt.:


> So, bitte höflich bleiben und keine anderen User beleidigen.
> 
> *verschoben*



wohin????


----------



## Anfänger22 (21. Okt 2011)

Marcinek hat gesagt.:


> Die Klasse
> 
> 
> 
> ...



verstehs nicht

bitte code aufführen


----------



## El Kabong (21. Okt 2011)

Weißt du wie man ein Objekt erzeugt?


----------



## Anfänger22 (21. Okt 2011)

El Kabong hat gesagt.:


> Weißt du wie man ein Objekt erzeugt?



ja klar.

zum beispiel 

Date d = new Date (int day, month............)

usw.

mein Interface


```
public interface EURDMConverter {
//Umrechnung von Euro nach DM
public double convertEUR2DM(double amount);
//Umrechnung von DM nach Euro
public double convertDM2EUR(double amount);
}
```

die Klasse


```
public class EURDMConverterImpl implements EURDMConverter {

	private double amount;
	private String Beschreibung;
	
	public EURDMConverterImpl (double Betrag, String Beschreibung)
	{
		this.amount = Betrag;
		this.Beschreibung = Beschreibung;
	}
	
	public String getBeschreibung()
	{
		return Beschreibung;
	}
	
	public double getBetrag()
	{
		return amount;
	}
	
	@Override
	public double convertEUR2DM(double amount) {
		 return amount * 1.95583;
	}

	@Override
	public double convertDM2EUR(double amount) {
		return amount /1.95583;
	}
}
```


und wie ich das dann per argument ablesen lassen soll weiß ich nicht. hilfe!



```
public class ConverterMain {

	public static void main(long args) {

	
	}
}
```


----------



## Anfänger22 (21. Okt 2011)

El Kabong hat gesagt.:


> Weißt du wie man ein Objekt erzeugt?



ja klar.

zum beispiel 

Date d = new Date (int day, month............)

usw.

mein Interface


```
public interface EURDMConverter {
//Umrechnung von Euro nach DM
public double convertEUR2DM(double amount);
//Umrechnung von DM nach Euro
public double convertDM2EUR(double amount);
}
```

die Klasse


```
public class EURDMConverterImpl implements EURDMConverter {

	private double amount;
	private String Beschreibung;
	
	public EURDMConverterImpl (double Betrag, String Beschreibung)
	{
		this.amount = Betrag;
		this.Beschreibung = Beschreibung;
	}
	
	public String getBeschreibung()
	{
		return Beschreibung;
	}
	
	public double getBetrag()
	{
		return amount;
	}
	
	@Override
	public double convertEUR2DM(double amount) {
		 return amount * 1.95583;
	}

	@Override
	public double convertDM2EUR(double amount) {
		return amount /1.95583;
	}
}
```


und wie ich das dann per argument ablesen lassen soll weiß ich nicht. hilfe!



```
public class ConverterMain {

	public static void main(String[] args) {

	
	}
}
```


----------



## Marcinek (21. Okt 2011)

```
public class ConverterMain {
 
    public static void main(string args[]) {
 
           for (String arg : args) 
               System.out.println(,,,);
    }
}
```


----------



## nillehammer (21. Okt 2011)

> Diese Klasse soll die Klasse Converter kapseln (has-a-Beziehung) und ihre Funktionalität nutzen.


D.h. Du sollst die Formel in den convertXX-Methoden nicht nochmal implementieren, sondern Converter benutzen

```
public class EURDMConverterImpl implements EURDMConverter {
 
    //Konstante für Beschreibung "DM"
    public static final String DM = "DM";

    // Und für EUR
    public static final String EUR = "EUR";

    //Hier wird der Converter benutzt
    private static final Converter EUR_DM_CONVERTER  = new Converter(1.95583);

    // Überflüssig, bitte streichen!
    private double amount;
    // Überflüssig, bitte streichen!
    private String Beschreibung;
    
    //Brauchst Du nicht, bitte den ganzen Konstruktor streichen
    public EURDMConverterImpl (double Betrag, String Beschreibung)
    {
        this.amount = Betrag;
        this.Beschreibung = Beschreibung;
    }
    
    // Methodennamen bitte klein und mit CamelCase. Änder das auch im Interface
    // Verwende sprechende Namen für Parameter, also besser eur statt amount.
    @Override
    public double convertEUR2DM(double amount) {
         return EUR_DM_CONVERTER.convertBtoA(amount);
    }

    // Diese Methode könnte evtl. auch aus dem Interface kommen
    // Hier siehst Du wie's besser geht. Der Name ist klein und Camelcase und der parameter ist sprechend.
    public String eur2DmAsString(final double eur) {
       return convertEUR2DM(eur) + " " + DM;
    }
 
   // Methodennamen bitte klein und mit CamelCase. Änder das auch im Interface
    // Verwende sprechende Namen für Parameter, also besser dm statt amount.
    @Override
    public double convertDM2EUR(double amount) {
        return EUR_DM_CONVERTER.convertAtoB(amount);
    }

      // Diese Methode könnte evtl. auch aus dem Interface kommen
    // Hier siehst Du wie's besser geht. Der Name ist klein und Camelcase und der parameter ist sprechend.
    public String eur2DmAsString(final double eur) {
       return convertDM2EUR(dm) + " " + EUR;
    }
}
```

In der Main-Methode erzeugst Du eine Instanz dieser Klasse und speichers sie in einer Referenzvariablen mit Typ EURDMConverter. Der Parameter für main ist zwingend ein String-Array. D.h. Du musst aus dem ersten Parameter erstmal einen Double machen.

Die Fallunterscheidung machst Du mit equals(). Du kannst Die Konstanten aus der Klasse dafür verwenden.


----------



## ARadauer (21. Okt 2011)

Anfänger22 hat gesagt.:


> lies dir die aufgabenstellung durch!



 Jawohl! :shock: Hier herscht ein Ton wie beim Bund :autsch:


----------



## Firephoenix (21. Okt 2011)

Ob das jetzt passt oder nicht - den Pädagogikvortrag halte ich für nötig...

Mal ehrlich Anfänger22, du hast bereits vor 10 Monaten hier im Forum fragen zu Grundlagen gestellt, vor 7 Monaten gab es dann diesen Thread zu einer Hausübung der mich von der Aufmachung schon stark an diesen hier erinnert: http://www.java-forum.org/hausaufgaben/115018-datum-programm-nextday.html

Das bedeutet du beschäftigst dich zumindest mal sein 7 Monaten so mit Java, das von dir offenbar erwartet wird Schul- bzw Uniaufgaben damit zu lösen (je nachdem was davon für dich gilt).

Die Aufgabe die du jetzt in diesem Thread gepostet hast ist nun wirklich keine große Herausforderung wenn man sich mal mit den Grundlagen beschäftigt hat, alleine in der Aufgabenstellung findet man fast alles geschenkt was man sucht:

-Die Klasse Converter wurde sauber erklärt - die 13 Zeilen kann ein Anfänger nach 2 Wochen verstehen

Dann dieser Satz:


> Programmieren Sie eine Klasse EURDMConverterImpl, die die Umrechnung von
> Euro nach DM und umgekehrt ermöglicht. Diese Klasse soll die Klasse Converter
> kapseln (has-a-Beziehung) und ihre Funktionalität nutzen.



Du sollst Euro nach DM umrechnen (A nach B -> Converter) und die Funktionalität nutzen.
Und spätestens hier könnte man wenigstens mal erwarten, dass man sich sowas wie einen Converter in seiner Klasse erzeugt oder wenigstens von Converter erbt (erben wäre zwar ein Fehler, aber wenigstens ein nachvollziehbarer Fehler). Wie man hier sowas einfach ignoriert und stupide die Kurse in die Methoden klatschen kann ist mir mit dem Hintergrund ein absolutes Rätsel!!!
Tatsächlich steht das sogar nochmal in der Aufgabe:


> Realisieren Sie die beiden Methoden
> zur Umrechnung von DM nach EUR und anders herum unter Verwendung der Klasse
> Converter



Und so hart wie das jetzt auch ist, hier stehe ich voll hinter Marcinek, entweder man kommt mit einer Frage und etwas Eigeninitiative und macht es selbst und holt sich hier Kritik und Hilfe, oder man lässt etwas machen und zahlt dafür!

Und sich alles vorkauen zu lassen nach dem Motto:
"So du musst jetzt das machen, dannach schreibst du jenes und fügst noch das Stück Quellcode ein das ich dir gebe" ist auch etwas das einem beim Lernen unterstützen soll und kein Dauerzustand.

Gerade bei Hausaufgaben, Uniprojekten etc habe ich absolut kein Problem damit jemandem mal zu helfen - und wenn das mal 6 Stunden an nem Abend Hilfe für nen Projekt sind ist mir das auch egal - solange man sieht, dass derjenige auch was davon mitnimmt. Gerade bei Anfängerfragen versuche ich so gut ich kann und so korrekt wie ich kann jemandem zu helfen, sei es mit Code, weiterführenden Artikeln oder Textbeispielen.

Aber so wie der Thread hier wieder läuft wird das wohl wieder nur darauf rauslaufen, dass du dir aus 10-20 Posts deine Übung zusammenbaust, dein Java-Verständnis wird sich damit aber nicht ändern, und bei der nächsten Hausübung geht der ganze Tanz von vorne los.

nillehammer hat sich bei seinem Code schon richtig viel Mühe gegeben, aber auch dort stecken einige Details drin, die man ohne Grundwissen nicht nachvollziehen kann.

So genug von dem Pädagogik-teil - war trotzdem meiner Meinung mal notwendig.

Jetzt mal zu der Aufgabe:

Die Klasse Converter solltest du hoffentlich verstanden haben, falls nicht solltest du Begriffe wie Felder, Accessmodifiert, Getter/Setter und Instanzen nochmal nachholen.

Dann zu der Klasse EURDMConverterImpl:


> die die Umrechnung von
> Euro nach DM und umgekehrt ermöglicht


Aufgabe der Klasse - darüber nachdenken wie man das realisieren kann



> Diese Klasse soll die Klasse Converter
> kapseln (has-a-Beziehung) und ihre Funktionalität nutzen. Des Weiteren soll die Klasse
> das Interface EURDMConverter implementieren. Realisieren Sie die beiden Methoden
> zur Umrechnung von DM nach EUR und anders herum unter Verwendung der Klasse
> Converter.


Du sollst also in deiner Klasse die vorige Klasse Converter benutzen. Und zwar in den beiden Methoden zur umrechnung. Ein Ansatz dafür hat nillehammer bereits geliefert.



> Sehen Sie in Ihrer Klasse geeignete Attribute und Konstruktoren vor! Der
> Umrechnungsfaktor von Euro nach DM ist 1,95583 (rateAB).


Hier kann man sich mal gedanken darüber machen was die Klasse beim Instanzieren wissen muss und was man in Attribute auslagert (Ein gutes Attribut wäre z.b. eine Instanz von Converter, damit du dieses wiederverwenden kannst und nicht in jeder Umrechnungsmethode Converter neu instanzieren musst)

Zu Aufgabe b):

Du hast jetzt eine eigene Klasse geschrieben mit der du Euro und Dm umrechnen kannst.
Die Schwierigkeit hier liegt hier:


> Die Klasse erhält Ihre
> Eingabe über die Kommandozeilenargumente. Im ersten Argument („args[0]“) soll der
> Betrag, im zweiten Argument („args[1]“) die Währung übergeben werden. Die
> angegebene Währung bestimmt die Richtung der Umrechnung (Fallunterscheidung!).


Hierzu unbedingt mal über die Main-Methode von Java und insbesondere über das String-Array args informieren.
Du wirst hier auf 2 Schwierigkeiten treffen:
1. Dein Geldbetrag ist ein String und mit Strings kann man nicht rechnen (String in Zahl umwandeln)
und 2. Du kriegst eine Fallunterscheidung, musst also den String der Währung (z.B. "DM") prüfen und darauf reagieren (Wie vergleicht man Strings, If-Bedingungen verstehen)
Hier bekommst du sogar die Fehlerbehandlung geschenkt, du musst also nicht abfangen, dass einer dein Programm mit völlig falschen Argumenten aufruft.

Gruß


----------

