Generische Konstruktor

Diskutiere Generische Konstruktor im Java Basics - Anfänger-Themen Bereich.
H

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
Code:
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
Code:
    public Rechnung<Privatkunde>(){
        anzahlrechnungenpri++;
    }
    
    public <Privatkunde> Rechnung(){
        anzahlrechnungenpri++;
    }
probiert aber keins der beiden Sachen hat funktioniert.


Hier nochmal der vollständige Code
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

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ß.
 
H

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

mrBrown

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

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:
Java:
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 { }
 
Zuletzt bearbeitet:
MoxxiManagarm

MoxxiManagarm

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

Java:
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 { }
 
F

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):
Java:
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 { }
 
Zuletzt bearbeitet:
MoxxiManagarm

MoxxiManagarm

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

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

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.
 
Thema: 

Generische Konstruktor

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben