Serait-il plus facile de garder le code comme si imbriquées déclarations ou pour essayer de convertir à un commutateur ou plusieurs commutateurs

joe7664:

J'ai terminé une mission de codage pour la classe et a donné des commentaires par un ami que les ifs imbriquées pourrait ressembler beaucoup mieux que les états de commutation

J'ai essayé de le convertir en commutateurs, mais il semble être sur le même sinon plus de travail.

//this is the absolute basic frame of the code created
if(arg){
    //code
    if(arg){
        //code
        if(arg){
            //code
        }
        else if(arg){
            //code
        }
    }
    else if(arg){
        //code
    }
else if(arg){
    //code
}

Serait-il plus facile et mieux regarder si elle a été convertie en instructions switch ou serait-il le même si pas pire gâchis?

EDIT: pour ghostcat, c'est la section complète du code que je simplifié pour la question

while(loop == true){
        System.out.print("Do you have more students to enter (Y for yes, N for no): ");
        yn = input.nextLine();
        if(yn.equals("Y") || yn.equals("y")) {
            System.out.print("Undergraduate or Graduate? (U for undergraduate, G for graduate): ");
            ug = input.nextLine();
            if(ug.equals("U") || ug.equals("u")) {
                System.out.print("Student name: ");
                NAME = input.nextLine();
                System.out.print("Student ID: ");
                ID = input.nextInt();
                System.out.print("Student GPA: ");
                GPA = input.nextFloat();
                System.out.print("Is student a transfer student? (Y for yes, N for no): ");
                input.nextLine();
                transfer = input.nextLine();
                if(transfer.equals("Y") || transfer.equals("y")) {
                    ts = true;
                    students.add(new UndergradStudent(NAME, ID, GPA, ts));
                }
                else if(transfer.equals("N") || transfer.equals("n")) {
                    ts = false;
                    students.add(new UndergradStudent(NAME, ID, GPA, ts));
                }
            }
            else if(ug.equals("G") || ug.equals("g")) {
                System.out.print("Student name: ");
                NAME = input.nextLine();
                System.out.print("Student ID: ");
                ID = input.nextInt();
                System.out.print("Student GPA: ");
                GPA = input.nextFloat();
                System.out.print("What college did the student graduate from: ");
                input.nextLine();
                college = input.nextLine();
                students.add(new GradStudent(NAME, ID, GPA, college));
            }
        }
        else if(yn.equals("N") || yn.equals("n")) {
            loop = false;
        }
    }

GhostCat de Monica C.:

Du code propre perspective, les deux options (if / else ou commutateurs) ne sont pas préférables. Mais la résolution que , sans plus de contexte est impossible.

Tout, le premier vrai problème est que votre méthode qui se trouve autour de votre code d'exemple doit examiner tant de paramètres.

Le nombre d'idéal d'arguments pour une fonction est nulle (niladic). Vient ensuite un (monadique), suivi de près par deux (dyadique). Trois arguments (triades) doivent être évités si possible. Plus de trois (polyadique) exige une justification et très particulière alors ne devrait pas être utilisé de toute façon.

En d' autres termes: vous vous efforcez d'écrire des méthodes qui ont peu d' arguments que possible. Parce que chaque argument potentiellement ajoute la nécessité d'un tel cas ou le contraste de l' interrupteur.

Lorsque plusieurs instruction switch travaillerait pour vous, un chemin potentiel pourrait être se tourner vers le polymorphisme. La « bonne » façon de passer en POO est d'avoir différentes classes, et l'utilisation du polymorphisme d'exécution pour déterminer quelle méthode est effectivement appelé à l'exécution.

Compte tenu du contexte ajouté:

ug = input.nextLine();
if(ug.equals("U") || ug.equals("u")) {
...

La solution de code propre pourrait se présenter comme suit:

ug = input.nextLine();
if (ug.equalsIgnoreCase("u")) {
  fetchValuesForUndergraduate(); 
}

C'est ça! Votre vrai problème avec votre code actuel est qu'il fait tant de choses dans un seul endroit. La solution « code propre » à cela est de déplacer le code dans des méthodes d'aide distinctes, qui ont de beaux noms révélateurs, et que faire beaucoup moins.