(Je ne suis pas sûr de Java) J'ai pensé qu'il serait bien de prendre en charge le type de somme directe par défaut. J'ai également créé un «interpréteur qui calcule des formules en notation polonaise inverse (comme« 1 2 + »=« 3 »)» pour étudier en utilisant le type de somme directe.
package neta;
import java.util.Stack;
public class Main {
//Un type qui représente un type numérique
static class IntType extends Exception {
int v;
IntType(int v) {
this.v = v;
}
@Override
public String toString() {
return Integer.toString(v);
}
}
//Un type qui représente une opération positive
static class PlusOperation extends Exception {
@Override
public String toString() {
return "+";
}
}
private static void eval(String statement) throws IntType, PlusOperation {
try {
throw new IntType(Integer.parseInt(statement));
} catch (NumberFormatException e) {
if (statement.equals("+")) {
throw new PlusOperation();
} else {
//Utilisez Stack pour calculer la notation polonaise inversée
Stack<Integer> stack = new Stack<>();
//Les jetons peuvent être séparés par des espaces
for (String s : statement.split(" ")) {
try {
eval(s);
} catch (IntType iv) {
stack.push(iv.v);
} catch (PlusOperation op) {
stack.push(stack.pop() + stack.pop());
}
}
throw new IntType(stack.pop());
}
}
}
private static void test(String statement) {
try {
eval(statement);
} catch (IntType | PlusOperation e) {
System.out.println(e);
}
}
public static void main(String[] args) {
test("1");
test("1 2 +");
test("3 4 + 5 +");
test("6 7 8 + +");
test("+");
}
}
Lorsque j'exécute ce programme, j'obtiens la sortie suivante:
1
3
12
21
+
Il semble que le mot-clé throws soit utilisé dans la définition de la fonction pour indiquer le type de retour.
//Exemple
void eval(String statement) throws IntType, PlusOperation
Dans cet exemple, le type de somme directe de ʻIntType et PlusOperationest le type de retour de la fonction ʻeval ().
C'est cool d'écrire le type de retour après le nom de la fonction, comme dans les langages de programmation modernes (Go / Rust / ..).
Je ne suis pas sûr que le mot-clé qui représente une fonction soit «void», mais je pense qu'il est grammaticalement basé sur les dernières tendances linguistiques.
Il semble utiliser le mot-clé throw lors du retour d'une valeur. Je pense que de nombreux langages de programmation utilisent des mots clés comme «return», mais c'est rare.
//Exemple:Renvoie un type numérique
throw new IntType(Integer.parseInt(statement));
//Exemple:Renvoie l'opérateur d'addition
throw new PlusOperation();
Notez que lorsque vous retournez une valeur, vous devez en faire une instance d'une classe avec ʻextends Exception, comme ʻIntType, ou vous obtiendrez une erreur de compilation. C'est un peu gênant.
Utilisez try / catch pour la branche conditionnelle selon le type. C'est comme Scala ou une correspondance / cas de langage moderne.
try {
eval(s);
} catch (IntType iv) {
//Traitement selon le type
} catch (PlusOperation op) {
//Traitement selon le type
}
Dans une langue avec une longue histoire, il semble qu'un modèle de visiteur soit utilisé, ou qu'un type soit vérifié et ramifié avec quelque chose comme ʻinstanceof`.
Comme le langage Go, il semble entraîner une erreur de compilation si vous ne vérifiez pas l'erreur renvoyée.
try {
throw new IntType(Integer.parseInt(statement));
} catch (NumberFormatException e) {
//Que faire si une valeur de type d'erreur est renvoyée
}
Dans ce qui précède, vous pouvez écrire un traitement normal à la fois, et vous n'avez pas à vérifier l'erreur de valeur de retour une par une, c'est donc comme une monade.
Recommended Posts