Азбука Морзе + Шифр Цезаря [дубликат]

Вы заблудились в двух соснах. Посему хочу показать вам немного измененное решение. Изменения состоят в том, что здесь нет классов-фабрик. Все дело в том, что каноническое представление паттерна фабричный метод предусматривает такие классы, однако в реальной жизни этот метод давно выродился до соответствующих методов в классе - родителе(именно так сделал я). Кроме того я немного подправил энам, потому как в вашем случае он выполняет очень странную роль - он образуется из стринга, чтобы по нему в дальнейшем фабрика каким-то способом создала и венула новый экземпляр класса (тогда почему это не сделать по стрингу). Кроме того, в этом случае вы увидите , что энам может выполнять роль не только простого перечисления.

public class Lesson1Main {
    public static void main(String[] args) {
        final String algorithm = Algorithms.CAESAR.name();
        final String initialString = "dima";
        System.out.println("Initial: " + initialString);
        System.out.println("Algorithm: " + algorithm);
        final Encoder encoder = Coder.getEncoder(algorithm);
        final String encoded = encoder.encode(initialString);
        System.out.println("Encoded: " + encoded);
        final Decoder decoder = Coder.getDecoder(algorithm);
        final String decoded = decoder.decode(encoded);
        System.out.println("Decoded: " + decoded);
        if (!Objects.equals(initialString, decoded)) {
            throw new IllegalStateException("Initial and decoded strings mismatch");
        }
    }
}

public enum Algorithms {
    CAESAR(new CaesarCodec()),
    MORSE(new MorseCodec());
    private final Coder coder;
    private Algorithms(Coder coder) {
        this.coder = coder;
    }
    public Decoder getDecoder() {
        return coder;
    }
    public Encoder getEncoder() {
        return coder;
    }
}
public interface Decoder {
    String decode(String input);
}
public interface Encoder {
    String encode(String input);
}
public abstract class Coder implements Encoder, Decoder {
    public static Decoder getDecoder(String name) {
        return Algorithms.valueOf(name).getDecoder();
    }
    public static Encoder getEncoder(String name) {
        return Algorithms.valueOf(name).getEncoder();
    }
}
public class CaesarCodec extends Coder {
    private static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    @Override
    public String encode(String input) {
        {
            int shiftKey = 3;
            input = input.toLowerCase();
            String cipherText = "";
            for (int i = 0; i < input.length(); i++) {
                char replaceVal = input.charAt(i);
                int charPosition = ALPHABET.indexOf(replaceVal);
                if (charPosition != -1) {
                    int keyVal = (shiftKey + charPosition) % 26;
                    replaceVal = ALPHABET.charAt(keyVal);
                }
                cipherText += replaceVal;
            }
            return cipherText;
        }
    }
    @Override
    public String decode(String input) {
        int shiftKey = 3;
        input = input.toLowerCase();
        String plainText = "";
        for (int i = 0; i < input.length(); i++) {
            char replaceVal = input.charAt(i);
            int charPosition = ALPHABET.indexOf(replaceVal);
            if (charPosition != -1) {
                int keyVal = (charPosition - shiftKey) % 26;
                if (keyVal < 0) {
                    keyVal = ALPHABET.length() + keyVal;
                }
                replaceVal = ALPHABET.charAt(keyVal);
            }
            plainText += replaceVal;
        }
        return plainText;
    }
}
class MorseCodec extends Coder {
    private static final char[] ENGLISH = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
        'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
        'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
        ',', '.', '?'};
    private static final String[] MORSE = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",
        ".---", "-.-", ".-..", "--", "-.", "---", ".---.", "--.-", ".-.",
        "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", ".----",
        "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----.", "-----",
        "--..--", ".-.-.-", "..--.."};
    @Override
    public String encode(String input) {
        input = input.toLowerCase();
        char[] chars = input.toCharArray();
        String str = "";
        for (int i = 0; i < chars.length; i++) {
            for (int j = 0; j < ENGLISH.length; j++) {
                if (ENGLISH[j] == chars[i]) {
                    str = str + MORSE[j] + " ";
                }
            }
        }
        return str;
    }
    @Override
    public String decode(String input) {
        String[] letters = input.split(" ");
        String str = "";
        for (int i = 0; i < letters.length; i++) {
            for (int j = 0; j < MORSE.length; j++) {
                if (MORSE[j].equals(letters[i])) {
                    str = str + ENGLISH[j];
                }
            }
        }
        return str;
    }
}

Как бы делал я, из того, что вы написали.

У нас есть типы кодировщиков

public enum Algorithms {
    CAESAR,
    MORSE;
}

Интерфейсы

public interface Encoder {
    String encode(String input);
}
public interface Decoder {
    String decode(String input);
}

Цезарь кодируется элементарно

public class CaesarCodec implements Encoder, Decoder {
    public static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    private int _shift;
    public CaesarCodec(int shift) {
        this._shift = shift;
    }
    @Override
    public String encode(String input) {
        StringBuilder ret = new StringBuilder();
        for(int i=0; i<input.length(); i++)
            ret.append(ALPHABET.charAt((ALPHABET.indexOf(input.charAt(i)) + _shift)%ALPHABET.length()));
        return ret.toString();
    }
    @Override
    public String decode(String input) {
        StringBuilder ret = new StringBuilder();
        for(int i=0; i<input.length(); i++)
            ret.append(ALPHABET.charAt((ALPHABET.indexOf(input.charAt(i)) - _shift + ALPHABET.length())%ALPHABET.length()));
        return ret.toString();
    }
}

Морзе - менее лакончино, ну и я добавил хеш таблиц для скорости

public class MorseCodec implements Encoder, Decoder {
    static final HashMap<Character, String> _encodeMap = new HashMap<>();
    static final HashMap<String, Character> _decodeMap = new HashMap<>();
    static final char[] english = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
            'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
            'y', 'z', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
            ',', '.', '?' };
    static final String[] morse = { ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",
            ".---", "-.-", ".-..", "--", "-.", "---", ".---.", "--.-", ".-.",
            "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", ".----",
            "..---", "...--", "....-", ".....", "-....", "--...", "---..", "----.", "-----",
            "--..--", ".-.-.-", "..--..", };
    public MorseCodec(){
        for(int i=0; i<english.length; i++)
        {
            _encodeMap.put(english[i], morse[i]);
            _decodeMap.put(morse[i], english[i]);
        }
    }
    @Override
    public String encode(String input) {
        StringBuilder ret = new StringBuilder();
        for(int i=0; i<input.length(); i++)
        {
            ret.append(_encodeMap.get(input.charAt(i)));
            ret.append(" ");
        }
        return ret.toString().trim();
    }
    @Override
    public String decode(String input) {
        String[] letters = input.split(" ");
        StringBuilder ret = new StringBuilder();
        for(int i=0; i<letters.length; i++)
            ret.append(_decodeMap.get(letters[i]));
        return ret.toString();
    }
}

Фабрика, простейший вариант

public class Factory{
    public Encoder getEncoder(Algorithms type){
        if (type == Algorithms.CAESAR) return new CaesarCodec(3);
        if (type == Algorithms.MORSE) return new MorseCodec();
        throw new IllegalArgumentException("type");
    }
    public Decoder getDecoder(Algorithms type){
        if (type == Algorithms.CAESAR) return new CaesarCodec(3);
        if (type == Algorithms.MORSE) return new MorseCodec();
        throw new IllegalArgumentException("type");
    }
}

Проверка

public static void main(String[] args) {
    Factory factory = new Factory();
    Encoder morseEncoder = factory.getEncoder(Algorithms.MORSE);
    Decoder morseDecoder = factory.getDecoder(Algorithms.MORSE);
    System.out.println(morseEncoder.encode("hello"));
    System.out.println(morseDecoder.decode(".... . .-.. .-.. ---"));
    Encoder caesarEncoder = factory.getEncoder(Algorithms.CAESAR);
    Decoder caesarDecoder = factory.getDecoder(Algorithms.CAESAR);
    System.out.println(caesarEncoder.encode("hello"));
    System.out.println(caesarDecoder.decode("khoor"));
}

Вывод

.... . .-.. .-.. ---
hello
khoor
hello

Контроль правильности ввода уже думайте сами.