Parameter in verschiedenen Anzahl und Typen

[Carcharoth]

Hallo

Ich möchte eine Klasse Programmieren die verschiedene Variablen halten und bearbeiten soll.
Nun weiss ich aber nicht im Voraus wie viele Variablen und von welchen Typen.

Der Konstruktor müsste also mit Parametern wie "int, int, String, String, double" oder auch "String, int, int" zurecht kommen.

Ich habe mir den Weg über eine ArrayList von Objekten überlegt. Das die ArrayList die primitiven Typen "wrappt" ist für mich i.O.
Gibt es einen besseren Weg ?

public class TestEintrag {
    public ArrayList<Object> daten;

    public TestEintrag(ArrayList<Object> daten) {
        this.daten = daten;
    }
    
    public void print() {
        for (Object ding: daten) {
            System.out.println(ding.getClass() + " --> " + ding.toString());
        }
    }

    public static void main(String[] args) {
         ArrayList<Object> liste = new ArrayList<Object>(){{
                add(1);
                add("Hund");
                add(3.14);
                add("Katze");
                add(2);
                   }};
                  
        TestEintrag testEintrag = new TestEintrag(liste);
        testEintrag.print();
    }
}

 

[httpdigest]

Du müsstest hier schon konkreter werden. Eine Klasse, "die verschiedene Variablen halten und bearbeiten soll", klingt erstmal komisch.
Was ist denn genau der Anwendungsfall?
Wo werden die Variablen später genutzt?

 

[Carcharoth]

Ich könnte z.B. Einträge in eine Datenbank speichern wollen.
Vielleicht sind es dann auch mehrere Datenbanken und dann sehen die Einträge nicht immer gleich aus.

Beispiel:

• Eintrag Typ A für die Datenbank der Mitarbeiter speichert jeweils Name (String), Vorname (String), Alter (int), Grösse (double), Gewicht (double)
• Eintrag Typ B für die Datenbank der Lieferanten speichert jeweils Firmenname (String), Postleitzahl (int), Ort (String), Umsatz (double)

Damit ich aber immer die gleiche Klasse Eintrag benutzen kann, muss sie mit verschiedenen Sätzen an Variablen zurecht kommen.

 

[Neumi5694]

Du kannst nur verarbeiten, was du kennst.
Eine Möglichkeit ist eben Object zu akzeptieren und dann mit der oben genannten Map zu arbeiten.
Die andere ist, die selbe Methode mit verschiedenen Parametern anzubieten.
Zusätzlich kannst du noch eine Object-Methode anbieten, falls beim Kompilieren tatsächlich noch nicht klar ist, was reinkommt.

public void handle (String value) {
    
}
public void handle (Integer value) {
    
}
public void handle (Character value) {
    
}

public void handle(Object o) {
    if (o == null) {
        System.out.println("null");
    } else if (o instanceof String s) {
        handle(o);
    } else if(o instanceof Integer i) {
        handle(i);
    } else if(o instanceof Character c) {
        handle(c);
    } else {
        System.out.println("Unknown type: " + o.getClass().getName());
    }
}

 

[Neumi5694]

Da war natürlich ein kleiner Fehler drin, in der ersten Fallprüfung sollte handle(s) aufgerufen werden, sonst haben wir eine Endlosschleife.

 

[KonradN]

Also Daten sollte man immer sauber modellieren. Wenn Du das Thema Datenbank nimmst, dann hast Du da ja schon ein super Beispiel. Wie ist das aufgebaut?

Du hast Tabellen mit Spalten. Zu jeder Spalte gibt es dann Name und Typ (Wobei Typ recht viel beinhaltet).
Dann hast Du Rows. Diese rows speichern Werte für jede Spalte.

Wenn man sich so ein Resultset anschaut, dann hat man ja:

• Man kann sich als Object geben lassen. Dann ist es halt irgendwas (was halt dem Typ entspricht)
• Man kann es sich als bestimmten Typ zurück geben lassen - ob das Sinn macht oder nicht muss man dann entscheiden - dann gibt es ggf. eine Exception.

Das kann man dann z.B. genau so abbilden.

In Deinem Fall kann man es schon ganz trivial machen: Dann hast Du z.B. einfach eine Klasse wie:

public class DataRow {
    private Object[] values;
    
    public DataRow(Object... values) {
        this.values = values;
    }
}

Da kannst Du jetzt irgendwas an Daten speichern. Du hast absolut keine Grenzen!
Wenn Du also eine List<DataRow> hast, dann sind die alle voneinander unabhängig. Der erste Eintrag hat z.B. nut ein Wert und das ist ein String. Die Zweite Reihe hat 5 Werte und das sind alles Double.
==> Keine Grenzen!

Und damit kommen wir zu dem Kernproblem, weshalb man sowas ungerne macht: Du hast dann keinerlei Typkontrolle zur Compilezeit. Du bekommst irgendwelche Object Arrays und Du hast keinerlei Kontrolle, was da drin ist und wie viele Elemente da drin sind. Der größte Vorteil von Sprachen wie Java ist aber die Typsicherheit. Die einfach so wegzuwerfen ist extrem unschön.

Daher gibt es dann viel Code zur Prüfung der Typen - das macht dann z.B. ResultSet - das kennt dann die Typen einer jeden Spalte und kann daher klar sagen, wie auf so einen Wert zugegriffen werden kann.

Das kann man aber machen:

public class Data {
    private Object value;
    private KnownTypes type;
    
    public Object getValue() { return value; }
    
    public String getValueAsString() { return value.toString(); } // Wenn eine Convertierung gewünscht wird.
    
    public String getIntValue() {
        if (value != null && value instanceOf Integer i)
            return i;
        
        throw new WhateverException("Not an Integer or null!");
    }
    
    ...
}

Aber damit hast Du dann ganz viel Kontrollen, was denn ein Wert ist oder nicht ist. Daher: Prüfe Dein Design!

Die angesprochene map ist ansonsten prinzipiell die Möglichkeit, auf irgendwelche if Arien zu verzichten. Das geht aber nur, wenn die Anzahl der Typen klar begrenzt ist und Du also nach den Typen suchen kannst. Das hört aber auf zu funktionieren, wenn Du auch mit abgeleiteten Klassen arbeiten willst oder mit Interfaces. Sprich: Da wird die Map auch recht schnell obsolet und es läuft auf eine eigene Implementierung hinaus.

 

[Carcharoth]

Danke für die Ausführungen. Es leuchtet mir ein und ich werde umsichtig überlegen wie ich es nun wann umsetze.