Loop -, Repeat-Programm in Java (Java-Anfänger-Frage)

Statt Schalter haben, könnten Sie ein array von option-Vollzieher. Wenn der Benutzer trifft eine Zahl (also 1) es bezieht sich auf das array-element 0, welches dann ausgeführt wird. Dies ermöglicht eine bessere Erweiterbarkeit, wie Sie können, erstellen Sie einfach neue Vollstrecker.

private interface Executor {
  public void run();
}

...
public static void main(String[] str) {
  Executor temp = new Executor() {
    public void run() {
      System.out.println("Under Construction");
    }
  }

  Executor[] ex = {temp, temp, temp, temp};

  while(true) {
    System.out.println("Please enter your choice from the following menu:");
    System.out.println("1. Enter student transcript");
    System.out.println("2. Display transcript summary");
    System.out.println("3. Read student transcript from a file");
    System.out.println("4. Write 1transcript summary to a file");
    System.out.println("5. Exit");

    choice = kb.nextInt();

    if(choice > 0 && choice < ex.length) {
      ex[choice - 1].run();
    } else {
      break;
    }
  }
}

Bin ich mir auch nicht sicher, was genau du meinst mit der Frage. Wollen Sie dem Benutzer erlauben, noch einmal zu wählen, wenn Sie wählen ein 'under construction' - option? In diesem Fall würde ich brechen Sie aus in eine Methode wieder aufgerufen, um das Menü wieder.

public static void main(String [] args) {
    showMenu();
}

public static void showMenu() {
    Scanner kb = new Scanner (System.in);
    int choice;
    System.out.println("Please enter your choice from the following menu:");
    System.out.println("1. Enter student tanscript");
    System.out.println("2. Display transcript summary");
    System.out.println("3. Read student transcript from a file");
    System.out.println("4. Write 1transcript summary to a file");
    System.out.println("5. Exit");

    choice = kb.nextInt();

    switch (choice) {
        case 1:
        case 2:
        case 3:
        case 4:
            System.out.println("Under construction");
            System.out.println();
            showMenu();
            return;
        case 5:
            return;
        default:
            showMenu();
            return;
    }
}

Wenn Sie möchten, entfernen Sie die langen switch-Anweisung, Sie könnte möglicherweise erstellen Sie eine Map<int, MenuAction>, wo MenuAction ist eine Schnittstelle, die eine Methode hat DoAction führt, dass das Verhalten.

public interface MenuAction {
    void doAction();
}

public UnderConstructionAction implements MenuAction {
    public void doAction() {
        System.out.println("Under construction");
        System.out.println();
    }
}

public ExitAction implements MenuAction {
    public void doAction() {
    }
}

public class MainClass {
    static {
        Map<Integer, MenuAction> menuActions = new HashMap<Integer, MenuAction>();
        menuActions.put(1, new UnderConstructionAction());
        menuActions.put(2, new UnderConstructionAction());
        menuActions.put(3, new UnderConstructionAction());
        menuActions.put(4, new UnderConstructionAction());
        menuActions.put(5, new ExitAction());
    }

    public static void main(String [] args) {
        showMenu();
    }

    public static void showMenu() {
        Scanner kb = new Scanner (System.in);
        int choice;
        System.out.println("Please enter your choice from the following menu:");
        System.out.println("1. Enter student tanscript");
        System.out.println("2. Display transcript summary");
        System.out.println("3. Read student transcript from a file");
        System.out.println("4. Write 1transcript summary to a file");
        System.out.println("5. Exit");

        choice = kb.nextInt();

        if (!menuActions.containsKey(choice)) {
            showMenu();
            return;
        }

        menuActions.get(choice).doAction();
    }
}

Man könnte sogar noch weiter gehen, und erstellen Sie eine StudentTranscriptAction, TranscriptSummaryAction etc. erbt UnderConstructionAction, hat aber eine Description Feld, und verwenden Sie diese, um den Aufbau der Menü-Ausgabe.

Hinweis: ich habe wenig getan, Java, und noch nicht getestet code.

Alternative zu ICR ' s Antwort ist mit der Observer-Muster. Wenn eine Auswahl getroffen, wird ein Ereignis erzeugt (wie, wenn ein JButton gedrückt wird), und es können weitere Objekte abonnieren, die Veranstaltung.

Können Sie lokal behandeln Sie das Ereignis, wie das Java-Swing-Architektur ist, oder gehen Sie für einen zentralen Event-Bus wie in der Architektur.

Auf der einen Seite, dem observer-Muster ist leicht erweiterbar, da müssen Sie nicht zum ändern der MainClass-code, auf der anderen Seite könnte es der code weniger transparent als alles abhängig von der Laufzeit-Konfiguration - die Zuhörer haben selbst registriert.

Haben Sie auch einen Blick auf die Beispiele in der ultimative Ort des Wissens, wikipedia 🙂

Beispiel:

public class Foo extends Observable {

    //The Observers would normally be in their own file
    static class OneHandler implements Observer {
        public void update(Observable o, Object val) {
            if (val != null && val.equals(1)) {
                System.out.println("One pressed");
            }
        }
    }

    static class TwoHandler implements Observer {
        public void update(Observable o, Object val) {
            if (val != null && val.equals(2)) {
                System.out.println("Two pressed");
            }
        }
    }

    static class EverythingHandler implements Observer {
        public void update(Observable o, Object val) {
            if (val != null) {
                System.out.println(val + " pressed");
            } else {
                System.out.println("Null pressed");
            }
        }
    }

    public void askQuestion() {
        //ask the question
        System.out.println("Ask Question");
        setChanged(); //otherwise observers are not notified
        notifyObservers(1); //in this example 1 is pressed (will be autoboxed to Integer)
    }

    public static void main(String[] args) {
        //main and Foo would usually not be in the same class
        Foo foo = new Foo();
        //Register observers.
        //Note that you do not bind OneHandler to 1 here, but that OneHandler
        //itself knows when to react. It could be that more Observables would react 
        //to the same event
        //You would not know the order in which they are called.
        foo.addObserver(new OneHandler());
        foo.addObserver(new TwoHandler());
        foo.addObserver(new EverythingHandler());

        foo.askQuestion();
    }
}