Java génériques + Générateur de modèle

Comment dois-je appeler start() ci-dessous?

package com.example.test;
class Bar {}
public class Foo<K>
{
final private int count;
final private K key;
Foo(Builder<K> b)
{
this.count = b.count;
this.key = b.key;
}
public static class Builder<K2>
{
int count;
K2 key;
private Builder() {}
static public <K3> Builder<K3> start() { return new Builder<K3>(); }
public Builder<K2> setCount(int count) { this.count = count; return this; }
public Builder<K2> setKey(K2 key) { this.key = key; return this; }
public Foo<K2> build() { return new Foo(this); }
}
public static void main(String[] args)
{
Bar bar = new Bar();
Foo<Bar> foo1 = Foo.Builder.start().setCount(1).setKey(bar).build();
//Type mismatch: cannot convert from Foo<Object> to Foo<Bar>
Foo<Bar> foo2 = Foo.Builder<Bar>.start().setCount(1).setKey(bar).build();
//Multiple markers at this line
//- Bar cannot be resolved
//- Foo.Builder cannot be resolved
//- Syntax error on token ".", delete this token
//- The method start() is undefined for the type Foo<K>
//- Duplicate local variable fooType mismatch: cannot convert from Foo<Object> to Foo<Bar>
Foo<Bar> foo3 = Foo<Bar>.Builder.start().setCount(1).setKey(bar).build();
//Multiple markers at this line
//- Foo cannot be resolved
//- Syntax error on token ".", delete this token
//- Bar cannot be resolved     
}
}
InformationsquelleAutor Jason S | 2010-07-08
  1. 29

    Proximité:

    Foo.Builder.<Bar> start().setCount(1).setKey(bar).build();

    Cheers! 🙂

    P. S. Si le compilateur ne peut pas déduire le type de paramètre de la méthode sur son propre, vous pouvez le forcer en appelant obj.<Type> method(...) .

    P. P. S vous pouvez utiliser:

    public Foo<K2> build() {
return new Foo<K2>(this);
}

    Éviter à l'aide de matières types.

    • chaque fois que vous écrivez explicitement un argument de type dans une méthode, dieu tue un chaton 😉
    • aha, c'est ainsi que vous spécifiez méthodes statiques avec des types génériques. merci!
    • ok, donc, il y a une autre façon de le faire?
    • offre la clé de la méthode start() et de le transmettre au constructeur privé, de sorte que vous obtenez quelque chose comme: Bar bar = Bar(); Foo.Générateur de rapports.start(bar); // type sera déduit à partir de la barre de
    • Vous m'avez pris, je ne suis pas un grand fan de chats 😛
    • n'étant pas un fan n'a pas à justifier de tuer des chatons, rien n'! 😉
    • hmmm... alors pourquoi est écrit explicitement un argument de type mauvais? Il ne semble pas comme il y a une alternative qui est vraiment moins laid.
    • Je pense que le chaton devis a été à l'origine de Josh Bloch. Je l'utilise moi-même bien que, au moins une fois dans un certain temps. Si vous n'utilisez ce générateur de vous-même, allez juste pour elle. Cependant, si il y a d'autres développeurs, ma réponse pourrait être plus facile pour eux. Type explicite les arguments ne sont tout simplement pas assez et - encore plus important - tout le monde ne développeur sait qu'elles existent. Simplement vous regarder. Vous deviez venir ici dans le but de les faire travailler. De même, d'autres développeurs auront de la difficulté à utiliser votre bibliothèque qui fait usage de leur. Donc, finalement, il se résume à une question de convivialité et de goût.
    • ok, donc c'est moins une question de laideur/désordre que d'obscurs/confus de la syntaxe. merci!

    InformationsquelleAutor Andrei Fierbinteanu
  2. 17

    Andrei méthode est d'accord, mais la plupart des programmeurs seront susceptibles de lutte avec le plutôt inconnu de la syntaxe. Il pourrait être plus facile à utiliser de cette façon:

    static public <K3> Builder<K3> start(Class<K3> cls) { return new Builder<K3>(); }
Foo<Bar> foo1 = Foo.Builder.start(Bar.class).setCount(1).setKey(bar).build();

    La classe n'est passé pour aider avec le type générique. C'est pas joli, mais au moins la syntaxe est la connaissance commune.

    Une autre option serait de commencer tout de suite avec un objet du type générique:

    Foo<Bar> foo1 = Foo.Builder.startWithKey(bar).setCount(1).build();
    InformationsquelleAutor sfussenegger
  3. 1

    voici comment je ferais :

    package odmor2018.krit.rtti.builderpattern;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
public class Person {
private String firstName;
private String middleName;
private String lastName;
private boolean sex;
public Person(String firstName, String middleName, String lastName, boolean sex) {
this.firstName = firstName;
this.middleName = middleName;
this.lastName = lastName;
this.sex = sex;
}
public Person() {
}
@Override
public String toString() {
return "Person{" + "firstName=" + firstName + ", middleName=" + middleName + ", lastName=" + lastName + ", sex=" + sex + '}';
}
public static class Builder {
private final Field[] fields = Person.class.getDeclaredFields();
private final List<Field> fieldsList = Arrays.asList(fields);
private final List<String> fNames = fieldsList.stream().map(f -> f.getName()).collect(Collectors.toList());
private final Person nP = new Person();
public Builder with(String fName, Object value) {
if (fNames.contains(fName)) {
int fInd = fNames.indexOf(fName);
try {
Field f = fields[fInd];
f.setAccessible(true);
f.set(nP, value);
} catch (Exception ex) {
Logger.getLogger(Person.class.getName()).log(Level.SEVERE, null, ex);
}
}
return this;
}
public Person createPerson2() {
return nP;
}
}
public static void main(String[] args) {
Person p3 = new Person.Builder()
.with("firstName", "doooobri2")
.with("sex", false)
.createPerson2();
System.err.println("p3:" + p3);
}
}
    InformationsquelleAutor dobrivoje