# Datensturkturen und Methoden



## Thisor (26. Jan 2016)

Hey, ich komme gerade etwas durcheinander und komme nicht weiter.
Als erstes soll ich die Datensturkturen eingeben, aus der Sturktur festlegen was ein Objekt so für Attribute hat und sie dann in der Main auch zuweißen. Das habe ich auch getan.
Nun soll ich eine Methode schreiben, die die Steuer bezüglich des Hubraums berechnet. Die Funktion soll den Namen steuerHubraum haben, als Parameter ein Kfz entgegennehmen und die Steuer zurückgeben.
Die Steuer bezüglich des Hubraum berechnet sich wie folgt:

Pro angefangene 100ccm:
Ottormotor: 2,00;
Dieselmotor: 9,50;
Hinweis: Sie dürfen die Funktion Math.ceil() nutzen um ein double zum nächst größeren int zu runden.

```
public class Kfz {

    String fahrzeugbeschreibung;
    short hubraum;//in ccm
    Motorart art;//Dieselmotor oder Ottomotor
    short jahrErstzulassung;
    short emissionswert;//in g/km
    float steuer; //wird später berechnet

    public static Kfz create(String fahrzeugbeschreibung, short hubraum, Motorart art, short jahrErstzulassung,
            short emissionswert) {
        Kfz auto = new Kfz();
        auto.fahrzeugbeschreibung = fahrzeugbeschreibung;
        auto.art = art;
        auto.jahrErstzulassung = jahrErstzulassung;
        auto.emissionswert = emissionswert;

        return auto;

    }

    public static double steuerHubraum(Kfz auto) {

        double steuer = 0;

        if (Motorart == Motorart.DIESELMOTOR) {

        }
        return steuer;
    }

    public static void main(String[] args) {
        Kfz[] auto = new Kfz[4];
        auto[0] = create("Golf 1.4 TSI", (short) 1390, Motorart.OTTOMOTOR, (short) 2009, (short) 144);
        auto[1] = create("Honda Insight", (short) 1300, Motorart.OTTOMOTOR, (short) 2012, (short) 101);
        auto[2] = create("Smart CDI", (short) 800, Motorart.DIESELMOTOR, (short) 2012, (short) 88);
        auto[3] = create("Porsche Cayenne", (short) 4800, Motorart.OTTOMOTOR, (short) 2009, (short) 358);

    }

}
```
Zusatzfrage:
Muss ich nicht Hubraum oder die erstellten Autos mit reingeben, damit die Werte auch gegeben werden? In der Aufgabe steht ja nur ich solle nur Kfz als Parameter mitgeben


----------



## Joose (26. Jan 2016)

Ja sprich als Parameter bekommt die Methode ein Objekt vom Typ Kfz übergeben.
Dieses Objekt hat Attribute wie "fahrzeugbeschreibung", "hubraum", "art", "steuer", ....
Mit diesen Attributen kannst du dann in der Methode arbeiten.


----------



## Thisor (26. Jan 2016)

Jap, aber ich kam nicht drauf das ich in der if-Anweißung mit auto.art zugreifen muss


----------



## Joose (26. Jan 2016)

Jetzt weißt du es aber


----------



## kneitzel (26. Jan 2016)

Also ich kenne die Anforderung nicht, aber Dein Code (so er auch technische korrekt ist), ist in meinen Augen sehr "dubios". Die massive Verwendung von static Funktionen führt zumindest zu ungewohntem Code.

a) Dein public static Kfz create hätte ich als Konstruktor erwartet, so dass statt einem KFZ.create(...) einfach ein new KFZ(....) benutzt wird. (Du hast nur deshalb kein "KFZ." nutzen müssen, da Du alles in die Klasse KFZ gepackt hast. Separation of Concerns - Du hast da Dinge gemixt, die so nicht zusammen gehören!)
b) Die Aufrufe KFZ.steuerHubraum(KFZ meinAuto) sind auch ungewohnt. Da würde ich Aufrufe wie meinAuto.steuerHubraum() erwarten.

Das, was Du da geschrieben hast, entspricht zumindest in meinen Augen nicht wirklich einem objektorientierten Ansatz.

Konrad


----------



## Thisor (26. Jan 2016)

Richtig @kneitzel , hier geht es nämlich auch nicht um objektorientierte Programmierung. Sondern nur das man mit Datenstrukturen und mit Methoden besser umgehen kann/versteht, weiß wie sie funktionieren etc.
In dieser Aufgabe (und die die noch heute und morgen kommen werden ) sollen wir auch gar nicht mit Konstruktoren arbeiten.


----------



## Thisor (26. Jan 2016)

ops doppelt gemoppelt


----------



## Thisor (26. Jan 2016)

Okay, ich habe nun die steuerHubraum-Mehode erstellt.
Zusätzlich kommt noch die Methode steuerEmission dazu.
Als drittes soll die Methode steuer kommen, welche ein Kfz als Parameter entgegennimmt und die Summe aus den ersten beiden Methoden zurückliefert.

So sieht mein code aus:

```
public class Kfz {

    String fahrzeugbeschreibung;
    short hubraum;
    Motorart art;
    short jahrErstzulassung;
    short emissionswert;
    float steuer;

    public static Kfz create(String fahrzeugbeschreibung, short hubraum, Motorart art, short jahrErstzulassung,
            short emissionswert) {
        Kfz auto = new Kfz();
        auto.fahrzeugbeschreibung = fahrzeugbeschreibung;
        auto.art = art;
        auto.jahrErstzulassung = jahrErstzulassung;
        auto.emissionswert = emissionswert;

        return auto;
    }

    public static double steuerHubraum(Kfz auto) {
        double steuer = 0;

        if (auto.art == Motorart.DIESELMOTOR) {
            steuer = auto.hubraum % 100;
            if (steuer != 0) {
                steuer += 2.00;
            }
        } else {
            steuer = auto.hubraum % 100;
            if (steuer != 0) {
                steuer += 9.50;
            }
        }
        return steuer;
    }

    public static double steuerEmision(Kfz auto) {
        double emision = 0;

        if (auto.jahrErstzulassung < 2012) {
            emision = auto.emissionswert - 120;
            emision *= 2;
            if (emision <= 0) {
                System.out.println("Keine Steuerrückgabe!");
            }
        } else if (auto.jahrErstzulassung > 2012 && auto.jahrErstzulassung < 2014) {
            emision = auto.emissionswert - 110;
            emision *= 2;
            if (emision <= 0) {
                System.out.println("Keine Steuerrückgabe!");
            }
        } else {
            emision = auto.emissionswert - 95;
            emision *= 2;
            if (emision <= 0) {
                System.out.println("Keine Steuerrückgabe!");
            }
        }
        return emision;
    }

    public static double steuer(Kfz auto) {
        double steuer = 0;
        return steuer;
    }

    public static void main(String[] args) {
        Kfz[] auto = new Kfz[4];
        auto[0] = create("Golf 1.4 TSI", (short) 1390, Motorart.OTTOMOTOR, (short) 2009, (short) 144);
        auto[1] = create("Honda Insight", (short) 1300, Motorart.OTTOMOTOR, (short) 2012, (short) 101);
        auto[2] = create("Smart CDI", (short) 800, Motorart.DIESELMOTOR, (short) 2012, (short) 88);
        auto[3] = create("Porsche Cayenne", (short) 4800, Motorart.OTTOMOTOR, (short) 2009, (short) 358);

        System.out.println(steuerEmision(auto));
    }
}
```

Doch da wird nichts ausgegeben. Meine Vermutung ist, dass in den Methoden keine Werte ausgegeben werden. Ich kanns nicht mal in der Konsole ausgeben da zb: steuerHubraum(auto);  not applicable ist..
Ich könnte ja irgendeinen Wert da ein geben, aber ich denke das ist nicht der Sinn davon 
bitte um hilfe x_x übermorgen ist das Testat :/


----------



## kneitzel (26. Jan 2016)

Also ein paar Dinge, die mir auffallen:
a) auto ist ein Array von KFZ, aber steuerEmission nimmt nur ein KFZ. Also müsstest Du das per for schleife für jedes Auto aufrufen oder so.
b) Du hast steuer als Instanzvariable und auch teilweise als lokale Variable. Das ist extrem unschön und ich würde dies vermeiden wollen. Und wenn Du die Steuer so einfach ausrechnen kannst, ist die Frage, in wie weit Du die überhaupt lokal abspeichern musst ...

Konrad


----------



## Thisor (26. Jan 2016)

kneitzel hat gesagt.:


> Also ein paar Dinge, die mir auffallen:
> a) auto ist ein Array von KFZ, aber steuerEmission nimmt nur ein KFZ. Also müsstest Du das per for schleife für jedes Auto aufrufen oder so.
> b) Du hast steuer als Instanzvariable und auch teilweise als lokale Variable. Das ist extrem unschön und ich würde dies vermeiden wollen. Und wenn Du die Steuer so einfach ausrechnen kannst, ist die Frage, in wie weit Du die überhaupt lokal abspeichern musst ...
> 
> Konrad


Dann aber auch in steuerHubraum mit der Schleife rein, oder?


----------



## kneitzel (26. Jan 2016)

Also steuerHubraum nimmt ein KFZ, und für dieses eine KFZ wird dann die Steuer für den Hubraum berechnet. Was für eine Schleife meinst Du da zu benötigen?

Es gibt Verkäufer. Diese haben die Funktion fragPreis(Produkt). Da kannst Du also nun den Verkäufer nach dem Preis von einem Produkt fragen. Wenn Du jetzt die Preise für mehrere Produkte haben willst, dann gehst Du hin und fragst die Produkte einzeln ab: Was kosten dies? Was kostet jenes? Der Verkäufer hat es immer nur mit einem Produkt zu tun, für das er dann etwas macht. Aber Du gehst evtl. das ganze Sortiment durch.

Konrad


----------



## Joose (26. Jan 2016)

Thisor hat gesagt.:


> Als drittes soll die Methode steuer kommen, welche ein Kfz als Parameter entgegennimmt und die Summe aus den ersten beiden Methoden zurückliefert.


Naja dann sollt die Methode "steuer" doch die beiden anderen Methode aufrufen und jeweils den Parameter übergeben, den Rückgabewert der Methoden addierst du zusammen und lieferst ihn per return zurück.



Thisor hat gesagt.:


> ```
> public static double steuerHubraum(Kfz auto) {
> double steuer = 0;
> 
> ...



Hier hast du einen Fehler drinnen. Laut deiner Angabe im 1.Post soll die Steuer (abhängig von der Motorart) je angefangenen 100ccm berechnet werden. -> Sprich für 144ccm müsstest du 4.00 bzw. 19.00 als ergebnis bekommen.
Du rechnest hier mit Modulo (dividierst durch 100 und rechnest mit dem Rest der Division weiter) und addierst dann eben nur 1x die gewünschte Steuer.

Hier eine mögliche Version (inkl auf die hingewiesene Math.ceil() Methode):

```
public static double steuerHubraum(Kfz auto) {
   double hubraumSteuer = 0.0;
   if(auto.art == Motorart.DIESELMOTOR) {
     hubraumSteuer = 2.0;
   } else {
     hubraumSteuer = 9.5;
   }
   int steuerMultiplikator = Math.ceil(auto.hubraum / 100.0); // berechnet die anzahl der angefangenen 100ccm, dezimalzahlen werden aufgerundet
   return hubraumSteuer * steuerMultiplikator;
}
```


----------



## Thisor (26. Jan 2016)

Moment, ich bin gerade etwas überfordert. Zu der Methode Hubraum habe ich jetzt das hier:


```
public static double steuerHubraum(Kfz[] auto) {

        double steuerHub = 0;
        for (int i = 0; i < auto.length; i++) {
            // berechnung für Ottomotor
            if (auto[i].art == Motorart.OTTOMOTOR) {
                steuerHub = auto[i].hubraum / 100;
                steuerHub = Math.ceil(steuerHub);
                if (steuerHub > 0) {
                    steuerHub += 2;
                    return steuerHub;
                } else if (steuerHub < 1) {
                    return steuerHub;
                }
            }
            // berechnung für Ottomotor:
            if (auto[i].art == Motorart.DIESELMOTOR) {
                steuerHub = auto[i].hubraum / 100;
                steuerHub = Math.ceil(steuerHub);
                if (steuerHub > 0) {
                    steuerHub += 9.5;
                    return steuerHub;
                } else if (steuerHub < 1) {
                    return steuerHub;
                }
            }
        }

    }
```


----------



## kneitzel (26. Jan 2016)

Wieso nimmst Du jetzt als Parameter ein Array von Autos? Den Punkt hatte ich doch schon versucht zu erklären. Und du berechnest "Etwas" beim ersten Auto und gehst dann mit return raus....

Bitte überleg doch einmal genau, wie DU die Steuer für ein Auto berechnen würdest. Nimm einfach ein Beispiel und rechne es uns einmal vor. Und dann schau einmal, wie Du Deine Berechnungen / Überlegungen umsetzen könntest ...


----------



## Thisor (26. Jan 2016)

Ich muss doch jedes einzelne Auto durchlaufen...ah oder mach ich das zum Schluss in der Mainmethode? 

1. Also, ich würde erstmal prüfen welcher Motor in dem Auto eingebaut ist.
2. Dann würde ich den Hubraum durch 100 teilen und für jedes mal geteilt durch 100 mit 2(wenn Ottomotor, sonst mit +9,5 da Dieselmotor) addieren. 
3. Mit Math.ceil() runden
4. Und prüfen ob es einen Restwert gibt. Falls ja, den Vorgang wiederholen und pro Vorgang mit +2 (oder mit + 9,5) addieren.


----------



## kneitzel (26. Jan 2016)

Machen wir ein anderes Beispiel: Pro angefangenen Apfel musst du 2 Euro bezahlen. Jetzt zählst Du die Äpfel und addierst dann addierst Du am Ende 2 Euro?

Also was Du machst, ist die Anzahl der Äpfel ermitteln. Da kommt dann vor mir aus 3,5 heraus.
Da kannst Du dann mittels Math.ceil runden - dann hast Du 4.
Dann kannst Du den Preis für diese 4 Äpfel ermitteln.

Oder wenn Du ohne Math.ceil arbeiten wolltest:
Dann machst Du die Division in einen Integer. Da fehlt dann der Nachkommateil. Dann prüfst Du das Modulo Ergebnis und wenn das nicht 0 ist, addierst Du 1. Und dann berechnest Du den Gesamtpreis.
(Hier stimmt das Apfel-Beispiel leider nicht, da Du da 3,5 Äpfel nicht als Modulo Operation sehen kannst. Aber bei dem Hubraum geht es ja um angefangene 100 Kubikzentimeter.)

Konrad


----------



## Thisor (26. Jan 2016)

Sorry, ich hocke seit 8 Uhr in der Uni und solangsam funktioniert der Kopf nicht mehr..
Kann ich nicht einfach prüfen ob hubraum % 100 != 0 ist dann mache ergebnis * 2, wenn hubraum % 100 <=0 ist dann gebe nichts zurück?


----------



## Joose (26. Jan 2016)

Thisor hat gesagt.:


> Sorry, ich hocke seit 8 Uhr in der Uni und solangsam funktioniert der Kopf nicht mehr..
> Kann ich nicht einfach prüfen ob hubraum % 100 != 0 ist dann mache ergebnis * 2, wenn hubraum % 100 <=0 ist dann gebe nichts zurück?



Schau dir bitte meinen letzten Post an, dort habe ich eine Beispiellösung für die "steuerHubraum" Methode geschrieben. Inkl ceil


----------



## kneitzel (26. Jan 2016)

Also lass Dir die Berechnung noch einmal in Ruhe durch den Kopf gehen oder mach Schluss für heute und mach Morgen weiter. Evtl. hast Du gerade eine Blockade. Die Berechnungsmöglichkeiten habe ich ja etwas beschrieben. Ohne das ceil hast Du sowas wie:

```
int angefangeneHunderter = hubraum / 100;
if (hubraum % 100 > 0) angefangeneHunderter++;
steuer = angefangeneHunderter * betragProHunderter;
```


----------



## Thisor (26. Jan 2016)

Bin zurück 

```
public class Kfz {

    String fahrzeugbescheinigung;
    short hubraum;
    Motorart art;
    short erstzulassung;
    short emissionswert;
    short steuer;

    public static Kfz create(String fahrzeugbescheinigung, short hubraum,
            Motorart art, short erstzulassung, short emissionswert) {
        Kfz auto = new Kfz();
        auto.fahrzeugbescheinigung = fahrzeugbescheinigung;
        auto.hubraum = hubraum;
        auto.art = art;
        auto.erstzulassung = erstzulassung;
        auto.emissionswert = emissionswert;

        return auto;

    }

    public static double steuerHubraum(Kfz auto) {

        double steuerHub = 0;

        // berechnung für Ottormotor
        if (auto.art == Motorart.OTTOMOTOR) {
            steuerHub = auto.hubraum / 100;
            steuerHub = Math.ceil(steuerHub);
            steuerHub = steuerHub * 2;
        }
        // berechnung für Dieselmotor
        else if (auto.art == Motorart.DIESELMOTOR) {
            steuerHub = auto.hubraum / 100;
            steuerHub = Math.ceil(steuerHub);
            steuerHub = steuerHub * 2;

        }

        return steuerHub;

    }

    public static double steuerEmision(Kfz auto) {

        double steuerEmision = 0;
        if (auto.erstzulassung < 2012) {
            steuerEmision = auto.emissionswert - 120;
            steuerEmision *= 2;
            if (steuerEmision < 0) {
                System.out.println("Keine Steuerrückgabe!");
                steuerEmision = 0;
            }
        } else if (auto.erstzulassung >= 2012 && auto.erstzulassung < 2014) {
            steuerEmision = auto.emissionswert - 110;
            steuerEmision *= 2;
            if (steuerEmision < 0) {
                System.out.println("Keine Steuerrrückgabe!");
                steuerEmision = 0;
            }
        } else {
            steuerEmision = auto.emissionswert - 95;
            steuerEmision *= 2;
            if (steuerEmision < 0) {
                System.out.println("Keine Steuerrückgabe!");
                steuerEmision = 0;
            }

        }

        return steuerEmision;
    }

    public static double steuer(Kfz auto) {
        double steuer = 0;
        steuer = steuerHubraum(auto) + steuerEmision(auto);

        return steuer;
    }

    public String toString() {
        return fahrzeugbescheinigung + hubraum + art + erstzulassung
                + emissionswert;
    }

    public static void main(String[] args) {
        Kfz[] auto = new Kfz[4];
        auto[0] = create("Golf 1.4 TSI", (short) 1300, Motorart.OTTOMOTOR,
                (short) 2009, (short) 144);
        auto[1] = create("Honda Insight", (short) 1300, Motorart.OTTOMOTOR,
                (short) 2009, (short) 101);
        auto[2] = create("Smart CDI", (short) 800, Motorart.DIESELMOTOR,
                (short) 2012, (short) 88);
        auto[3] = create("Porsche Cayenne", (short) 4800, Motorart.OTTOMOTOR,
                (short) 2009, (short) 358);

    }
}
```

Die letzte Aufgabe lautet: 
"Durchlaufen Sie den Array aus Aufgabe 6.1.2 (Sind quasi meine erstellten Auto[0] bis [3]). Berechnen sie die Steuer und speichern Sie diese in der Kfz Datenstruktur."
Wie funktioniert das?


----------



## kneitzel (27. Jan 2016)

Also erst einmal ein paar Anmerkungen zu Deinem Code:
- Du hast einmal einen Fehler - bei Diesel soll der Faktor für die Steuer nicht 2 sondern 9,5 sein. Da steht aber noch eine 2.
- Du hast "doppelten" Code. Wiederholungen von Code sind immer blöd zu warten. Daher würde ich da ein paar Veränderungen vorschlagen:
a) Die Checks prüfen nur, was unterschieden werden soll, also Diesel/Benzin oder eben das Zulassungsjahr. Dann setzt Du halt eine neu einzuführende Variable steuerFaktor oder emmisionsFreimenge. 
b) Dann kannst Du die Berechnung nach den if/else Blocks einmalig durchführen. 
c) selbst wenn Du das nicht unbedingt machen willst, dann solltest Du bei der steuerEmision den Check auf negative Werte aus den Blöcken ziehen und vor das return statement setzen. Dann hast Du das nur noch einmal...

Und was den neuen Teil angeht: Du erzeugst in der main Funktion ja ein Array auto. Dieses kannst Du doch durchlaufen. Und für jedes Auto kannst Du dann die von Dir geschriebene Funktion steuer aufrufen. Und dann kannst Du diesen Wert in dem KFZ speichern. Da gibt es ja auch eine Instanzvariable steuer (aber da stimmt wohl der Datentyp noch nicht).

Generell solltest Du aber sehen, dass dies nun suboptimal ist. Du kannst die steuer dann zum einen aus der Variable lesen oder eben berechnen. Aber Du weisst ja nicht, ob die Variable schon gesetzt wurde. 
a) Also da die Berechnung unkritisch ist (kostet nicht groß Zeit), würde ich die Variable heraus nehmen.
b) Oder wenn die Variable da sein soll, würde ich diese Variable direkt beim Erstellen des Objekts berechnen (im Konstruktor bzw. derzeit bei Dir die create Methode)
c) oder man macht die Instanzvariable von einem Typ, der auch null sein kann (Zu jedem primitiven Datentyp gibt es auch eine Java Klasse! Wenn man den Typ nimmt, dann ist null auch möglich!). Und dann ändert man die Funktionen so, dass man halt zu der Instanzvariablen steuer einen Getter hat. Dieser getter prüft, ob die variable null ist. Sollte dies der Fall sein, dann wird die Steuer erst berechnet und in der Variablen gespeichert. Und dann wird die Variable ausgegeben.
(Das ist dann das Konzept vom "lazy load" - daten werden erst geladen oder berechnet, wenn diese benötigt werden.) Dabei ist noch zu beachten: Die anderen Setter müssen dann ggf. auch die steuer auf null setzen. Wenn ich also setHubraum aufrufe, dann würde sich die Steuer ja ändern und damit ist der berechnete Wert ungültig.)


----------



## Jardcore (27. Jan 2016)

Btw... tritt doch bitte deinen Lehrer / Professor ans Bein, weil er Objektorientierung auf sehr dubiosen Wege beibringt.
Wenn man schon Java benutzt sollte man von Anfang an objektorientiert Programmieren.
Man könnte vielleicht vorher C oder eine andere funktionale Sprachen benutzten um den Unterschied zu sehen... aber Java misshandeln um schlechten Code zu produzieren... ich weiß ja nicht ob das der richtige Ansatz ist.

Ich hoffe für deinen Lehrer/Prof das er auch eine objektorientierten Ansatz als richtige Lösung akzeptiert.

P.s.: kannst du mal die Aufgabenstellung posten?


----------



## Thisor (27. Jan 2016)

Im zweiten Semester haben wir objektorientiere Programmierung, ich vermute das erste Programmierung soll uns die primitiven Daten lehren, wie das ganze abläuft, dann welche Methode es gibt, wie man neue Objekte erstellt und eben Zugriffe und Anwendungen von Methoden.
Hierbei ist es nicht erlaubt mit Konstruktoren, get(), set() etc anzuwenden.

Zur Aufgabenstellung: 

Am 1. Juli 2009 wurde die seit 60 Jahren unveränderte KfzBesteuerung zum ersten Mal
reformiert. Mit ausschlaggebend ist seitdem der CO2Ausstoß. Aktuell ergibt sich die
KfzSteuer aus der Steuer für den Hubraum plus der Steuer für die CO2Emissionen.
6.5.1 Definieren Sie eine Datenstruktur Kfz , die die folgenden Daten zu einem Kfz
aufnehmen kann. Wählen Sie dabei geeignete Datentypen. (Also nicht immer nur double oder int verwenden)

● Fahrzeugbeschreibung
● Hubraum (in ccm)
● Motorart (Dieselmotor oder Ottomotor)
● Jahr der Erstzulassung
● Emissionswert (in g/km)
● Steuer (wird später berechnet)

6.5.2 Nachfolgend finden Sie eine Beschreibung einiger Kfz. Erzeugen Sie ein KfzArray
mit den in der Tabelle stehenden Daten. 
Fahrzeugbeschreibung | Hubraum| Motorart| Erstzulassung |Emissionswert
Golf 1.4 TSI |1390 |Ottomotor 2009 |144
Honda Insight| 1300| Ottomotor| 2012 |101
Smart CDI| 800 |Dieselmotor| 2012 |88
Porsche Cayenne |4800 |Ottomotor| 2009 |358

6.5.3 Schreiben Sie eine Funktion, die die Steuer bezüglich des Hubraums berechnet. Die
Funktion soll den Namen steuerHubraum haben, als Parameter ein Kfz
entgegennehmen und die Steuer zurückgeben.
Die Steuer bezüglich des Hubraums berechnet sich wie folgt:
Pro angefangene 100 Kubikzentimeter (ccm)
Ottomotor 2,00 Euro
Dieselmotor 9,50 Euro
Hinweis: Sie dürfen die Funktion Math.ceil() nutzen um ein double zum nächst
größeren int zu runden.

6.5.4 Schreiben Sie eine Funktion, die die Steuer bezüglich der Emission berechnet. Die
Funktion soll den Namen steuerEmision haben und als Parameter ein Kfz
entgegennehmen und die Steuer zurückgeben.
Die Steuer bezüglich der Emission berechnet sich wie folgt:
Erstzulassung Sockelwert für CO2- Freibetrag
vor 2012 120 g/km
ab 2012 110 g/km
ab 2014 95 g/km
Für jedes g/km über dem Freibetrag müssen 2 Euro bezahlt werden. Achten Sie
drauf keine negativen Werte zu erhalten. Mann bekommt keine Steuern zurück,
wenn man sich unter dem Sockelwert befindet.

Beispiel: Erstzulassung am 1. Februar 2012, Emissionswert von 135 g/km
135 g/km 110
g/km = 25 g/km "zu viel"
25 x 2 Euro = 50 Euro

6.5.5 Schreiben Sie eine Funktion steuer, welche ein Kfz entgegennimmt und
die Summe aus steuerHubraum und steuerEmision zurückliefert.

6.5.6 Durchlaufen Sie das Array aus Aufgabe 6.1.2. Berechnen sie die Steuer und
speichern Sie diese in der Kfz Datenstruktur.


----------



## Jardcore (27. Jan 2016)

Die Aufgabenstellung verbietet so aber keinen objektorientierten Ansatz 

Ich würde ein Objekt Kfz erstellen. 
Dann würde ich vielleicht noch ein Objekt KfzSteuerrechner erstellen, dieser hat alle Methode die in der Aufgabenstellung gefordert sind.

In einer Main Klasse würde ich ein Kfz Array und den KfzSteuerrechner anlegen.
Anschließend würde ich das Array durchiterieren und die jeweiligen Methoden des KfzSteuerrechners ausführen und die geforderten Werte im Kfz setzten.

Sollte so keine 10min dauern, die Methoden hast du ja schon alle.


----------



## Thisor (29. Jan 2016)

Ich habe die Aufgabe noch fertig bearbeitet wie sie gewünscht war, hier der Code ( Enum war in einer anderen Klasse mit den Variablen Dieselmotor und Ottomotor eben) :

```
public class Kfz {
    String fahrzeugbeschreibung;
    short hubraum;
    Motorart motorart;
    short erstzulassung;
    short emissionswert;
    float steuer;

    /**
     *
     * @param fahrzeugbeschreibung
     * @param hubraum
     * @param motorart
     * @param erstzulassung
     * @param emissionswert
     * @return
     */
    public static Kfz create(String fahrzeugbeschreibung, short hubraum, Motorart motorart, short erstzulassung,
            short emissionswert) {

        Kfz kfz = new Kfz();
        kfz.fahrzeugbeschreibung = fahrzeugbeschreibung;
        kfz.hubraum = hubraum;
        kfz.motorart = motorart;
        kfz.erstzulassung = erstzulassung;
        kfz.emissionswert = emissionswert;

        return kfz;

    }

    /**
     *
     * @param kfz
     * @return
     */
    public static double steuerHubraum(Kfz kfz) {

        double summeHubraum = 0;
        if (kfz.motorart == Motorart.OTTOMOTOR) {
            summeHubraum = kfz.hubraum / 100;
            summeHubraum = Math.ceil(summeHubraum);
            summeHubraum *= 2;

        } else if (kfz.motorart == Motorart.DIESELMOTOR) {
            summeHubraum = kfz.hubraum / 100;
            summeHubraum = Math.ceil(summeHubraum);
            summeHubraum *= 9.5;
        }
        return summeHubraum;
    }

    /**
     *
     * @param kfz
     * @return
     */
    public static float steuerEmission(Kfz kfz) {
        float summeEmission = 0;

        if (kfz.erstzulassung < 2012) {
            summeEmission = kfz.emissionswert - 120;
            summeEmission *= 2;
            if (summeEmission <= 0) {
                summeEmission = 0;
            }

        } else if (kfz.erstzulassung >= 2012 && kfz.erstzulassung < 2014) {
            summeEmission = kfz.emissionswert - 110;
            summeEmission *= 2;
            if (summeEmission <= 0) {
                summeEmission = 0;
            }

        } else if (kfz.erstzulassung > 2014) {
            summeEmission = kfz.emissionswert - 95;
            summeEmission *= 2;
            if (summeEmission <= 0) {
                summeEmission = 0;
            }

        }
        return summeEmission;

    }

    /**
     *
     * @param kfz
     * @return
     */
    public static double steuer(Kfz kfz) {
        double summeSteuer = steuerEmission(kfz) + steuerHubraum(kfz);

        return summeSteuer;
    }

    /**
     *
     * @param args
     */
    public static void main(String[] args) {

        Kfz[] kfz = new Kfz[4];
        kfz[0] = create("Golf 1.4 TSI", (short) 1390, Motorart.OTTOMOTOR, (short) 2009, (short) 144);
        kfz[1] = create("Honda Insight", (short) 1300, Motorart.OTTOMOTOR, (short) 2012, (short) 101);
        kfz[2] = create("Smart CDI", (short) 800, Motorart.DIESELMOTOR, (short) 2012, (short) 88);
        kfz[3] = create("Porsche Cayenne", (short) 4800, Motorart.OTTOMOTOR, (short) 2009, (short) 358);

        for (int i = 0; i < kfz.length; i++) {
            kfz[i].steuer = Kfz.steuerEmission(kfz[i]);
            kfz[i].hubraum = (short) Kfz.steuerHubraum(kfz[i]);
            System.out.println(kfz[i]);
            System.out.println();

        }

    }

    @Override
    public String toString() {
        return "Fahrzeugbeschreibung: \n" + fahrzeugbeschreibung + "\nHubraum: " + hubraum + "\nMotorart: " + motorart
                + "\nErstzulassung: " + erstzulassung + "\nEmissionswert: " + emissionswert + "\nSteuer: " + steuer;
    }

}
```


----------



## kneitzel (29. Jan 2016)

Also zu dem Code paar Anmerkungen:
hubraum enthält den Hubraum des KFZ ... Da irgendwelche Steuern rein zu schreiben dürfte nicht korrekt sein.
Und javadoc kommentare sind eine gute Idee ... Sollten dann nur auch gefüllt werden.
Das ist, was ich so beim Überfliegen gesehen habe. Also kein Anspruch auf Vollständigkeit.


----------



## Thisor (29. Jan 2016)

Kannst du mir ein bsp. geben wie ein JavaDoc in der realtiät aussieht?
mfg


----------



## kneitzel (29. Jan 2016)

Ich hab jetzt einfach mal etwas von Deinem Code ausgeschnitten und gefüllt


```
/**
     * Beschreibung der Funktion, also etwas wie "Erzeugt eine neue KFZ instanz und gibt diese zurück".
     * @param fahrzeugbeschreibung Beschreibung des Parameters, also sowas wie "Beschreibung des Fahrzeugs"
     * @param hubraum Hubraum des Fahrzeugs in Kubikcentimetern
     * @param motorart Motorart (Benzin / Diesel / ...)
     * @param erstzulassung Jahr der Erstzulassung.
     * @param emissionswert Emmission des Fahrzeugs nach ...
     * @return Die neue KFZ Instanz.
     */
    public static Kfz create(String fahrzeugbeschreibung, short hubraum, Motorart motorart, short erstzulassung,
            short emissionswert) {
```

So in der Art halt.


----------



## Thisor (29. Jan 2016)

Ah okay, gut danke!
Übrigens, gestern hatte ich mein Testat und es lief super


----------

