Почему класс NeverSwitch перекрывает мой класс AlwaysSwitch?

Question

Я использую шаблонный метод. У меня есть драйвер, который предоставляет мне игру, которая создает игру и проходит через один из двух классов переключения: AlwaysSwitch или NeverSwitch. Затем драйвер создает пробную версию Always Switch и отдельную пробную версию NeverSwitch. Каждое испытание проходит 100 раз и подсчитывает, сколько раз каждый случай выигрывает игру.

Оба эти класса расширяют Game. В игре есть абстрактный метод, который называется Switching(). Оба коммутирующих класса наследуют этот метод. Я поместил простое утверждение печати в обоих классах. AlwaysSwitch "Я хотел бы переключиться", в то время как NeverSwitch имеет "Я останусь".

Моя проблема даже в пробной версии Always switch, которая создает new Game g = new AlwaysSwitch();, выход всегда "я останусь". и в new Game g = new NeverSwitch();, выход снова будет "Я останусь".

Я попытался закомментировать пробную версию NeverSwitch в драйвере, и только после этого пробная версия AlwaysSwitch сработает.

Я не понимаю, почему класс neverSwitch переопределяет класс AlwaysSwitch?

public class Host {
    private Door prizeDoor;

    /**
     * Choose a random prize door and keep it secret.
     */
    public void choosePrizeDoor() {
        prizeDoor = Door.randomDoor();
    }

    /**
     * Reveal a door that does not contain the prize and does not
     * match the one the contestant chose.
     */
    public Door revealADoor(Door contestantChoice) {
        Door result = contestantChoice;
        // Randomly pick a door. Might iterate few times.
        while (result == contestantChoice || result == prizeDoor) {
            result = Door.randomDoor();
        }
        return result;
    }

    /**
     * Determine if the contestant's door wins or loses.
     */
    public boolean isAWinner(Door contestantChoice) {
        return prizeDoor == contestantChoice;
    }
}

/**
 * An enum representing a door. Left = 1, center = 2, right = 3.
 * Can also choose random doors here.
 * 
 * @author Todd Whittaker
 * @version 20180110
 */
public enum Door {
    LEFT(1),
    CENTER(2),
    RIGHT(3);

    private int value;
    private static final Random r = new Random();

    Door(int value) {
        this.value = value;
    }

    /**
     * Find the door that matches the number.
     */
    public static Door valueOf(int num) {
        switch (num) {
            case 1: return LEFT;
            case 2: return CENTER;
            default: return RIGHT;
        }
    }

    /**
     * return the number matching this door.
     */
    public int valueOf() {
        return value;
    }

    /**
     * Pick a random door (LEFT, CENTER, RIGHT).
     */
    public static Door randomDoor() {
        return Door.valueOf(r.nextInt(3)+1);
    }
}

public abstract class Game {

    private Host host;
    public Door contestantChoice;
    public Door revealedDoor;

    /**
     * Creates the game and its host.
     */
    public Game () {
        this.host = new Host();
    }

    /**
     * Implements the algorithm for the game:
     * 1. The host chooses which door has a prize at random.
     * 2. The contestant picks a door (left, center, or right) at random.
     * 3. The host reveals one of the two other doors that does not contain 
        the prize.
     * 4. The contestant can then switch to the other door or keep their 
        current door.
     * 5. The prize is revealed and the contestant wins or loses.
     */
    final boolean runGame() {
        host.choosePrizeDoor(); //1
        System.out.println("Let's Play");

        contestantChoice = contestantChoice.randomDoor();//2
        System.out.println("Contestant chooses " + contestantChoice);

        revealedDoor = host.revealADoor(contestantChoice); //3
        System.out.println("reveal door " + revealedDoor);

        System.out.println("would you like to switch?");
        switching();

        if(host.isAWinner(contestantChoice) == true)
        {
            System.out.println("Winner!! \n");
            return true;
        }

        System.out.println("Sorry you lose \n");

        return false;
    }

    abstract void switching();
}

public class AlwaysSwitch extends Game {
    void switching()
    {        
        System.out.println("I would like to switch" );
    }
}

public class NeverSwitch extends Game {
     void switching()
    {        
        System.out.println("I will stay." );
    }
}

public class Driver {
    private static final int TRIALS = 100;

    public static void main(String [] args) {
        int switchWins = 0;
        int stayWins = 0;
        for (int i = 0; i < TRIALS; ++i) {
           Game g = new AlwaysSwitch();
           if (g.runGame()) {
               ++switchWins;
           }
        }

        for (int i = 0; i < TRIALS; ++i) {
            Game g = new NeverSwitch();
            if (g.runGame()) {
                ++stayWins;
            }
        }

        System.out.println("Out of " + TRIALS + " trials:");
        System.out.println(" Switch won " + switchWins + " times.");
        System.out.println(" Stay won " + stayWins + " times.");
    }
}

Все результаты говорят: "Я останусь".

Answer 1

Чтобы завершить код, вы можете изменить подпись switching() чтобы:

abstract Door switching(Door contestantsChoice, Door revealedDoor);

Тогда вы бы позвонили в Game.runGame() как это:

contestantsChoice = switching(contestantsChoice, revealedDoor);

Ваш AlwaysSwitch реализация будет:

Door switching(Door contestantChoice, Door revealedDoor)
{
    System.out.println("I would like to switch" );
    return selectRemainingDoor(contestantChoice, revealedDoor);
}

private Door selectRemainingDoor(Door contestantChoice, Door revealedDoor) {
    List<Door> doors = new ArrayList<>(asList(LEFT, CENTER, RIGHT));
    doors.remove(contestantChoice);
    doors.remove(revealedDoor);
    return doors.get(0);
}

И ваш NeverSwitch реализация будет выглядеть так:

Door switching(Door contestantChoice, Door revealedDoor)
{
    System.out.println("I will stay." );
    return contestantChoice;
}