Boucle dans la validation de carte de crédit en java

Votre problème est que vos deux conditions de boucle impliquent totalSum mais vous ne changez que checkDigit.

while (totalSum % 10 != 0)
{
    checkDigit--;
    if (totalSum % 10 == 0)
    {
        break;
    }
}

Vous devez recalculer totalSum ou modifier la condition pour être basée sur checkDigit. Si vous voulez boucler et décrémenter comme vous le faites, vous devrez ajouter une méthode qui exécute l'algorithme et l'appeler à chaque fois. La façon dont vous avez décrit votre classe rend cela très gênant car vous ne convertissez pas les nombres.

public static int[] cardToNumbers(String cardText) {

    // \D is regex for non-digits
    cardText = cardText.replaceAll("\\D", "");

    int[] cardNumbers = new int[cardText.length()];

    // convert unicode to corresponding integers
    for (int i = 0; i < cardText.length(); i++)
        cardNumbers[i] = cardText.charAt(i) - '0';

    return cardNumbers;
}

public static int calcTotalSum(int[] cardNumbers) {

    int sum = 0;

    /* "every other one" loops
     *
     * I recommend against the "mod 2 index" scheme
     * i % 2 relies on the card number being even
     * you can't have your code blow up with unusual inputs
     *
     */

    for (int i = cardNumbers.length - 1; i >= 0; i -= 2) {
        sum += cardNumbers[i];
    }
    for (int i = cardNumbers.length - 2; i >= 0; i -= 2) {
        int dig = cardNumbers[i] * 2;
        while (dig > 0) {
            sum += dig % 10;
            dig /= 10;
        }
    }

    return sum;
}

Maintenant, vous pouvez faire quelque chose comme:

public void makeItValid() {
    int[] invalidNumbers = cardToNumbers(creditCardNumber);

    int sum = calcTotalSum(invalidNumbers);

    while ((sum = calcTotalSum(invalidNumbers)) % 10 != 0)
        invalidNumbers[invalidNumbers.length - 1]--;

    totalSum = sum;
    checkDigit = invalidNumbers[invalidNumbers.length - 1];
}

Mais vous devriez pouvoir simplement soustraire la différence pour trouver le chiffre de contrôle valide:

if (totalSum % 10 != 0) checkDigit -= totalSum % 10;

Ou quelque chose comme:

public void makeItValid() {
    int[] invalidNumbers = cardToNumbers(creditCardNumber);

    checkDigit = invalidNumbers[invalidNumbers.length - 1] -= totalSum % 10;
    totalSum = calcTotalSum(invalidNumbers);

    valid = true;
}

Quelques apartés,

Je recommanderais de stocker les chiffres en tant que champ et de faire en sorte que checkDigit représente un index dans le tableau. Cela simplifierait certaines des opérations que vous effectuez.

Je suggère également de ne pas changer" silencieusement " les champs en interne, c'est-à-dire comme dans votre méthode makeItValid, sauf s'il s'agit d'une spécification de affectation. Je pense qu'une meilleure forme est de laisser le code "propriétaire" faire les changements lui-même, ce qui est plus clair à l'extérieur. Une implémentation quelque peu complète ressemblerait à ceci:

public class CreditCard {
    public static void main(String[] args) {
        if (args.length == 0) return;

        CreditCard card = new CreditCard(args[0]);

        if (!card.isValidNumber()) {
            card.setCheckDigit(card.getValidCheckDigit());
        }
    }

    private final String cardText;
    private final int[] cardDigits;
    private final int cdIndex;

    public CreditCard(String ct) {
        cardDigits = cardToNumbers(cardText = ct);

        if ((cdIndex = cardDigits.length - 1) < 0) {
            throw new IllegalArgumentException("# had no digits");
        }
    }

    public boolean isValidNumber() {
        return calcTotalSum(cardDigits) % 10 == 0;
    }

    public void setCheckDigit(int dig) {
        cardDigits[cdIndex] = dig;
    }

    public int getValidCheckDigit() {
        int sum = calcTotalSum(cardDigits);
        if (sum % 10 != 0) {
            return cardNumbers[cdIndex] - sum % 10;
        } else {
            return cardNumbers[cdIndex];
        }
    }

    // above static methods
}

La meilleure forme de l'OMI serait de refuser la création d'un objet de carte de crédit à moins que le chiffre de contrôle ne soit valide. En tant que principe de POO, il ne devrait pas avoir de sens de créer des cartes de crédit invalides. Le constructeur doit lever une exception si la carte n'est pas valide et avoir une méthode statique pour corriger le nombre.

Je ferais quelque chose comme ce qui suit (raccourci):

public class CreditCard {
    public CreditCard(String number) {
        if (!validateCheckDigit(number)) {
            throw new IllegalArgumentException("check digit failure");
        }
    }
}

public static void main(String[] args) {
    String number = args[0];
    CreditCard card = null;

    boolean valid = false;
    do {
        try {
            card = new CreditCard(number);
            valid = true;
        } catch (IllegalArgumentException e) {
            number = CreditCard.correctCheckDigit(number);
        }
    } while (!valid);
}

Je suppose que c'est plus ou moins faire vos devoirs pour vous, mais je suis sûr que vous pouvez en tirer des leçons.

À moins que je manque quelque chose de majeur sur le fonctionnement de la validation, votre méthode makeitvalid ne fonctionnera pas de la manière dont vous l'abordez.

Il est plus logique (du moins pour moi) d'extraire tout ce que vous avez dans votre constructeur dans une méthode ie.

boolean isValid(String cardNumber);

Qui ferait tout ce que votre constructeur fait sauf définir l'indicateur valide. votre constructeur devient alors

public CreditCard(String pCreditCardNumber){
    valid = isValid(pCreditCardNumber);
}

Et puis pour trouver quel changement le rendrait valide votre méthode check valid fait quelque chose comme

change the value of check digit
   if (isValid(Changed String))
        return checkdigit
   else
       continue
repeat until you either find one that works or until you determine that it can't work.

Quelque chose dans ce sens devrait faire. Vous devrez toujours implémenter quelques méthodes par vous-même.

public static void main(String[] args) {
    String creditCardNumber = readCreditCardNumber();
    String correctCreditCardNumber = getCorrectCreditCardNumber(creditCardNumber);

    if (creditCardNumber.equals(correctCreditCardNumber)) {
        System.out.println("Credit Card Valid");
    } else {
        System.out.println("Credit Card Invalid. Did you mean " + correctCreditCardNumber + "?");
    }
}

public static String getCorrectCreditCardNumber(String creditCardNumber) {
    int[] creditCardDigits = getCreditCardDigits(creditCardNumber);

    int sum = 0;
    for (int i = creditCardDigits.length - 2; i >= 0; i--) {
        if (isOdd(i)) {
            sum += creditCardDigits[i];
        } else {
            sum += digitSum(creditCardDigits[i] * 2);
        }
    }

    int last = creditCardDigits.length - 1;
    int remainder = sum % 10;
    if (remainder != 0) {
        creditCardDigits[last] = 10 - remainder;
    }

    return getCreditCardNumberAsString(creditCardDigits);
}

Ce programme est très dynamique. Je n'ai pas ajouté trop de gestion des erreurs. Vous pouvez entrer n'importe quel nombre divisible par 8.

Code:

Enter a card number: 4358 9795
Number is valid?: true

Continue? (y/n): y

Enter a card number: 4358 9796
Number is valid?: false

Continue? (y/n): y

Enter a card number: 43-58 97-95
Number is valid?: true

Continue? (y/n): n

Exiting...

CreditCardValidator.java

import java.text.ParseException;
import java.util.Scanner;

public class CreditCardValidator {
    Integer[] digits;

    public CreditCardValidator(String numberSequence) {
        parseNumber(numberSequence);
    }

    private void parseNumber(String numberSequence) {
        try {
            String sequence = numberSequence.replaceAll("[\\s-]+", "");

            int length = sequence.length();

            if (length % 8 != 0) {
                throw new IllegalArgumentException("Number length invalid.");
            }

            digits = new Integer[length];

            int pos = 0;
            for (Character c : sequence.toCharArray()) {
                if (Character.isDigit(c)) {
                    digits[pos++] = Character.getNumericValue(c);
                } else {
                    throw new ParseException("Invalid digit.", pos);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean validateNumber() {
        int sum = 0;

        for (int i = digits.length - 1; i >= 0; i--) {
            if (i % 2 == 1) {
                sum += digits[i];
            } else {
                sum += NumberUtils.sumDigits(digits[i] * 2);
            }
        }

        return sum % 10 == 0;
    }

    public static void main(String[] args) {
        boolean stop = false;
        CreditCardValidator c;

        while (!stop) {
            System.out.print("Enter a card number: ");
            c = new CreditCardValidator(new Scanner(System.in).nextLine());
            System.out.println("Number is valid?: " + c.validateNumber());
            System.out.print("\nContinue? (y/n): ");

            if (new Scanner(System.in).next().charAt(0) == 'n') {
                stop = true;
            }

            System.out.println();
        }

        System.out.println("Exiting...");
        System.exit(0);
    }
}

J'ai écrit un utilitaire de sommation de chiffres séparé:

public class NumberUtils {
    public static void main(String[] args) {
        for(int i = 0; i < 2000; i+=75) {
            System.out.printf("%04d: %02d\n", i, sumDigits(i));
        }
    }

    public static int sumDigits(int n) {
        if (n < 0)
            return 0;

        return sumDigitsRecursive(n, 0);
    }

    private static int sumDigitsRecursive(int n, int total) {
        if (n < 10)
            return total + n;
        else {
            return sumDigitsRecursive(n / 10, total + (n % 10));
        }
    }
}