Caesar Cipher with Three-Digit Key in Java

My first post ever here, so bear with me. I have to modify a given program for a Caesar Cipher to make the key 3 digits as opposed to its previous 1. The code I have is:

/** Class for doing the encryption and decryption using the Caesar Cipher. */
public class CaesarCipher {
    protected char[] encoder = new char[26];    // Encryption Array
    protected char[] decoder = new char[26];    // Decryption Array
    protected int[] r_array = new int[3];
    /** Constructor that initializes the encryption and decryption arrays. */
    public CaesarCipher(int rotation) {     // function begins by changing input rotation into an array of digits
        String number = String.valueOf(rotation);
        for(int i = 0; i < number.length(); i++) {
            int r = Character.digit(number.charAt(i), 10);
            r_array[i] = r; // input changed to array
        }
        //TODO: fix three digit decryption
        for (int k = 0; k < 26; k+=3) {     
// Origianlly there was one for loop with a k++ that cycled through the rotation directly, as oppose to r_array.
            encoder[k] = (char) ('A' + (k + r_array[0]) % 26);
            decoder[k] = (char) ('A' + (k - r_array[0] + 26) % 26);
        }
        for (int k = 1; k < 26; k+=3) {
            encoder[k] = (char) ('A' + (k + r_array[1]) % 26);
            decoder[k] = (char) ('A' + (k - r_array[1] + 26) % 26);
        }
        for (int k = 2; k < 26; k+=3) {
            encoder[k] = (char) ('A' + (k + r_array[2]) % 26);
            decoder[k] = (char) ('A' + (k - r_array[2] + 26) % 26);
        }
    }
    /** Returns String representing encrypted message. */
    public String encrypt(String message) {
        return transform(message, encoder);     // use encoder array
    }
    /** Returns decrypted message given encrypted secret. */
    public String decrypt(String secret) {
        return transform(secret, decoder);      // use decoder array
    }
    /** Returns transformation of original String using given code. */
    private String transform(String original, char[] code) {
        char[] msg = original.toCharArray();
        for (int k=0; k < msg.length; k++) {
            if (Character.isUpperCase(msg[k])) {
                int j = msg[k] - 'A';
                msg[k] = code[j];
            }
            if (Character.isLowerCase(msg[k])) {
                int j = msg[k] - 'a';
                msg[k] = code[j];
            }
        }
        return new String(msg);
    }
}

Then there was a separate class for the main.

public class CipherDriver {
    /** Simple main method for testing the Caesar cipher */
    public static void main(String[] args) {

        /** Uses user input to create new message */    // Added for practice
        Scanner input_1 = new Scanner(System.in);
        System.out.println("\nEnter desired message or enter 'DEFAULT' to use default message: ");
        String input_m = input_1.nextLine();
        String d_string = "DEFAULT";
        if (input_m.equals(d_string)) {     // builds a default message
            input_m = "CAESAR HAS NAMED SOMETHING AFTER HIMSELF, AGAIN.";
        }
        System.out.println("Encoding message... \n");

        /** Uses user input to assign new encryption key */
        Scanner input_2 = new Scanner(System.in);
        System.out.println("Enter three digit rotation to generate cipher: ");
        int rotation = input_2.nextInt();
        System.out.println("Generating cipher code... \n");

        CaesarCipher cipher = new CaesarCipher(rotation);
        String message = input_m;

        /** Uses user input to determine whether the user wishes to encrypt or decrypt the message */
        Scanner input_3 = new Scanner(System.in);
        System.out.println("1.  Encrypt \n2.  Decrypt \n3.  Encrypt then Decrypt \n " +
                "\nEnter number for desired function: ");
        int option = input_3.nextInt();
        if (option == 1) {
            System.out.println("Encrypting message... ");
            System.out.println("Message: " + message);
            System.out.println("Encryption code = " + new String(cipher.encoder));
            String coded = cipher.encrypt(message);
            System.out.println("Encrypted secret:  " + coded);
        }
        if (option == 2) {
            System.out.println("Decrypting message... ");
            System.out.println("Secret: " + message);
            System.out.println("Decryption code = " + new String(cipher.decoder));
            String answer = cipher.decrypt(message);
            System.out.println("Decrypted message:  " + answer);  //should print plaintext again
        }
        if (option == 3) {
            System.out.println("\nMessage: " + message);
            System.out.println("\nEncrypting message... \n");
            System.out.println("Encryption code = " + new String(cipher.encoder));
            String coded = cipher.encrypt(message);
            System.out.println("Encrypted secret:  " + coded);
            System.out.println("\nDecrypting message... \n");
            System.out.println("Decryption code = " + new String(cipher.decoder));
            String answer = cipher.decrypt(coded);
            System.out.println("Decrypted message:  " + answer);  //should print plaintext again
        }
    }
}

The outputs I've been recieving have been, well, incorrect.

Enter desired message or enter 'DEFAULT' to use default message: 
DEFAULT
Encoding message... 

Enter three digit rotation to generate cipher: 
123
Generating cipher code... 

1.  Encrypt 
2.  Decrypt 
3.  Encrypt then Decrypt 
 
Enter number for desired function: 
3

Message: CAESAR HAS NAMED SOMETHING AFTER HIMSELF, AGAIN.

Encrypting message... 

Encryption code = BDFEGIHJLKMONPRQSUTVXWYAZB
Encrypted secret:  FBGTBU JBT PBNGE TRNGVJLPH BIVGU JLNTGOI, BHBLP.

Decrypting message... 

Decryption code = ZZZCCCFFFIIILLLOOORRRUUUXX
Decrypted message:  CZFRZR IZR OZLFC ROLFUIIOF ZFUFR IILRFLF, ZFZIO.

How can I make the program correctly utilize a three-digit key?

The reconfigured alphabets are really not required for the Caesar cipher. You can just add / subtract the key value for encryption / decryption when you've obtained the index in the alphabet.

For each character in input:

1. convert character to index in alphabet (in this case the ABC);
2. perform modular addition with the digit mod the size of the alphabet to encrypt - modular subtraction for decryption;
3. convert new index to character in alphabet again
4. add that character to the output

And that's all there is to it.

If you want to encrypt the first character with the first digit, and the second with the second digit then you need separate reconfigured alphabets for those keys. Current in your example the encryption code begins and ends with a B. Think about that for a second, that can surely not be right?