Альтернатива операторов if-else и switch

У меня есть следующий код в Java:

public void doSomething(int i) {
    if (i == 12) {
        // order should be same
        up();
        left();
        stop();
    }
    if (i == 304) {
        // order should be same
        right();
        up();
        stop();
    }
    if (i == 962) {
        // order should be same
        down();
        left();
        up();
        stop();
    }
}
// similar code can be done using switch case statements.
// all the function can have any functionality and might not resemble to the name given to them.

Теперь, если меня попросят не использовать аргументы if-else и switch case, то что можно сделать? Код может быть выполнен в Java или JavaScript.

ОТВЕТЫ

Ответ 1

Если вы можете использовать JavaScript, вы можете использовать объект с функциями:

function doSomething(i) {
  var obj = {};

  obj[12] = function () {
    // order should be same
    up();
    left();
    stop();
  };
  obj[304] = function () {
    // order should be same
    right();
    up();
    stop();
  };
  obj[962] = function () {
    // order should be same
    down();
    left();
    up();
    stop();
  };

  // apparently we can't use any conditional statements
  try {
    obj[i]();
  } catch (e) {}
}

Если не разрешены только операторы if и switch, замените все операторы if логическим оператором AND (&&):

function doSomething(i) {
  (i == 12) && (
    // order should be same
    up(),
    left(),
    stop()
  );

  (i == 304) && (
    // order should be same
    right(),
    up(),
    stop()
  );

  (i == 962) && (
    // order should be same
    down(),
    left(),
    up(),
    stop()
  );
}

Ответ 2

Вот простой способ выполнить это в JavaScript:

function up()    { console.log("up");    }
function down()  { console.log("down");  }
function left()  { console.log("left");  }
function right() { console.log("right"); }
function stop()  { console.log("stop");  }

var fnmaps = {
    12:  [up, left, stop],
    304: [right, up, stop],
    962: [down, left, up, stop]
};

function doSomething(i) {
    var fnmap = fnmaps[i] || [], j;
    for (j = 0; j < fnmap.length; j++) {
        fnmap[j]();
    }
}

doSomething(12);
doSomething(304);
doSomething(962);

Функции могут быть добавлены/упорядочены просто путем редактирования переменной карты.

Ответ 3

Вы можете сделать словарь ввода-вывода. В Java это будет Map<Integer, Runnable>, с, например: *:

map.put(12, () -> {
    up();
    left();
    stop();
});

Затем вы можете получить соответствующий Runnable и запустить его:

Runnable action = map.get(i);
if (action != null) {
    action.run();
} else {
    // some default action
    // This is the "default" case in a switch, or the "else" in an if-else
}

В противном случае нет необходимости, но без него вы получите NullPointerException, если i не является ожидаемым значением — то есть одно из значений, которые вы помещаете в карту.

Идея похожа на JavaScript, но с объектами вместо Map s, функциями (возможно, анонимными) вместо Runnable s и т.д.

Этот код предназначен для Java 8. В Java 7 и ниже вы должны:

map.put(12, new Runnable() {
    @Override
    public void run() {
        up();
        left();
        stop();
    }
});

суб >

Ответ 4

Вахахахахаха, ты спас мой день:) Это должно сработать, теперь нет возможности проверить.

public void doSomething(int i) {

try {
    int x = 1/(12-i); // fails for i==12
} catch (ArithmeticException e) {
        up();
        left();
        stop();
}

и т.д., наслаждайтесь!

Ответ 5

Затем сделайте это с while и break, нет другого способа без проверки условий

public void doSomething(int i) {

while(i == 12) {
// order should be same
    up();
    left();
    stop();
break;
    }

while(i == 304) {
// order should be same
    right();
    up();
    stop();
break;
    }

while(i == 962) {
// order should be same
    down();
    left();
    up();
    stop();
break;
    }
}

Ответ 6

Посмотрите, естественно, вы должны проверить условный оператор с условным выражением! Теперь, если вы не хотите этого делать, вы можете сделать это неестественно:

сначала сделайте это для всех методов (вверх, вниз,...)

java.lang.reflect.Method method;
try {
  method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) {
  // ...
} catch (NoSuchMethodException e) {
  // ...
}

вместо целого числа, которое вы передаете в doSomething, используйте массив, содержащий имя методов, которые вы хотите вызвать, и внутри цикла for вызовите каждый метод следующим образом:

Затем вы вызываете этот метод, вызывая

try {
  method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {

К сожалению, Java не имеет делегатов!

Ответ 7

для js u может попробовать следующее:

// define ur actions here
var actions = {
  "12" : function () { up(); left(); stop(); },
  "304" : function () { right(); up(); stop(); },
  "962" : function () { down(); left(); up(); stop(); }
};

function doSomething(i) {
  var fn = actions[i];
  try {
    fn();
  } catch (err) {
    console.error(err);
  }
}
//
doSomething(12); //invoke here

Ответ 8

Эта проблема может быть решена с использованием методов ООП.

В java это будет выглядеть так:

public abstract class AObject{
   public abstract  void doSomething();
   public void  up(){
      //do something here
   }
   public void down(){
      //do something here
   }
   public void left(){
      //do something here
   }
   public void right(){
      //do something here
   }       
   public void stop(){
      //do something here
   }     
}


public class AObject12 extends AObject{
   public void doSomething(){
      up();
      left();
      stop();
   }
}

public class AObject304 extends AObject{
   public void doSomething(){
      right();
      up();
      stop();
   }
}

public class AObject962 extends AObject{
   public void doSomething(){
      down();
      left();
      up();
      stop();
   }
}

Выполнение doSomething на экземпляре конкретного класса вызовет соответствующее поведение. Поэтому больше нет, если /else необходимо. Смотрите пример ниже:

AObject A12 = new AObject12();
A12.doSomething();
// Will run Up left stop in that order

AObject A304 = new AObject304();
A304.doSomething();
// Will run right Up stop in that order

AObject A962 = new AObject962();
A962.doSomething();
// Will run down left up stop in that order

Дополнительную информацию об этом виде программирования можно найти здесь: http://en.wikipedia.org/wiki/Polymorphism_%28computer_science%29

Если вы хотите динамически изменять поведение объекта, вы можете рассмотреть возможность применения шаблона состояния: http://en.wikipedia.org/wiki/State_pattern p >

Ответ 9

В Java это должно работать.

public class IfTest {

    public static void main(String[] args) {
        IfTest ifTest = new IfTest();

        ifTest.doSomething(12);
        ifTest.doSomeThingWithoutIf(12);

        ifTest.doSomething(304);
        ifTest.doSomeThingWithoutIf(304);

        ifTest.doSomething(962);
        ifTest.doSomeThingWithoutIf(962);

        ifTest.doSomething(42);
        ifTest.doSomeThingWithoutIf(42);
    }

    public void doSomeThingWithoutIf(int i) {


        boolean x = i == 12 ? f12() : (i == 304 ? f304() : (i == 962 ? f962() : false));
    }

    public boolean f12() {

        up();
        left();
        stop();

        return true;
    }

    public boolean f304() {

        right();
        up();
        stop();
        return true;
    }

    public boolean f962() {

        down();
        left();
        up();
        stop();

        return true;
    }

    public void doSomething(int i) {

        if(i == 12) {
            // order should be same
            up();
            left();
            stop();
        }

        if(i == 304) {
            // order should be same
            right();
            up();
            stop();
        }

        if(i == 962) {
            // order should be same
            down();
            left();
            up();
            stop();
        }
    }

    private boolean retfalse() {
        return false;
    }

    private void down() {
        System.out.println("down");
    }

    private void right() {
        System.out.println("right");
    }

    private void stop() {
        System.out.println("stop");
    }

    private void left() {
        System.out.println("left");
    }

    private void up() {
        System.out.println("up");
    }
}

Ответ 10

Желаемое поведение может быть достигнуто в JAVA, играя с коротким замыканием логического оператора AND следующим образом:

public static Boolean seq12() {
    // order should be same
    up();
    left();
    stop();
    return true;
}
public static Boolean seq304() {
    // order should be same
    right();
    up();
    stop();
    return true;
}
public static Boolean seq962() {
    // order should be same
    down();
    left();
    up();
    stop();
    return true;
}

public static void doSomething(int i) {
    Boolean tmp;
    tmp = (i == 12 && seq12());
    tmp = (i == 304 && seq304());
    tmp = (i == 962 && seq962());
}

Этот код довольно прямолинейный и полагается на тот факт, что логический оператор AND оценивает только второй операнд, если первый имеет значение true.