[JAVA] [Reading Memo] Refactoring-Typecode replacement (pour les types de code qui affectent le comportement) -1

(Quoi) Quel est le code de type qui affecte le comportement?

Par exemple, comme ça.

Tapez du code qui affecte le comportement.java

public int getPayAmount() {
    switch (getType()) {
        case ENGINEER:
            return getMonthlySalary();
        case SALESMAN:
            return getMonthlySalary() + getCommission();
        case MANAGER:
            return getMonthlySalary() + getBonus();
        default:
            return 0;
    }
}

C'est là que le code de type est déterminé et un code différent est exécuté en fonction du résultat. Généralement, les instructions «if --other» et «switch» correspondent aux parties qui font l'objet de ce temps.

Si vous regardez un tel code, ce que vous voulez faire est le suivant.

1. Remplacez le code de type par une structure d'héritage qui réalise un comportement polymorphe
2. Remplacer la ramification conditionnelle par le polymorphisme

(Pourquoi) Pourquoi le remplacer?

J'essaie de remplacer les pièces qui sont traitées différemment en fonction du résultat du jugement du code de type, mais l'avantage de ceci est ↓

★ Vous pouvez supprimer les connaissances sur le comportement dans différentes conditions du client.
    =>Par conséquent, lors de l'ajout d'une nouvelle variation, il devient possible de répondre uniquement en ajoutant la variation.
    =>Sans polymorphisme, vous devrez trouver toutes les branches conditionnelles existantes et ajouter un traitement à chacune.
        =>Cela suggère que des fuites supplémentaires peuvent se produire et constitue un foyer d'échec.

(Comment) Comment le remplacer?

Remplacement de sous-classe

Changer avant.java

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
        case REQUEST_CODE_FOR_EVALUATION_SEND:
　　　　　　　　　　　　　　　　　　　　　　　//Traiter quelque chose
            break;
        case REQUEST_CODE_FOR_SMS_SEND_ACTIVITY:
　　　　　　　　　　　　　　　　　　　　　　　//Traiter quelque chose
            break;
        case REQUEST_CODE_FOR_CAMERA_USAGE:
　　　　　　　　　　　　　　　　　　　　　　　//Traiter quelque chose
            break;
        default:
    }
}

Après le changement.java

class ActivityResult {
    public static final int REQUEST_CODE_FOR_EVALUATION_SEND = 1;
    public static final int REQUEST_CODE_FOR_SMS_SEND_ACTIVITY = 2;
    public static final int REQUEST_CODE_FOR_CAMERA_USAGE = 3;

    static ActivityResult create(int requestCode) {
        switch (requestCode) {
            case REQUEST_CODE_FOR_EVALUATION_SEND:
                return new ActivityResultEvaluationSend();
            case REQUEST_CODE_FOR_SMS_SEND_ACTIVITY:
                return new ActivityResultSmsSend();
            .. //Idem pour les autres codes
        }
    }

    private ActivityResult() {}

    abstract int getRequestCode();
}

class ActivityResultEvaluationSend extends ActivityResult {
    @Override
    public int getRequestCode() {
        return ActivityResult.REQUEST_CODE_FOR_EVALUATION_SEND;
    }
}

class ActivityResultSmsSend extends ActivityResult {
    @Override
    public int getRequestCode() {
        return ActivityResult.REQUEST_CODE_FOR_SMS_SEND_ACTIVITY;
    }
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    ActivityResult result = ActivityResult.create(requestCode);
    // @Implémentez le processus dans todo result.
}

Vous l'avez maintenant remplacé par une sous-classe. Ce n'est pas la forme finale de ce que je voulais faire, mais comme c'est devenu un polymorphisme après cela, j'implémenterais chaque processus dans chaque sous-classe. Cependant, je vais l'écrire séparément.