Comment peut-Polymorphisme de remplacer un if-else à l'intérieur d'une boucle?

Polymorphisme remplace habituellement instructions de commutation lorsque chaque cas correspond à un type différent. Alors au lieu d'avoir:

public class Operator
{
    string operation;

    public int Execute(int x, int y)
    {
         switch(operation)
         {
             case "Add":
                 return x + y;
             case "Subtract":
                 return x - y;
             case "Multiply":
                 return x * y;
             case "Divide":
                 return x /y;
             default:
                 throw new InvalidOperationException("Unsupported operation");
         }
    }
}

vous auriez:

public abstract class Operator
{
    public abstract int Execute(int x, int y);
}

public class Add : Operator
{
    public override int Execute(int x, int y)
    {
        return x + y;
    }
}

//etc

Cependant, pour le type de comparaison de la décision que vous avez fourni, le polymorphisme n'aide vraiment pas.

OriginalL'auteur Jon Skeet

Polymorphisme ne peut remplacer le cas des tests lorsque la si le test est fondamentalement dispatchi g à une variété de méthodes en fonction du "type" d'un objet. Par exemple, si l'objet est de type X invoquer foo si il Y invoquer bar et. Dans cet exemple artificiel définir une interface DoSonething avec une méthode mauvais(). À la fois X et Y serait la mise en œuvre de Baz et leur baz() appeler foo() pour X et bar() pour Y. il suffit d'appeler baz() permettrait d'éliminer la nécessité pour un cas de test.

OriginalL'auteur mP.

Un pattern est d'avoir des objets qui représentent le résultat de l'essai, et les objets qui représentent l'exécution du bloc. Le résultat objets ont remplacé les fonctions de sélection, de sorte que si Bool avait un choisir(T positif, T négative), alors Bool.VÉRITABLE serait de retour l'argument positif et Bool.FAUSSE serait de retour négatif. Naïf implémentations du langage smalltalk-famille des langues de travail comme ça.

Pour encoder votre boucle while dans ce formulaire, il doit appeler le choisir la méthode sur le résultat de la comparaison de x et y afin de déterminer l'opportunité d'appeler le bloc à l'intérieur de la boucle while, et ce bloc utilise également comparer et de choisir pour définir la valeur de x. Une traduction plus littérale serait de choisir soit un bloc de laquelle les ensembles de x à z ou de l'un qui ne fait rien; au lieu de cela il utilise juste choisir x est réglé à la même valeur.

Évidemment, c'est exagéré, et inefficace pour ce cas simple.

public class WantonPolymorphism {

    static class Int32 {
        final int value;
        Int32 ( final int value ) { this.value = value; }

        Compare compare ( Int32 other ) {
            //Java runs out of turtles at this point unless you use
            //an enum for every value
            if ( this.value < other.value ) return Compare.LESS;
            if ( this.value > other.value ) return Compare.GREATER;
            return Compare.EQUAL;
        }
    }

    enum Compare {
        LESS {
            <T> T choose (T less, T equal, T greater) { return less; }
        },
        EQUAL {
            <T> T choose (T less, T equal, T greater) { return equal; }
        },
        GREATER {
            <T> T choose (T less, T equal, T greater) { return greater; }
        };

        abstract <T> T choose (T less, T equal, T greater) ;
    }

    interface Block { Block execute () ; }


    /**
     * Main entry point for application.
     * @param args The command line arguments.
     */
    public static void main (String...args) {
        Block block =  new Block() {
            Int32 x = new Int32(4);
            Int32 y = new Int32(3);
            Int32 z = new Int32(2);

            public Block execute () {
                System.out.printf("x = %d, y = %d, z = %d\n", x.value, y.value, z.value);

                return x.compare(y).choose(done, done, new Block () {
                    public Block execute () {
                        x = x.compare(z).choose(x,x,z);

                        return x.compare(y).choose(done, done, this);
                    }
                });
            }

            Block done = new Block () {
                public Block execute () {
                    System.out.printf("x = %d, y = %d, z = %d\n", x.value, y.value, z.value);
                    System.exit(0);
                    return this;
                }
            };
        };

        for(;;) 
            block = block.execute();
    }
}

OriginalL'auteur Pete Kirkham