Salut

j'ai un generique : <E> et je veux faire une fabrique d'elements de E

j'ai tente un new E();

j'ai tente :

public E factory() throws java.lang.InstantiationException, java.lang.IllegalAccessException{
E ob=null; return (E) ob.getClass().newInstance();
}

mais ca part en nullpointeurException

En Cpp, j'aurais juste eu a faire un new E(); mais la, je bloque...
Si quelqu'un a la solution :)

Merci d'avance

Salut
ne faudrait-il pas plutot qu'en sortit de ta fonction, le type soit : <? extends E>
De plus, tu fais un 'E ob = null', et tu appelles une fonction dessus !!! (D'où nullPointerException)

A mon avis, c'est plutôt: NomDeMaClasseGeneriqueQuiNeSoitPasUneInterface.getClass().newInstance();

Voili voilà

[#Tout le monde a des idées : la preuve, c'est qu'il y en a de mauvaises]
[#Je ne comprends pas tout, mais je parle de tout : c'est ce qui compte]

Réponse acceptée !
Salut,

je sais pas trop si ça va correspondre à ce que tu veux mais voici une solution :
(prise ICI)

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
 

publicfinalclass GenericInstantiator {
public <T> T makeInstance(Class<T> c) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException {
		T instance = null;	
 
		Class[] emptyParams = {};
		Constructor<T> con = c.getDeclaredConstructor(emptyParams);
		con.setAccessible(true);

		instance = con.newInstance();
 
return instance;
}
}

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

OoWORAoO

indiana_jules, cette solution appelle une methode oui, mais statique (enfin je crois, ou si elle ne l'est pas, elle n'utilise pas this...) bref, en Cpp et en delphi, ca aurait marche...

twinuts, je vais tester ca des que possible :)

pour le moment, je m'en suis sorti en passant une Class en parametre, c'est moche, mais ca fonctionne.

Bref, j'achete une barette de ram et je teste ca :)

Salut,

Je ne vois pas de possibilité pour avoir une usine pour tous les objets possibles. Une usine est dédiée à la fabrication d'objets d'un certain type ou dérivant d'un certain type. Enfin je me trompe peux être.

Voici un exemple d'usine qui délègue la fabrication d'objet à la classe qui l'utilise (usine abstraite) :

/**
 * Usine abstraite pour objet issue d'une base de données
 *
 * @param <T>
 */
import java.sql.ResultSet;
import java.sql.SQLException;

public abstract class  Factory<T>{

    /**
     * la création d'un objet à partir d'un ResultSet est délégué à la classe utilisatrice
     * Seule la classe utilisatrice sait comment fabriquer un objet à partir des champs du ResultSet
     *
     * @param resultSet
     * @return
     * @throws SQLException
     */
    public abstract T create(ResultSet resultSet) throws SQLException;
   
}

/**
 * Classe utilisatrice de l'usine Factory
 *
 */
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MyObject{
   
    private final Integer myInt;
    private final Integer myString;
   
    /**
     * La construction de l'objet a lieu au sein de la classe,
     * car elle seule sait comment fabriquer un objet à partir des champs du ResultSet
     *
     * @param resultSet
     * @throws SQLException
     */
    private MyObject(final ResultSet resultSet) throws SQLException {
        this.myInt = resultSet.getInt("myInt");
        this.myString = resultSet.getInt("myString");
    }
   
    /**
     * L'usine à objet de la classe
     * Elle definit le create à partir du constructeur privé de la classe qui utilise le ResultSet
     *
     */
    private static final Factory<MyObject> myObjectFactory = new Factory<MyObject>(){
        @Override
        public MyObject create(ResultSet resultSet) throws SQLException{
            return new MyObject(resultSet);
        }
    };
   
    public String toString() {
        return "myInt = " + this.myInt + " myString = " + this.myString;
    }
   
    public static void main(final String[] args){
       
        final int someId = 1;
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        MyObject object = null;
        try{
            connection=java.sql.DriverManager.getConnection("jdbc:mysql://hostname:port/database?user=myUser&password=myPassword");
            statement = connection.createStatement();
            resultSet = statement.executeQuery("SELECT myInt, myString FROM myTable where myId = " + someId);
            object = myObjectFactory.create(resultSet);
        }
        catch(final SQLException e){
            e.printStackTrace();
        } finally {
            if (resultSet != null) try{
                resultSet.close();
            if (statement != null)
                statement.close();
            if (connection != null)
                connection.close();
            }
            catch(final SQLException e){
                e.printStackTrace();
            }
        }
        if (object != null)
            System.out.println(object);
    }
}

quand tu dis : "Une usine est dédiée à la fabrication d'objets d'un certain type ou dérivant d'un certain type."
bah dans mon cas, elle fait des <E>...
En Cpp, ca passe sans probleme, mais les generiques en java ont pas mal de retard sur ceux du Cpp

Ok c++ est plus ancien, mais son modèle objet est trop spaghetti (héritage multiple, pas de classe mère (Object)...). Le mécanisme des patrons de classe était certes joli, mais plus difficile à maintenir.
Ok java est encore jeune (et encore ça se discute), mais il n'y a aucune raison pour qu'il existe de modèle absolu de fabrication des objets dont pas de raison qu'il existe un modèle absolu des usines à objet.
Regarde aussi le modèle objet de javascript (héritage par prototype et non par classe => héritage dynamique). Mécanisme que ni c++ ni java ne sont capables de proposer (faire changer la hiérarchie de classe d'un objet en cours d'execution, c'est fort quand même !!). Certains parlent même de AOP (Aspect Oriented Programming), une extension de l'OOP. Le modèle objet n'est pas figé, les langages évolueront en fonction des nouvelles propositions. Java suit sa route...

Faire des <E> ou des <? extends E> au sens large est plutôt utopique. Ton programme devrait prendre en compte la totalité des cas de E et pour faire simple il y en a une ... infinité...

La solution de Twinuts part du principe que tout les objets ont un constructeur sans arguments. Qui a décrété que toutes les classes avait forcément ce type de constructeur.

Réponse acceptée !
twinuts, j'avais pas vu ce matin : tu passes :

Class<T> c

en parametre c'est justement ce que je voulais eviter, daedric m'avait bien aide a trouver cette solution, mais elle ne me plaisait pas trop (parce-que ca fait une redondence, on met T deux fois quand on appelle la classe... bref)

public class JsonCollection<E extends JsonAble>{
...
    Class classe;
...
    public E factory() throws java.lang.InstantiationException, java.lang.IllegalAccessException{
        return (E)classe.newInstance();
    }
    public JsonCollection(... Class c) throws ...{
 ....
            classe = c;
...
}
}

pour l'appel, ca donne un truc genre :

 JsonCollection<Etudiant> ets=new JsonCollection<Etudiant>(...Etudiant.class);

et tu vois, j'utilise deux fois Etudiant (en plus du type)

Réponse acceptée !
ca me rassure je dis pas que de la merde :p

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"