Correction Février 2012

Programmation Avancée

Modérateur : Douin

a.tortevois
Messages : 70
Inscription : 05 oct. 2018 16:00
Contact :

Correction Février 2012

Message par a.tortevois » 20 janv. 2019 12:00

Bonjour,
Est-il possible d'avoir cette correction svp : http://jfod.cnam.fr/NFP121/annales/2012_fevrier/ ?
Merci par avance.

a.tortevois
Messages : 70
Inscription : 05 oct. 2018 16:00
Contact :

Re: Correction Février 2012

Message par a.tortevois » 20 janv. 2019 13:06

Il y a quelque chose que je n'arrive pas à capter sur ce sujet.

Comment se fait le lien entre Method et FiltreI ?

Ne serait-ce que pour la première méthode à écrire pour ListeDesMethodesI j'aurais tendance à écrire :

Code : Tout sélectionner

    public ListeDeMethodesI<FiltreI> ajouter( Method m) { 
        if( m != null )
            if( !listeMethodes.contains(m) )
                if( filtre.estSatisfait( m.getModifiers(), m.getReturnType(), m.getParameterTypes() ) ) 
                    listeMethodes.add(m); // ici erreur Method vs FiltreI attendu ...
        return this;
    }
Et en q2-1 il est demandé de déclencher les méthodes de la liste .. si on a des FiltreI dans la liste comment on "invoke" ?

a.tortevois
Messages : 70
Inscription : 05 oct. 2018 16:00
Contact :

Re: Correction Février 2012

Message par a.tortevois » 24 janv. 2019 13:10

Est-ce que quelqu'un aurait une idée svp ?

Douin
Messages : 284
Inscription : 18 mars 2009 15:46

Re: Correction Février 2012

Message par Douin » 25 janv. 2019 12:33

Bonjour, je n'avais pas vu que la correction en place est pour un autre examen, ci dessous les classes au fil de l'eau...

Code : Tout sélectionner

package question1;

import java.lang.reflect.*;

import java.util.List;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class MethodesFiltrees<F  extends FiltreI> extends AbstractSet<Method> implements ListeDeMethodesI<F>{
  private F filtre;
  private List<Method> liste; // une liste ici uniquement pour l'appel de Collections.sort, cf. trier
  
  public MethodesFiltrees(F filtre){
    this.filtre = filtre;
    this.liste = new ArrayList<Method>();
  }
  
  public F filtre(){
    return this.filtre;
  }
  
  public MethodesFiltrees<F> ajouter(Class<?> c){
    boolean resultat = false;
    // est-ce bien une classe publique ?
    boolean publicClass = Modifier.isPublic(c.getModifiers()) && !Modifier.isInterface(c.getModifiers());
    if(publicClass)
      for(Method m : c.getDeclaredMethods())
        ajouter(m);
      
      
    return this;
  }
  
  
  public MethodesFiltrees<F> ajouter(Method m){
    boolean resultat = false;
    if(!contains(m) && filtre.estSatisfait(m.getModifiers(), m.getReturnType(), m.getParameterTypes())){
      liste.add(m);
      resultat = true;
    }
    return this;
  }
  
  
  public Set<Class<?>> classes(){
    Set<Class<?>> set = new HashSet<Class<?>>();
    for(Method m : this){
      set.add(m.getDeclaringClass());
    }
    return set;
  }
  
  public MethodesFiltrees<F> trier(){ // covariance ...
    Collections.sort(liste, new Comparator<Method>(){
       public int compare(Method m1, Method m2){
          return m1.getName().compareTo(m2.getName());
       }
    });
    return this;
  }
    
  @Override
  public Iterator<Method> iterator(){
    return liste.iterator();
  }
  @Override
  public int size(){
    return liste.size();
  }
  @Override 
  public boolean add(Method m){
    if(contains(m)) return false;
    ajouter(m);
    return true;
  }
  
}

package question1;

import java.lang.reflect.*;
// import java.util.Arrays; // Arrays.deepEquals(parameterTypes,paramètre)

public class FiltreDeMethodes  implements FiltreI{
  private int modifier;
  private Class<?>[] parametres;
  private Class<?> retour;
  
  public FiltreDeMethodes(int modifier,  Class<?> returnType, Class<?>... parameterTypes){
    this.modifier = modifier;
    this.retour = returnType;
    this.parametres = parameterTypes;
    if(returnType==null || parameterTypes==null) throw new RuntimeException(" returnType==null || parameterTypes==null !!!");
  }
  
  public boolean estSatisfait( int modifier, Class<?> returnType, Class<?>... parameterTypes){
    if(returnType!=null && parameterTypes != null)
      return (this.modifier & modifier)==this.modifier && FiltreDeMethodes.equals(parameterTypes,parametres) && returnType==retour;
      
    return false;
  }

  public int modifier(){ return this.modifier;}
  public Class<?> returnType(){return this.retour;}
  public Class<?>[] parameterTypes(){return this.parametres;}
  
    private static boolean equals(Class<?>[] a, Class<?>[] b){ // idem Arrays.deepEquals
      if(a.length == b.length){
        for(int i = 0; i<a.length;i++){
          if(a[i] != b[i]) return false;
        }
        return true;
      }
      return false;
    }
}

Code : Tout sélectionner

package question2;

import question1.FiltreI;
import question1.ListeDeMethodesI;
import question1.FiltreDeMethodes;
import question1.MethodesFiltrees;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;


public class Console{
  public static double abs(double opr){
    return Math.abs(opr);
  }
  public static void main(String[] args) throws Exception{
    FiltreI ff = new FiltreDeMethodes(Modifier.STATIC | Modifier.PUBLIC, double.class, double.class);
    ListeDeMethodesI<FiltreI> liste = new MethodesFiltrees<FiltreI>(ff);
    liste.ajouter(Console.class).ajouter(ClasseAvec2Methodes.class).trier();


    double x = -3;
    for(Method m : liste){
      System.out.print(m.getName());
      double y = x;
      x = (double)m.invoke(null,x);
      System.out.println("(" + y + ")=" + x); 
    }
  }
}

package question2;

import question1.FiltreI;
import question1.ListeDeMethodesI;
import question1.FiltreDeMethodes;
import question1.MethodesFiltrees;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JButton;

import java.awt.BorderLayout;
import java.awt.FlowLayout;

import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.ActionEvent;
import java.awt.event.WindowEvent;

import java.util.Map;
import java.util.HashMap;

public class IHMMath extends JFrame implements IHM{

  private JTextField entree = new JTextField("10",4);
  private JTextField resultat = new JTextField(12);
  private ListeDeMethodesI<FiltreI> liste;
  
  
  public IHMMath(final ListeDeMethodesI<FiltreI> liste){
    super("les fonctions " + FiltreI.Utils.toString(liste.filtre()));
    this.liste = liste;
    
    JPanel p = new JPanel(new BorderLayout());
    JPanel p1 = new JPanel(new FlowLayout());
    p1.add(new JLabel("opérande: ?"));
    p1.add(entree);
    p1.add(new JLabel("résultat: "));
    resultat.setEnabled(false);
    p1.add(resultat);
    p.add(p1,BorderLayout.NORTH);
 
    JPanel panelDesFonctions =  new JPanel(new FlowLayout());
    for(final Method m : liste){
      JButton jb = new JButton(m.getName());
      jb.addActionListener(new ActionListener(){
        public void actionPerformed(ActionEvent ae){
          try{
            double res = (double)m.invoke(null,Double.parseDouble(entree.getText()));
            resultat.setText(Double.toString(res));
            notifyListeners(ae);
          }catch(Exception e){
            resultat.setText(e.getMessage());
           }
         }
       });
      panelDesFonctions.add(jb);
    }
    p.add(panelDesFonctions, BorderLayout.CENTER);
    
    add(p);
    setVisible(true);
    pack();
    
    addWindowListener(new WindowAdapter(){
      public void windowClosing(WindowEvent we){
        System.exit(0);
      }
    });
  }
  
  @Override
  public JTextField entree(){ return entree;}
  @Override
  public JTextField resultat(){ return resultat;}
  @Override
   public ListeDeMethodesI<FiltreI> liste(){ return liste;}
  
  
  private Map<ActionListener,ActionListener> listeners = new HashMap<ActionListener,ActionListener>();
  
  public void addActionListener( ActionListener al){
    listeners.put(al,al);
  }
  
  private void notifyListeners(ActionEvent ae){
    for(ActionListener al : listeners.keySet()){
      al.actionPerformed(ae);
     }
  }

  public static void main(String[] args) throws Exception{
    FiltreI ff = new FiltreDeMethodes(Modifier.STATIC | Modifier.PUBLIC, double.class, double.class);
    ListeDeMethodesI<FiltreI> liste = new MethodesFiltrees<FiltreI>(ff);
    liste.ajouter(java.lang.Math.class).ajouter(ClasseAvec2Methodes.class).trier();
   
    IHMMath ihm = new IHMMath(liste);
    ActionListener al = new AChaqueClicAffichageDeLaFonctionChoisie(ihm);
    //new question3.AChaqueClicAjoutAuJournalEnXML(ihm);
  }
}



Code : Tout sélectionner


package question3;

import question1.*;
import persistance.*;
import java.lang.reflect.Modifier;
import java.io.FileOutputStream;

public class MathEnListe extends ListeBuilder{
  
  public final static String NOM_FICHIER_MATH = "MathEnListe.xml";
  
  public MathEnListe construireFiltre() throws BuilderException{
    filtre = new FiltreDeMethodes(Modifier.STATIC | Modifier.PUBLIC, double.class, double.class);
    return this;
  }
  
  public MathEnListe construireListe() throws BuilderException{  
    liste = new MethodesFiltrees<FiltreI>(filtre);
    liste.ajouter(java.lang.Math.class);
    return this;
  }
  
  public MathEnListe trierListe(){
    liste.trier();
    return this;
  }
  
  public  MathEnListe sauvegarderListe() throws BuilderException{
    try{
      ListeDeMethodesEnXML listeXML = new ListeDeMethodesEnXML(this.liste);
      listeXML.sauvegarder(new FileOutputStream(NOM_FICHIER_MATH));
      return this;
    }catch(Exception e){
      throw new BuilderException(e.getMessage());
     }
   }
}

package question3;

import question1.*;
import persistance.*;

import org.jdom.*;
import org.jdom.input.*;

import java.io.*;
import java.util.*;

import java.lang.reflect.*;

public class XMLEnListe extends ListeBuilder{

  private String nomDuFichier;
  private Element racine;
  
   public XMLEnListe(String nomDuFichier) throws Exception{
       this.nomDuFichier = nomDuFichier;
       SAXBuilder saxB = new SAXBuilder(true); // la DTD est vérifiée
       Document document = saxB.build(new FileInputStream(nomDuFichier)); 
       this.racine = document.getRootElement();
    }
    
    
   public XMLEnListe construireFiltre()throws BuilderException{
     try{
       // Quel est le filtre ? 
       Element filtreElt = racine.getChild("filtre");
       // Quelle est la classe ?
       Class<?> classFiltre = Class.forName(filtreElt.getAttributeValue("class"));
       
       // A la recherche des paramètres destinés au constructeur
       // Quel est modificateur d'accès ?
       int modifier = Integer.parseInt(filtreElt.getChild("modifier").getText());
       // Quel est le type retourné ?
       Class<?> returnType = classType(filtreElt.getChild("returnType").getText());
       // Quels sont les type des paramètres ?
       List<Element> parameterTypesElt = filtreElt.getChildren("parameterType");
       // Allocation de la table
       Class<?>[] parameterTypes = new Class<?>[parameterTypesElt.size()];
       for(int i=0; i<parameterTypes.length; i++){
         // Affectation de chaque élément de classe Class<?>
         parameterTypes[i] = classType(parameterTypesElt.get(i).getText());
       }
       // Obtention du constructeur, avec cette entête, cet entête pourrait être dans le fichier XML...
       Constructor<?> consClassFiltre = classFiltre.getConstructor(int.class,Class.class,Class[].class);
       // Autre façon : prenons le premier constructeur
       // Création du filtre
       this.filtre = (FiltreI)consClassFiltre.newInstance(modifier,returnType,parameterTypes); 
       return this;
     }catch(Exception e){
         throw new BuilderException(e.getMessage());
     }
   }
   
   public XMLEnListe construireListe() throws BuilderException{
     try{
       // Quelle est l'implémentation de la liste choisie ?, sélection du constructeur
       Class<?> classListe = Class.forName(racine.getAttributeValue("class"));
       // Ce constructeur doit être présent
       Constructor<?> consClassListe = classListe.getConstructor(FiltreI.class);
      // La liste est alors initialisée
       this.liste = (ListeDeMethodesI)consClassListe.newInstance(filtre);
       
       // un test en fonction de la version du jdk... au cas où
       String versionJDK = racine.getChild("java.version").getText();
       if(System.getProperties().getProperty("java.version").equals(versionJDK)){
         // Alors la liste est construite à partir des classes ajoutées
         List<Element> classes = racine.getChildren("class");
         for(Element e : classes)
           liste.ajouter(classType(e.getText()));
   
       }else{
         // si ce n'est pas la même version du jdk,
         // alors la liste est construite à partir des méthodes,
         // Les méthodes absentes sont ignorées ... compatibilité descendante ...
         List<Element> methodes = racine.getChildren("method");
         for( Element e : methodes){
           Class<?> c = classType(e.getAttributeValue("class"));
           try{
             Method m = c.getMethod(e.getText(), filtre.parameterTypes());
             liste.ajouter(m);
            }catch(NoSuchMethodException exc){
            }
          }
        }
        //System.out.println("liste : " + liste);
        return this;
     }catch(Exception e){
         throw new BuilderException(e.getMessage());
     }
    }
    
   
   public XMLEnListe trierListe(){
     liste.trier();
     return this;
   }

   public XMLEnListe  sauvegarderListe() throws BuilderException{
     try{
       ListeDeMethodesEnXML listeXML = new ListeDeMethodesEnXML(this.liste);
       OutputStream os = new FileOutputStream(nomDuFichier);
       listeXML.sauvegarder(os);
       os.close();
       return this;
     }catch(Exception e){
         throw new BuilderException(e.getMessage());
     }
   }
   
 
   
   private static Class<?> classType(String name) throws Exception{
     Class<?> res = null;
     res = primitive.get(name);
     if(res==null) res = Class.forName(name);
     return res;
    }
    
    
   private static Map<String,Class<?>> primitive;
   static{
     primitive = new HashMap<String,Class<?>>();
     primitive.put("double", double.class);
     primitive.put("float", float.class);
     primitive.put("int", int.class);
     primitive.put("long", long.class);
     primitive.put("byte", byte.class);
     primitive.put("char", char.class);
     primitive.put("short", short.class);
     primitive.put("boolean",boolean.class);
     primitive.put("void",void.class);
   }
}
// exemple de fichier lu

// <?xml version="1.0" encoding="UTF-8"?>
// <!DOCTYPE liste SYSTEM "README.TXT">
// 
// <liste class="question1.MethodesFiltrees">
//   <filtre class="question1.FiltreDeMethodes">
//     <!-- signature: public static double _( double )-->
//     <modifier>9</modifier>
//     <returnType>double</returnType>
//     <parameterType>double</parameterType>
//   </filtre>
//   <!-- classes: [class java.lang.Math, class question2_1.ClasseAvec2Methodes]-->
//   <java.version>1.7.0</java.version>
//   <class>java.lang.Math</class>
//   <class>question2_1.ClasseAvec2Methodes</class>
//   <method class="java.lang.Math">abs</method>
//   <method class="java.lang.Math">acos</method>
//   <method class="java.lang.Math">asin</method>
//   <method class="java.lang.Math">atan</method>
//   <method class="java.lang.Math">cbrt</method>
//   <method class="java.lang.Math">ceil</method>
//   <method class="java.lang.Math">cos</method>
//   <method class="java.lang.Math">cosh</method>
//   <method class="java.lang.Math">exp</method>
//   <method class="java.lang.Math">expm1</method>
//   <method class="java.lang.Math">floor</method>
//   <method class="java.lang.Math">log</method>
//   <method class="java.lang.Math">log10</method>
//   <method class="java.lang.Math">log1p</method>
//   <method class="question2_1.ClasseAvec2Methodes">moins1</method>
//   <method class="java.lang.Math">nextUp</method>
//   <method class="question2_1.ClasseAvec2Methodes">plus1</method>
//   <method class="java.lang.Math">rint</method>
//   <method class="java.lang.Math">signum</method>
//   <method class="java.lang.Math">sin</method>
//   <method class="java.lang.Math">sinh</method>
//   <method class="java.lang.Math">sqrt</method>
//   <method class="java.lang.Math">tan</method>
//   <method class="java.lang.Math">tanh</method>
//   <method class="java.lang.Math">toDegrees</method>
//   <method class="java.lang.Math">toRadians</method>
//   <method class="java.lang.Math">ulp</method>
// </liste>


package question3;

import question1.*;
import question2.*;

public class MaitreDOuvrage{

//   public MaitreDOuvrage(ListeBuilder builder){
//     this.builder
  public static void main(String[] args) throws Exception{
  
      //ListeBuilder builder = new MathEnListe(); // en fonction d'une configuration, CF. cours 10 
      ListeBuilder builder = new XMLEnListe("liste.xml");
      
      builder.construireFiltre();
      builder.construireListe().trierListe();
      
      ListeDeMethodesI<FiltreI> liste = builder.listeConstruite();
      System.out.println("liste : " + liste);
      IHM ihm = new IHMMath(liste);
      
  }
}


RENAUD
Messages : 101
Inscription : 21 sept. 2018 19:34

Re: Correction Février 2012

Message par RENAUD » 25 janv. 2019 22:28

Bonsoir
Quelqu’un a réussi à accéder aux codes sources ?
Il y'a des liens qui ne fonctionnent pas pour certains fichiers à cause de caractère accentués ou spéciaux :
http://lmi92.cnam.fr/NFP121/annales/201 ... uestion1/
Achat.java
AchatGroupéI.java
AchatI.java
AchatSimple.java
TestSimple.java
TâcheComplexe.java
Visiteur.java

http://lmi92.cnam.fr/NFP121/annales/201 ... uestion2/
TestVisiteurToString.java
TestVisiteurToXML.java
VisiteurToString.java
VisiteurToXML.java
XMLEnTâches.java

http://lmi92.cnam.fr/NFP121/annales/201 ... uestion3/
Observateur.java
TestMVC.java
TâcheComplexeContrôleur.java
TâcheComplexeObservable.java
TâcheComplexeObservableI.java
TâcheComplexeVueSwing.java

a.tortevois
Messages : 70
Inscription : 05 oct. 2018 16:00
Contact :

Re: Correction Février 2012

Message par a.tortevois » 27 janv. 2019 17:14

Merci.

@RENAUD : cherche pas les sources dispo en ligne n'ont rien à voir

RENAUD
Messages : 101
Inscription : 21 sept. 2018 19:34

Re: Correction Février 2012

Message par RENAUD » 28 janv. 2019 1:33

Oui m'en suis rendu compte donc j'ai laissé tombé 2002 d'ailleurs.
Et ce sera peut-être le dernier que j'essaierai de faire avant mardi sans trop me fier à mes réponses trop juste d'ici mardi !

Répondre