Dynamischen Supplier für Parameter

[Kababär]

Hi,

ich benutze einen Supplier, der hauptsächlich ein Array eines beliebigen Typs zurück liefern soll, welches ich als Parameter für die Methode

String.format(String s, Object ... args)

verwende.

Da ich allerdings Supplier verschiedener Typen (mal String, mal Integer, oder mal zusammen) in Unterklassen zusammenbaue, wäre es schön, einen Allround-Supplier zu haben, damit ich den Supplier in die Hauptklasse (abstract class) packen kann, denn der Methoden-Aufruf zum zusammenbauen der Strings bleibt ja der gleiche.

So würde es ja funktionieren:

public class Test {

    private static Supplier<Integer[]> params1 =
            () -> new Integer[] { getScoreHome(), getScoreTotal() };

    private static final String s1 = "Hallo, %d %d";

    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(String.format(s1, params1.get()));
    }

    public static Integer getScoreHome() {
        return 2;
    }

    public static Integer getScoreTotal() {
        return 11;
    }
}

Das Resultat list

Hallo, 2 11

Wenn ich aber den Supplier wie folgt austausche

 Supplier s = params1;
        System.out.println(String.format(s1, s.get()));

fliegt eine Exception:

java.util.IllegalFormatConversionException: d != [Ljava.lang.Integer;
at java.util.Formatter$FormatSpecifier.failConversion(Unknown Source)
at java.util.Formatter$FormatSpecifier.printInteger(Unknown Source)
at java.util.Formatter$FormatSpecifier.print(Unknown Source)
at java.util.Formatter.format(Unknown Source)
at java.util.Formatter.format(Unknown Source)
at java.lang.String.format(Unknown Source)
at com.agfa.orbis.tools.rwam.converter.amb.ebm2009.model.mapping.obj.buildPatt.Test.main(Test.java:20)

Was auch verständlich ist, denn Object!=Integer.

Die Idee ist halt, dass ich in meiner Hauptklasse die abstrakte Methode A nicht mehr abstrakt mache, sondern voll implementiert schreiben kann, um auf Basis des Suppliers X und der Parameters (String-Text mit "%s, %d") Y einen neuen Text Z zu erzeugen. Derzeit überschreibe ich die abstrakte Methode A in jeder Unterklasse und der Aufruf in jeder Unterklasse ist immer 1:1 der gleiche, lediglich die Supplier-Typen und Parameter unterscheiden sich von Unterklasse zu Unterklasse. Deshalb würde ich gerne in der Hauptklasse eine Referenz auf den aktuellen Supplier und Parameter halten und dann anschließend die Methoden der Hauptklasse aufrufen (die ja dann nicht mehr abstrakt, sondern implementiert wäre).

Versteht ihr was ich meine?

 

[Flown]

Ähhhh was?

 

[Kababär]

Ok ok...
Angenommen meine Klassen sehen so aus:

public abstract class A {

    abstract String build();

}

public class B extends A {

    private Supplier<Integer[]> param = () -> new Integer[] { new Integer(1), new Integer(2), new Integer(3) };

    private String unFormattedText = "%d - %d = %d";

    @Override
    String build() {
        return String.format(unFormattedText, param.get());
    }

}

public class C extends A {

    private Supplier<String[]> param = () -> new String[] { "Cafe ", " Babe", " Java" };

    private String unFormattedText = "%s | %s in %s";

    @Override
    String build() {
        return String.format(unFormattedText, param.get());
    }
}

Es ist unschwer zu erkennen, dass in B und C genau das gleiche in der überschriebenen Methode passiert.
Also hätte ich gerne eine Referenz von Supplier und "unFormattedText" in A. In B und C würde ich lediglich nur Param und unFormattedText ändern, aber das String.format würde in A geschehen.
Deswegen gibt es doch Vererbung oder? Um Gemeinsamkeiten zusammenzufassen bzw. zu abstrahieren und in den Unterklassen dann die "Unterschiede" näher zu spezifizieren.

Also gewünschtes Ergebnis:

public abstract class A {

    private Supplier<?> param;

    private String unformattedText;

    protected String build() {
        return String.format(unformattedText, param);
    }

    public void setParam(Supplier s) {
        this.param = s;
    }

    public void setUnformattedText(String t) {
        this.unformattedText = t;
    }

}

public class B extends A {

    private Supplier<Integer[]> param = () -> new Integer[] { new Integer(1), new Integer(2), new Integer(3) };

    private String unFormattedText = "%d - %d = %d";

    public B() {
        super();
        setParam(param);
        setUnformattedText(unFormattedText);
    }
}

 

[Flown]

Generics würden dir schon weiterhelfen. Hier ein Beispiel:

import java.util.function.Supplier;

public class Test {
  public static void main(String... args) {
    A<Integer> b = new B();
    A<String> c = new C();
    System.out.println(b.build());
    System.out.println(c.build());
  }
}

abstract class A<T> {
 
  private String formattedText;
  private Supplier<T[]> params;
 
  public A(String formattedText, Supplier<T[]> params) {
    this.formattedText = formattedText;
    this.params = params;
  }
 
  public String build() {
    return String.format(formattedText, params.get());
  }
}

class B extends A<Integer> {
  public B() {
    super("%d - %d = %d", () -> new Integer[] { 1, 2, 3 });
  }
}

class C extends A<String> {
  public C() {
    super("%s | %s in %s", () -> new String[] { "Cafe ", " Babe", " Java" });
  }
}

EDIT:
Du brauchst aber in diesem Fall nicht die Klasse A abstrakt zu machen, sondern kannst gleich ad-hoc die neuen Klassen selbst erstellen:

import java.util.function.Supplier;

public class Test {
  public static void main(String... args) {
    A<Integer> b = new B();
    A<String> c = new C();
    A<Double> d = new A<>("%f, %f", () -> new Double[] { 1.4d, 2.2d });
    System.out.println(b.build());
    System.out.println(c.build());
    System.out.println(d.build());
  }
}

class A<T> {
 
  private String formattedText;
  private Supplier<T[]> params;
 
  public A(String formattedText, Supplier<T[]> params) {
    this.formattedText = formattedText;
    this.params = params;
  }
 
  public String build() {
    return String.format(formattedText, params.get());
  }
}

class B extends A<Integer> {
  public B() {
    super("%d - %d = %d", () -> new Integer[] { 1, 2, 3 });
  }
}

class C extends A<String> {
  public C() {
    super("%s | %s in %s", () -> new String[] { "Cafe ", " Babe", " Java" });
  }
}

 

[mrBrown]

Es würde auch schon reichen, es in A als Supplier<Object[]> zu deklarieren?

 

[Flown]

Klar würde das reichen, aber es ist sicher noch was anderes dahinter?!

 

[Kababär]

Danke flown.
Ja da steckt mehr dahinter. Ich habe noch weitere Objekte, deren toString () ebenfalls formatiert werden sollen. Allerdings sollten nur gewissen Objekte erlaubt werden, aber auch Integers und Strings. (Deswegen Generics?)
Ich habe mal das abstract builder pattern ausprobiert, weswegen die Klasse A abstrakt ist, also die Grundattribute und Funktionen bereitstellt und nicht initialisiert werden kann.

 

[mrBrown]

Ja da steckt mehr dahinter. Ich habe noch weitere Objekte, deren toString () ebenfalls formatiert werden sollen. Allerdings sollten nur gewissen Objekte erlaubt werden. (Deswegen Generics?)

Haben die Objekte denn eine gemeinsame Oberklasse?

 

[Kababär]

Lediglich ein Interface. Aber das müsste ja auch gehen

 

[Flown]

Du musst schon mit konkreten Problem hier auftreten, so kann man dir mMn nicht helfen. Zeig mal dein wahres Problem her.

 

[Kababär]

Ich hab es schon erledigt dank eurer Hilfe

 

[Flown]

Und was war denn dann deine Lösung?

 

[Kababär]

Post #3 von dir. Habe die Klasse um Generics erweitert.