orienté processus
Exigence : utilisez Java pour implémenter un programme de console de calculatrice qui nécessite la saisie de deux nombres et d'opérateurs pour obtenir le résultat.
1) Mise en œuvre simple
public static void version1() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A：");
int A = scanner.nextInt();
System.out.println("请输入数字B：");
int B = scanner.nextInt();
System.out.println("请输入运算符号（+、-、*、/）：");
String oper = scanner.next();
int result = 0;
if (oper.equals("+")) {
// 问题1：分支判断写法不好，计算机做了3次无用功
result = A + B;
}
if (oper.equals("-")) {
result = A - B;
}
if (oper.equals("*")) {
result = A * B;
}
if (oper.equals("/")) {
result = A / B; // 问题2：如果除数时输入0如何处理，输入的是字符符号不是数字如何处理
}
System.out.println("结果是:" + result);
}
Problèmes existants :
- L'écriture du jugement de branche n'est pas bonne, ce qui fait que l'ordinateur fait 3 fois du travail inutile
- Et si vous entrez 0 lors de la division ? Que faire si l'entrée est un symbole de caractère au lieu d'un nombre ?
2) Amélioration
- Transformation de branche avec interrupteur
- Ajout du jugement du diviseur, ajout d'essayer ... attraper
public static void version2() {
try {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A：");
int A = scanner.nextInt();
System.out.println("请输入数字B：");
int B = scanner.nextInt();
System.out.println("请输入运算符号（+、-、*、/）：");
String oper = scanner.next();
int result = 0;
switch (oper) {
case "+":
result = A + B;
break;
case "-":
result = A - B;
break;
case "*":
result = A * B;
break;
case "/":
if (B != 0) {
result = A / B;
} else {
throw new IllegalArgumentException("除数不能为0");
}
break;
}
System.out.println("结果是:" + result);
} catch (Exception e) {
System.out.println("您的输入有误:" + e.getMessage());
}
}
Ce qui précède est juste pour réaliser la fonction, mais c'est en fait penser à la manière d'un ordinateur. Par exemple, le programme nécessite la saisie de deux nombres et symboles d'opérateur, puis choisit comment opérer en fonction des symboles d'opérateur, et obtient le résultat, qui n'est pas faux en soi. Cependant, ce type de réflexion fait que notre programme ne répond qu'aux besoins actuels, et le programme n'est pas facile à [maintenir], pas facile à [étendre] et encore plus difficile à [réutiliser], échouant ainsi à répondre aux exigences de haute qualité conditions.
orienté objet
Prérequis : Il est nécessaire d'écrire une autre calculatrice Windows. Le code ci-dessus peut-il être réutilisé ?
1) Mise en œuvre simple
Lorsqu'il y a un certain niveau de code répétitif dans le code, la maintenance peut être un désastre. Plus le système est gros, plus le problème est grave.Il y a un principe en programmation, essayez d'éviter au maximum les répétitions, et considérez ce qui est lié à la calculatrice et ce qui n'est pas lié à la console. Séparez la logique métier de la logique d'interface et réduisez le couplage entre elles.
/**
* 运算类(Operation)：
* 在Windows程序、Web版程序、PDA、手机等需要移动系统的软件需要运算都可以用它。
*/
public class Operation {
public static double getResult(double A, double B, String operate) {
double result = 0d;
switch (operate) {
case "+":
result = A + B;
break;
case "-":
result = A - B;
break;
case "*":
result = A * B;
break;
case "/":
result = A / B;
break;
}
return result;
}
}
Code client :
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A：");
int A = scanner.nextInt();
System.out.println("请输入数字B：");
int B = scanner.nextInt();
System.out.println("请输入运算符号（+、-、*、/）：");
String oper = scanner.next();
double result = Operation.getResult(A, B, oper);
System.out.println("结果是:"+result);
}
2) Amélioration
Q : Si je souhaite ajouter une opération racine, comment puis-je la modifier ?
Réponse : Il vous suffit de modifier la classe d'opération, ajoutez simplement une branche au commutateur.
Le problème est que si vous voulez ajouter une opération de racine carrée, vous devez effectuer les opérations d'addition, de soustraction, de multiplication et de division impliquées dans la compilation.Si vous changez accidentellement l'addition en soustraction, n'est-ce pas mauvais. À l'origine, laissez-vous ajouter une fonction, mais laissez le code de la fonction qui fonctionne bien changer, le risque est trop grand. Par conséquent , les opérations telles que l'addition, la soustraction, la multiplication et la division doivent être séparées. Leur modification ne doit pas affecter les autres, et l'ajout d'algorithmes d'opération n'affectera pas les autres codes .
public abstract class Operation {
private double numberA = 0;
private double numberB = 0;
/**
* 子类实现运算操作
*/
public abstract double getResult();
public double getNumberA() {
return numberA;
}
public void setNumberA(double numberA) {
this.numberA = numberA;
}
public double getNumberB() {
return numberB;
}
public void setNumberB(double numberB) {
this.numberB = numberB;
}
}
// 加
public class OperationAdd extends Operation {
@Override
public double getResult() {
return getNumberA() + getNumberB();
}
}
// 减
public class OperationSub extends Operation {
@Override
public double getResult() {
return getNumberA() - getNumberB();
}
}
// 乘
public class OperationMul extends Operation {
@Override
public double getResult() {
return getNumberA() * getNumberB();
}
}
// 除
public class OperationDiv extends Operation {
@Override
public double getResult() {
if (getNumberB() == 0) {
throw new IllegalArgumentException("除数不能为0");
}
return getNumberA() / getNumberB();
}
}
3) Modèle d'usine simple
Comment faire savoir à la calculatrice quel algorithme je veux utiliser ? Utilisez le modèle d'usine simple.
Qui doit être instancié ? Y aura-t-il plus d'objets instanciés à l'avenir, comme l'ajout d'opérations à l'origine de la racine
? C'est un endroit facile à changer. Vous devriez envisager d'utiliser une classe distincte pour le processus de création d'instances, qui est l'usine.
public class OperationFactory {
public static Operation createOperate(String operate) {
Operation oper = null;
switch (operate) {
case "+":
oper = new OperationAdd();
break;
case "-":
oper = new OperationSub();
break;
case "*":
oper = new OperationMul();
break;
case "/":
oper = new OperationDiv();
break;
}
return oper;
}
}
Classe client :
il suffit de saisir le symbole de l'opération, la fabrique instancie l'objet approprié et réalise le résultat de la calculatrice en retournant la classe parente par polymorphisme.
Si vous souhaitez la modifier : 1 : Ajoutez une sous-classe d'opération 2 : Dans la branche de commutateur d'ajout de classe d'usine
public static void main(String[] args) {
Operation oper= OperationFactory.createOperate("+");
oper.setNumberA(1);
oper.setNumberB(2);
double result = oper.getResult();
System.out.println(result);
}