Vererbung Superklasse -> Subklasse

[martinho]

Hallo zusammen,

ich habe eine Frage welche Implementierung eleganter ist.

Und zwar habe ich grundsätzlich eine Superklasse die mehrere Attribute und eine Methode hat. Von dieser Superklasse leite ich mehrere Subklassen ab wobei zu den Attributen noch welche hinzugefügt werden, die Methode wird für jede Subklasse angepasst. Da das Programm eigentlich nur mit String arbeitet habe ich eine Klasse mit Definitionen erstellt damit man einen schnellen überblick erhält.

Definitionen (Auszug):

// Steckdosen
    public final static String sd_typ = "Switch";
    public final static String sd_name = "sd";
    public final static String sd_namehome = "sdhome";
    public final static String sd_name2 = "onOff";
    public final static String sd_label = "Steckdose";
    public final static String sd_labelhome = "Steckdose Homematic";
    public final static String sd_mapping = "";
    public final static String sd_channel = "nutzerwelten:sd:a651b2fa";
    public final static String sd_channel2 = "onOff";
    public final static String sd_channel2home = "homematic:HM-ES-PMSw1-Pl:4c27bc95:NEQ0386523:1#STATE";
    public final static String sd_dateiname = "NW_Steckdosen.items";

Nun ist die Frage ob ich die Attribute die ich der Subklasse hinzufüge noch in den Konstruktor packe.... z.B.

private String labelhome;
    private String channel2home;
    private String namehome;
    private int homeAnzahl;
  
    public Steckdosen(int Anzahl, int homeAnzahl) {
        super(sd_typ, sd_name, sd_name2, sd_label, sd_mapping, sd_channel, sd_channel2, Anzahl, sd_dateiname);
        this.labelhome=sd_labelhome;
        this.channel2home=sd_channel2home;
        this.namehome=sd_namehome;
        this.homeAnzahl=homeAnzahl;
    }

Oder in der Subklasse direkt die "sd_"-Attribute nutze ohne diese im Konstruktor anderen Variablen zuzuweisen. In der Methode selbst könnte ich ja einfach die in der Definitionen erstellen Variablen nutzen. Was ist hier eleganter? Wenn ich die Attribute nicht im Konstruktor erwähne gehören sie sozusagen auch nicht zum dem jeweiligen Objekt sehe ich das richtig?

Danke im voraus

Martin

 

[mrBrown]

Im Idealfall setzt du alle Attribute der Oberklasse im Konstruktiv der Oberklasse, übergibst sie diesem also im Konstruktor der Unterklassen.
Der jeweilige Konstruktor setzt direkt also nur die in der eigenen Klasse deklarieren Attribute.

Oder in der Subklasse direkt die "sd_"-Attribute nutze ohne diese im Konstruktor anderen Variablen zuzuweisen. In der Methode selbst könnte ich ja einfach die in der Definitionen erstellen Variablen nutzen. Was ist hier eleganter? Wenn ich die Attribute nicht im Konstruktor erwähne gehören sie sozusagen auch nicht zum dem jeweiligen Objekt sehe ich das richtig?

Was du hiermit meinst, erschließt sich mir allerdings nicht.

Da das Programm eigentlich nur mit String arbeitet habe ich eine Klasse mit Definitionen erstellt damit man einen schnellen überblick erhält.

Das ist btw durchaus Verbesserungswürdig

 

[martinho]

Im Idealfall setzt du alle Attribute der Oberklasse im Konstruktiv der Oberklasse, übergibst sie diesem also im Konstruktor der Unterklassen.
Der jeweilige Konstruktor setzt direkt also nur die in der eigenen Klasse deklarieren Attribute.

Das wären aber ziemliche viele Attribute. Ich habe die Oberklasse nur mit den Attributen ausgestattet die jede Unterklasse hat, und die Unterklassen dann mit weiteren Attributen die wirklich nur für diese Unterklasse ist hinzugefügt.

Was du hiermit meinst, erschließt sich mir allerdings nicht.

Ich kann ja die Definitionen also die Attribute die ich in der "Definitionen"-Klasse erstellt habe einfach durch import in die Subklasse integrieren und könnte die dann einfach verwenden. Ihnen etwas in den Konstruktor zu schreiben.

Das ist btw durchaus Verbesserungswürdig

Was wäre denn hier besser?

Die ganzen Strings sind dafür da diese dann später in richtiger Reihenfolge in Textdateien zu schreiben:

public void functAusgabe() {
      
        PrintWriter pWriter = null;

try {
  
    pWriter = new PrintWriter(new BufferedWriter(new FileWriter(dateiname)));
  
    
        pWriter.println("// Items");
        pWriter.println();
      
        int x=0;
      
        for (int i=1 ; i<=Anzahl ; i++){
          
            pWriter.println(itemTyp+" "+itemName+i+"_"+itemName2+" "+"\""+labelText+" "+itemName+i+" "+mapping+"\""+" "+"{channel="+"\""+channel+":"+itemName+i+":"+channel2+"\""+"}");
            x=x+1;
          
        }
      
} catch (IOException ioe) {
  
} finally {
    if (pWriter != null){
        pWriter.flush();
        pWriter.close();
    }
}
    }

Das wäre die Methode in der Oberklasse. Die Methode in einer Unterklasse sieht was anders aus:

@Override
    public void functAusgabe() {

        super.functAusgabe();

        try (PrintWriter pw = new PrintWriter(new FileOutputStream(new File(nk_dateiname), true /* append = true */))) {

            pw.println("");
            pw.println("// Alive Items");

            int x = 0;

            for (int i = 1; i <= Anzahl; i++) {

                pw.println(typ2 + " " + itemName + i + "_" + alive + " " + "\"" + alabel + " " + itemName + i + " " + amapping + "\"" + " " + "{channel=" + "\"" + channel + ":" + itemName + i + ":" + alive + "\"" + "}");
                x = x + 1;

            }

            pw.println("");
            pw.println("// ButtonAlert Items");

            x = 0;

            for (int i = 1; i <= Anzahl; i++) {

                pw.println(typ2 + " " + itemName + i + "_" + buttonalert + " " + "\"" + balertlabel + " " + itemName + i + " " + alertmapping + "\"" + " " + "{channel=" + "\"" + channel + ":" + itemName + i + ":" + buttonalert + "\"" + "}");
                x = x + 1;

            }

            pw.println("");
            pw.println("// AlertReset Items");

            x = 0;

            for (int i = 1; i <= Anzahl; i++) {

                pw.println(typ3 + " " + itemName + i + "_" + alertreset + " " + "\"" + alertresetlabel + " " + itemName + i + " " + "\"" + " " + "{channel=" + "\"" + channel + ":" + itemName + i + ":" + alertreset + "\"" + "}");
                x = x + 1;

            }

            pw.println("");
            pw.println("// AlertImpulse Items");

            x = 0;

            for (int i = 1; i <= Anzahl; i++) {

                pw.println(typ2 + " " + itemName + i + "_" + alertimpulse + " " + "\"" + aimpulselabel + " " + itemName + i + " " + "\"" + " " + "{channel=" + "\"" + channel + ":" + itemName + i + ":" + alertimpulse + "\"" + "}");
                x = x + 1;

            }

            pw.println("");
            pw.println("// Extra Items");

            x = 0;

            for (int i = 1; i <= Anzahl; i++) {

                pw.println(typ2 + " " + itemName + i + "_" + fallWarn + " " + "\"" + fallWarnlabel + " " + itemName + i + " " + alertmapping + "\"");
                pw.println(typ2 + " " + itemName + i + "_" + fallDetect + " " + "\"" + fallDetectlabel + " " + itemName + i + " " + alertmapping + "\"");
                pw.println(itemTyp + " " + itemName + i + "_" + buttonAlertPersist + " " + "\"" + buttonAlertPersistlabel + " " + itemName + i + "\"");
                pw.println(itemTyp + " " + itemName + i + "_" + chart + " " + "\"" + chartlabel + " " + itemName + i + "\"");
                pw.println("");
                x = x + 1;

            }

        } catch (FileNotFoundException ex) {
            Logger.getLogger(Kontakte.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

}

 

[mrBrown]

Das wären aber ziemliche viele Attribute. Ich habe die Oberklasse nur mit den Attributen ausgestattet die jede Unterklasse hat, und die Unterklassen dann mit weiteren Attributen die wirklich nur für diese Unterklasse ist hinzugefügt.

Zu viele Attribute ist dann Zeichen für schlechtes Design, aber kein Grund, den Konstruktor nicht zu nutzen

Ich kann ja die Definitionen also die Attribute die ich in der "Definitionen"-Klasse erstellt habe einfach durch import in die Subklasse integrieren und könnte die dann einfach verwenden. Ihnen etwas in den Konstruktor zu schreiben.

Redest du über statische Konstanten oder Attribute des Objekts?
Erstere kannst du natürlich überall nutzen - solltest du aber nur lesend und nicht schreibend.

Was wäre denn hier besser?

Passende Klassen/Enums - kommt halt immer drauf an.