Conversion de chaîne de caractères de type générique

J'ai besoin de convertir la chaîne de valeur de la variable. J'ai trouvé la solution uniquement pour C#. J'en ai besoin en Java.

public class Property<T> {

    T value;

    public void setValue(String input){
        if(value instanceof String){
           value= input; //value is type of T not type of string (compilation error)
                         //incompatible types: String cannot be converted to T
        }
        if(value instanceof int){
           //parse string
        }
        if(value instanceof boolean){
           //parse string
        }
        ...
    }
}
si vous ne savez pas ce qui T est, vous ne pouvez pas convertir. Vous pouvez lancer, mais il peut facilement échouer. Une mauvaise conception, dis-je.
Qu'est ce qu'un "type spécifique de générique variable"?
Ce n'est pas logique, comment peut-il ne pas être un String si l'argument est de type string.
Je veux dire le type de T que je reconnais avec instanceof
Je ne vais pas mentir, je l'ai trouvé par procès & erreur. C'est très obscur pour moi. Mais je n'ai pas l'esprit de sales tours, aussi longtemps qu'ils ne mon enchères xD

OriginalL'auteur SpeedEX505 | 2014-07-05

  1. 10

    Qui n'est pas la façon dont il fonctionne. Vous pouvez, cependant, utiliser le polymorphisme, afin d'obtenir un résultat utile.

    Solution avec le polymorphisme

    Base générique (et abstrait) propriété

    public abstract class Property<T> {
    T value;
    public abstract void setValue(String input);
}

    Propriété pour les Chaînes

    public class StringProperty extends Property<String> {
    @Override
    public void setValue(String input) {
        this.value = input;
    }
}

    Propriété pour les entiers

    public class IntegerProperty extends Property<Integer> {
    @Override
    public void setValue(String input) {
        this.value = Integer.valueOf(input);
    }
}

    Pas sûr de ce que votre objectif réel est, mais cette approche pourrait fonctionner.

    Remarque, que input instanceof T sera un échec, car le type d'effacement. Il ne va pas marcher.

    Solution avec Class<T> comme argument

    À donner plus de détails à votre approche, ce serait le travail - mais c'est MOCHE.

    Laid et pas très pratique. Aucune idée de pourquoi vous voulez, tbh.

    class Property<T> {

    public T value;
    private final Class<T> clazz;

    public Property(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }       

    @SuppressWarnings("unchecked")
    public void setValue(String input) {
        if (clazz.isAssignableFrom(String.class)) {
            value = (T) input;
        } else if (clazz.isAssignableFrom(Integer.class)) {
            value = (T) Integer.valueOf(input);
        } else if (clazz.isAssignableFrom(Boolean.class)) {
            value = (T) Boolean.valueOf(input);
        } else if (clazz.isAssignableFrom(Double.class)) {
            value = (T) Double.valueOf(input);
        } else {
            throw new IllegalArgumentException("Bad type.");
        }
    }
}

    Utilisé comme:

    Property<String> ff = new Property<>(String.class);
ff.setValue("sdgf");

Property<Integer> sdg = new Property<>(Integer.class);
sdg.setValue("123");

System.out.println(ff.value);
System.out.println(sdg.value);

    Solution avec Reflection

    Apparemment, il est possible de déterminer le paramètre utilisé pour instancier la propriété.

    Cette petite formule magique vous donne simplement que:

    (Class<?>) getClass().getTypeParameters()[0].getBounds()[0]

    Je ne sais même pas comment j'ai réussi à le trouver. Eh bien, nous y voilà:

    class Property<T> {

    T value;    

    @SuppressWarnings("unchecked")
    public void setValue(String input)
    {
        //BEHOLD, MAGIC!
        Class<?> clazz = (Class<?>) getClass().getTypeParameters()[0].getBounds()[0];

        if (clazz.isAssignableFrom(String.class)) {
            value = (T) input;
        } else if (clazz.isAssignableFrom(Integer.class)) {
            value = (T) Integer.valueOf(input);
        } else if (clazz.isAssignableFrom(Boolean.class)) {
            value = (T) Boolean.valueOf(input);
        } else if (clazz.isAssignableFrom(Double.class)) {
            value = (T) Double.valueOf(input); 
        } else {
            throw new IllegalArgumentException("Bad type.");
        }
    }
}

    Et ne me regarde pas, je ne vous en servez pas. J'ai peu de bon sens.

    J'ai ce code avant mais j'ai essayé de l'éviter. Je pense que je vais analyser la chaîne de niveau plus élevé, et ensuite appeler la méthode setValue(T entrée) de type T. Mais merci.
    Vous devez passer à la classe de T en argument au constructeur de Propriété. Ensuite, vous pouvez comparer cette classe contre certains types connus et de la direction générale sur elle - mais qu'il est LAID. Polumorphism est là pour être utilisé, elle n'est pas évitée.
    Eh bien, il ya en effet un cas d'utilisation de l'homme. Imaginez un simple fichier texte de configuration, XML, webservice résultat (quoi que) vous donne un <string,string> carte et que vous avez réellement besoin que d'une seule méthode générique, disons <V> V GetValueByKey(string key) qui vous donne de la valeur correspondant à la clé appropriée, mais d'un type désiré - au lieu de la chaîne.

    OriginalL'auteur MightyPork