怎么可能多态性更换如果其他的发言内的一个循环？

Question

怎么可能多态性更换如果其他发言或开关内部的一个循环？特别是它可以随时更换一个，如果-其他的吗？大多数如果叫我利用内部的循环算的比较。这个问题的产生从这个 的问题.

int x;
int y;
int z;

while (x > y)
{
     if (x < z)
     {
         x = z;
     }
}

如何将这项工作与多?
注：我写了这个Java但我在此感兴趣的任何OOL。

Answer 1

多态性通常替换switch语句时每种情况下对应于不同类型的。因此，而不是具有：

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");
         }
    }
}

你必须：

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

然而，对于比较类型决定你所提供，多态性真的没有帮助。

Answer 2

多态性是不是真的适用在你所提供的示例。

请参阅此 SO回答。

Answer 3

多态性只能更换如果测试当测试是否基本上dispatchi克的各种依赖于一个对象的“类型”的方法。例如，如果对象是X型调用foo的，如果它是一个Ÿ调用酒吧等。在这种人为的例子人会定义一个接口与方法坏DoSonething（）。 X和Y将实施巴兹和具有它们各自的巴兹（）为X和bar（）为Y.这简单地调用巴兹（调用FOO（））将消除对一个if测试的需要。

Answer 4

在Smalltalk中，“如果”，实际上是在布尔多态的方法。在下面的示例：

[ x>y ] whileTrue:  
  [   
    ( x<z ) ifTrue: [ x:=z ]        
  ]

在ifTrue:aBlock消息在True实现为“执行该块”，并在False为“忽略此块”，所以取决于什么(x<z)计算结果为，无论是执行将被调用。

所以在Smalltalk多态性替换每个的if-else默认构造：）

Answer 5

一种模式是有代表了测试的结果对象，并且其代表为执行该块的对象。结果对象已覆盖选择功能，所以如果布尔有一个选择（T阳性，T负），那么Bool.TRUE将返回正论证和Bool.FALSE将返回负。 Smalltalk的家庭语言朴素实现工作这样的。

要编码您的while循环以这样的形式，存在需要调用上比较x和y的结果的选择方法来确定是否调用while循环的内部的块，以及该块还使用比较和选择设置x的值。更直译将选择其中任何一个集合X〜z或其中一个什么都不做的块;代替它只是使用选择设置X返回到相同的值。

显然，这是矫枉过正和低效为这个简单的例子。

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();
    }
}

Answer 6

有关原始我们不能，但对于对象是我们可以。

检查此博客