Implémentation d'une classe Input et utilisation du strategy pattern
Bonjour,
Tout d'abord, je tiens à vous informer que je suis un débutant complet en programmation Java. Je lis actuellement Programmer en Java de Claude Delannoy. Seulement voila. Dès le début nous apprenons qu'il n'y a pas de classe qui nous permet de récupérer directement une entrée utilisateur en un seul appel de fonction méthode comme souhaité. L'auteur de l'ouvrage nous propose donc dans son annexe une petite classe Clavier. Cependant, j'ai quelques petits soucis avec celle-ci :roll:
Donc la voici :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
// classe fournissant des fonctions de lecture au clavier
import java.io.* ;
public class Clavier
{ public static String lireString () // lecture d’une chaine
{ String ligne_lue = null ;
try
{ InputStreamReader lecteur = new InputStreamReader (System.in) ;
BufferedReader entree = new BufferedReader (lecteur) ;
ligne_lue = entree.readLine() ;
}
catch (IOException err)
{ System.exit(0) ;
}
return ligne_lue ;
}
public static float lireFloat () // lecture d’un float
{ float x=0 ; // valeur a lire
try
{ String ligne_lue = lireString() ;
x = Float.parseFloat(ligne_lue) ;
}
catch (NumberFormatException err)
{ System.out.println ("*** Erreur de donnee ***") ;
System.exit(0) ;
}
return x ;
}
public static double lireDouble () // lecture d’un double
{ double x=0 ; // valeur a lire
try
{ String ligne_lue = lireString() ;
x = Double.parseDouble(ligne_lue) ;
}
catch (NumberFormatException err)
{ System.out.println ("*** Erreur de donnee ***") ;
System.exit(0) ;
}
return x ;
}
public static int lireInt () // lecture d’un int
{ int n=0 ; // valeur a lire
try
{ String ligne_lue = lireString() ;
n = Integer.parseInt(ligne_lue) ;
}
catch (NumberFormatException err)
{ System.out.println ("*** Erreur de donnee ***") ;
System.exit(0) ;
}
return n ;
}
} |
Le problème ne vient pas du style l’indentation, que je trouve au passage... laid, horrible et illisible :vomi: (enfin... chacun ses goûts :aie:), il ne s'agit non plus d'un problème de compréhension.
Citation:
Envoyé par un senior en programmation très patient qui aime aider de jeunes débutants
Il est où alors ton problème, Ô pauvre débutant que tu es! Tu nous fait perdre notre temps, au revoir!
Non, ne partez pas! Mon problème se trouve dans l’implémentation de cette classe.
Ne dit-on pas qu'un bon développeur est un développeur bête et méchant fainéant ? (Le développeur et ses milles et une qualités :haha:) Enfin, passons... Ici, les méthodes qui retournent des nombres sont quasiment identiques. Et je n'aime pas réécrire mon code (oui parce que réinventer la roue, y'a pas de problème :mrgreen:) Après quelques recherches je suis tombé sur une manière spécifique de concevoir une classe et qui au passage me permet de refactoriser mes méthodes, youpi : le strategy pattern. Donc, voici comment j'ai remanié tant bien que mal cette petite classe de rien du tout :
:fleche: main.Application
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package main;
import com.tools.input.*;
public class Application
{
public static void main(String args[])
{
System.out.println( Input.readNumber(new ReturnInt()) );
}
} |
:fleche: com.tools.input.Input
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
package com.tools.input;
import java.io.*;
public class Input
{
public static String readString()
{
String stringInput = null;
try
{
InputStreamReader inputReader = new InputStreamReader(System.in);
BufferedReader inputBuffer = new BufferedReader(inputReader);
stringInput = inputBuffer.readLine();
}
catch (IOException err)
{
System.err.println("An error occurred: " + err.getMessage());
System.exit(0);
}
return stringInput;
}
public static Number readNumber(InputReturnType returnType)
{
Number numberInput = 0;
try
{
String str = Input.readString();
numberInput = returnType.parse(str);
}
catch (NumberFormatException err)
{
System.err.println("An error occurred: " + err.getMessage());
System.exit(0);
}
return numberInput;
}
} |
:fleche: com.tools.input.InputReturnType
Code:
1
2
3
4
5
6
7
8
|
package com.tools.input;
interface InputReturnType
{
public Number parse(String str);
} |
:fleche: com.tools.input.returnInt
Code:
1
2
3
4
5
6
7
8
9
10
11
|
package com.tools.input;
public class ReturnInt implements InputReturnType
{
@Override
public Number parse(String str) {
return Integer.parseInt(str);
}
} |
:fleche: com.tools.input.returnDouble
Code:
1
2
3
4
5
6
7
8
9
10
11
|
package com.tools.input;
public class ReturnDouble implements InputReturnType
{
@Override
public Number parse(String str) {
return Double.parseDouble(str);
}
} |
:fleche: com.tools.input.returnFloat
Code:
1
2
3
4
5
6
7
8
9
10
11
|
package com.tools.input;
public class ReturnFloat implements InputReturnType
{
@Override
public Number parse(String str) {
return Float.parseFloat(str);
}
} |
Courage, c'est presque fini. Voici donc mes questions sans plus tarder :
1. Est-ce que mon implémentation est mieux que l'originale?
2. Ai-je bien utilisé le strategy pattern dans ce cas-ci?
3. Je sais qu'il n'existe aucune implémentation parfaite mais est-ce qu'il y aurait un moyen d'optimiser celle que je vous propose en terme de performance ou de lisibilité? (peut-être en utilisant des Templates?)
Cordialement,
~ Kairos
