Generische Konstruktor

[Hieu]

Hallo Leute,
und zwar hätte ich gerne 2 Konstruktor. Einmal einen um eine rechnung für einen Geschäftskunden zu erstellen und einmal einen Konstruktor um eine Rechnung für einen Privatkunden zu erstellen . Ich kann ja jetzt eine Rechnung so erstellen

Rechnung<Geschäftskunde> rechnung = new Rechnung<Geschäftskunde>();

die Frage ist wie sieht der der Konstruktor dazu aus weil würde gerne, dass immer wenn eine Rechnung für einen Geschäftskunden erstellt wird, dass dann auch der Zähler dazu sich um eins erhöht und das dann halt für den Privatkunden aus. Ich habe das jetzt

    public Rechnung<Privatkunde>(){
        anzahlrechnungenpri++;
    }
    
    public <Privatkunde> Rechnung(){
        anzahlrechnungenpri++;
    }

probiert aber keins der beiden Sachen hat funktioniert.


Hier nochmal der vollständige Code

public class Rechnung<T> {
    
    
    private String rechnungsnummer;
    private T kunde;
    private int anzahlgefahrenerkilometer;
    private boolean rechnungbezahlt;
    
    //Objektzähler
    public static int anzahlrechnungen = 0;
    public static int anzahlrechnungenpri = 0;
    public static int anzahlrechnungenge = 0;
    
    public Rechnung<Privatkunde>(){
        anzahlrechnungenpri++;
    }
    
    public <Privatkunde> Rechnung(){
        anzahlrechnungenpri++;
    }

 

[Robat]

Die Rechnung muss mEn nicht wissen wie oft es sie gibt. Dazu solltest du eine Factory oder einen Service erstellen, welcher dir die entsprechenden Rechnungen erstellt und über die Anzahl der bereits vorhandenen Rechnungen bescheid weiß.

 

[Hieu]

Die Rechnung muss mEn nicht wissen wie oft es sie gibt. Dazu solltest du eine Factory oder einen Service erstellen, welcher dir die entsprechenden Rechnungen erstellt und über die Anzahl der bereits vorhandenen Rechnungen bescheid weiß.

für meine Übung muss ich das aber so machen

 

[mrBrown]

Kannst du nicht über die Konstruktoren lösen, dafür kannst du aber zB eine Factory-Methode nutzen.

 

[MoxxiManagarm]

Dein bisheriger Code zeigt ein Feld T kunde. Ich denke was du in der Aufgabe tun sollst ist Konstruktoren zu erstellen, welche dieses Feld direkt befüllen. (Es macht ja auch ehrlich keinen Sinn eine Rechnung ohne Kunden zu haben). Auf diese Weise klappt das auch mit dem Zählen.

Beispiel:

public class GenericCounter<T extends FooBar> {
    private static int countA = 0;
    private static int countB = 0;

    private T value;

    public GenericCounter(T value) {
        this.value = value;
        switch(value.getClass().getSimpleName()) {
            case "A": countA++; break;
            case "B": countB++; break;
        }
    }

    public static void main(String... args) {
        GenericCounter<A> a = new GenericCounter<>(new A());
        GenericCounter<B> b = new GenericCounter<>(new B());
    }
}

abstract class FooBar { }

class A extends FooBar { }

class B extends FooBar { }

 

[MoxxiManagarm]

Bzw. nochmal ein problemnäheres Beispiel, weil ich vermute, dass es in die Richtung geht:

public class Rechnung<T extends Kunde> {
    private static int countKunde = 0;
    private static int countGeschaeftskunde = 0;
    private static int countPrivatekunde = 0;

    private String rechnungsnummer;
    private T value;

    public Rechnung(T value) {
        this.value = value;
        switch (value.getClass().getSimpleName()) {
            case "Kunde": rechnungsnummer = "K" + ++countKunde; break;
            case "Geschaeftskunde": rechnungsnummer = "G" + ++countGeschaeftskunde; break;
            case "Privatkunde": rechnungsnummer = "P" + ++countPrivatekunde; break;
        }
    }

    @Override
    public String toString() {
        return rechnungsnummer;
    }

    public static void main(String... args) {
        List<Rechnung> rechnungen = new ArrayList<>();

        rechnungen.add(new Rechnung<>(new Geschaeftskunde()));
        rechnungen.add(new Rechnung<>(new Geschaeftskunde()));
        rechnungen.add(new Rechnung<>(new Privatkunde()));
        rechnungen.add(new Rechnung<>(new Privatkunde()));
        rechnungen.add(new Rechnung<>(new Kunde()));
        rechnungen.add(new Rechnung<>(new Privatkunde()));

        System.out.println(rechnungen); // prints [G1, G2, P1, P2, K1, P3]
    }
}

class Kunde { }
class Geschaeftskunde extends Kunde { }
class Privatkunde extends Kunde { }

 

[fhoffmann]

public class Rechnung<T extends Kunde> {

Ich verstehe an dem Beispiel nicht, weshalb du hier überhaupt eine generische Klasse benötigst.
Es funktioniert doch auch so (ich habe hier im Wesentlichen T durch Kunde ersetzt):

public class Rechnung {
    private static int countKunde = 0;
    private static int countGeschaeftskunde = 0;
    private static int countPrivatekunde = 0;

    private String rechnungsnummer;
    private Kunde kunde;

    public Rechnung(Kunde kunde) {
        this.kunde = kunde;
        switch (kunde.getClass().getSimpleName()) {
            case "Kunde": rechnungsnummer = "K" + ++countKunde; break;
            case "Geschaeftskunde": rechnungsnummer = "G" + ++countGeschaeftskunde; break;
            case "Privatkunde": rechnungsnummer = "P" + ++countPrivatekunde; break;
        }
    }

    @Override
    public String toString() {
        return rechnungsnummer;
    }

    public static void main(String... args) {
        java.util.List<Rechnung> rechnungen = new java.util.ArrayList<>();

        rechnungen.add(new Rechnung(new Geschaeftskunde()));
        rechnungen.add(new Rechnung(new Geschaeftskunde()));
        rechnungen.add(new Rechnung(new Privatkunde()));
        rechnungen.add(new Rechnung(new Privatkunde()));
        rechnungen.add(new Rechnung(new Kunde()));
        rechnungen.add(new Rechnung(new Privatkunde()));

        System.out.println(rechnungen); // prints [G1, G2, P1, P2, K1, P3]
    }
}

class Kunde { }
class Geschaeftskunde extends Kunde { }
class Privatkunde extends Kunde { }

 

[MoxxiManagarm]

Ich habe das gesetzt weil es eben die Ausgangslage im Thema war

 

[fhoffmann]

Ich habe das gesetzt weil es eben die Ausgangslage im Thema war

Und ich habe nachgefragt, weil ich das Gefühl habe, dass schon die Ausgansfrage falsch gestellt war; hier sind keine generischen Klassen notwendig (außer natürlich dein java.util.List<Rechnung>).

 

[mrBrown]

Es funktioniert doch auch so (ich habe hier im Wesentlichen T durch Kunde ersetzt):

Damit verlierst du allerdings die Information, welcher Art der Kunde ist. <T extends Kunde> wäre mMn sinnvoller.

 

[fhoffmann]

Damit verlierst du allerdings die Information, welcher Art der Kunde ist. <T extends Kunde> wäre mMn sinnvoller.

Die Instanz weiß doch immer noch, von welcher Art (Klasse) sie ist.

 

[Barista]

Und ich habe nachgefragt, weil ich das Gefühl habe, dass schon die Ausgansfrage falsch gestellt war; hier sind keine generischen Klassen notwendig

Ich bin der gleichen Meinung.

Bei Generics geht es um Behälter, die unterschiedliche Dinge enthalten können (vereinfacht gesagt).
Parametrische Polymorphie.

Bei Rechnungen für Privat-Kunden und alternativ Geschäfts-Kunden geht es sicher um unterschiedliches Verhalten, also unterschiedliche Rechnungs-Formate.
Das ist klar ein Fall für objektorientierte Polymorphie, also unterchiedlich überschriebene Methoden.

 

[MoxxiManagarm]

Ich sag ja nicht, dass ihr Unrecht habt. Aber ihr wisst doch nicht was Hieu insgesamt vorhat, vielleicht benötigt er die Parametrische Polymorphie und ist nur noch nicht erkennbar. Einfach mal angenommen die Rechnung bekommt später noch eine Methode/Attribut, welche es erlaubt die Rechnung nicht an den Kunden zuzustellen, sondern an einen anderen. Bei diesem Vorgang soll nur der Gleiche Kundentyp erlaubt sein wie der, für den die Rechnung ausgestellt ist, d.h. Rechnungsempfänger kann nur ein Privatkunde sein, wenn auch der Kunde ein Privatkunde ist. Dann ist Generics definitiv der richtige Weg.

Oder Generics ist vielleicht schlichtweg eine Vorgabe einer Uniaufgabe.