Why doesn´t my programm works with JavaFX?

Question

Hey guys I have a crypter/decrypter and wanted to use it over an JavaFX. But my problem is I don´t know, why he doesn´t crypt it how he has to do. I would like to hear some tips or updatet code lines from you guys.

If I run this programm he will make an Exception from the Class "Wuerfel" but my if-statments looks all fine for the cryption of the word. So after 2 hours of trying out I don´t know what the problem can be and would appreciate to hear some advices.

public interface Codec{


    String kodiere(String klartext);
    String dekodiere(String geheimtext);
    String gibLosung();
    void setzeLosung(String schluessel)throws
            IllegalArgumentException; // bei ungeeignetem Schlüssel!

}

//-----------------------------------------------------------------

package pis.hue;

import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.AnchorPane;
import javafx.stage.Stage;

public class CodecGui extends Application implements EventHandler<ActionEvent> {

    Button codierer, decodierer;
    TextField losung1, losung2;
    TextArea eingabetext;
    ComboBox auswahl;
    Label eingabelabel, label1, label2;
    Alert info;

    //Codec ceaser = new Ceaser();
    Codec wuerfel1 = new Wuerfel();
    Codec wuerfel2= new Wuerfel();

    @Override
    public void start(Stage primaryStage){
        try{
            //Die GUI über das alles läuft
            AnchorPane root = new AnchorPane();

            //Der Titel der GUI
            primaryStage.setTitle("Hausübung PiS");
            primaryStage.setScene(new Scene(root, 700, 300));
            root.setStyle("-fx-background-color: #363535;");
            primaryStage.show();



            //--------------------------------------------------------
            //Codierer
            codierer = new Button("Codierer");
            codierer.setPrefWidth(120);
            codierer.setMaxHeight(60);
            codierer.setOnAction(this);

            AnchorPane.setRightAnchor(codierer, 10.0);
            AnchorPane.setBottomAnchor(codierer, 10.0);

            //Decodierer
            decodierer = new Button("Decodierer");
            decodierer.setPrefWidth(120);
            decodierer.setMaxHeight(60);
            decodierer.setOnAction(this);

            AnchorPane.setRightAnchor(decodierer, 10.0);
            AnchorPane.setBottomAnchor(decodierer, 60.0);

            //--------------------------------------------------------

            //Eingabefeld
            eingabetext = new TextArea();
            eingabetext.setMaxHeight(300);
            eingabetext.setPrefWidth(700);
            AnchorPane.setTopAnchor(eingabetext, 20.0);
            AnchorPane.setBottomAnchor(eingabetext, 150.0);
            eingabetext.setStyle("-fx-background-color: #BDBDBD;");

            //Losung1
            losung1 = new TextField();
            losung1.setMaxHeight(45);
            losung1.setPrefWidth(250);
            AnchorPane.setBottomAnchor(losung1, 10.0);
            AnchorPane.setLeftAnchor(losung1, 10.0);
            losung1.setStyle("-fx-background-color: #BDBDBD;");

            //Losung2
            losung2 = new TextField();
            losung2.setMaxHeight(45);
            losung2.setPrefWidth(250);
            AnchorPane.setLeftAnchor(losung2, 10.0);
            AnchorPane.setBottomAnchor(losung2, 60.0);
            losung2.setStyle("-fx-background-color: #BDBDBD;");


            //--------------------------------------------------------

            //Labels

            //Eingabelabel
            eingabelabel = new Label("Bitte hier Text eingeben");
            AnchorPane.setTopAnchor(eingabelabel, 1.0);
            eingabelabel.setStyle("-fx-text-fill: #FFFFFF;");

            //Label für Losung 1
            label1 = new Label("Losung 1:");
            AnchorPane.setLeftAnchor(label1, 9.0);
            AnchorPane.setBottomAnchor(label1, 90.0);
            label1.setStyle("-fx-text-fill: #FFFFFF;");

            //Label für Losung 2
            label2 = new Label("Losung 2: (Only Würfel)");
            AnchorPane.setLeftAnchor(label2, 9.0);
            AnchorPane.setBottomAnchor(label2, 40.0);
            label2.setStyle("-fx-text-fill: #FFFFFF;");

            //--------------------------------------------------------

            //ComboBox

            auswahl = new ComboBox<>();
            ObservableList<String> items = FXCollections.observableArrayList("Ceaser", "Würfel");
            auswahl.setItems(items);
            auswahl.setPromptText("Codierungsart: ");

            AnchorPane.setBottomAnchor(auswahl, 60.0);
            AnchorPane.setRightAnchor(auswahl, 200.0);
            auswahl.setMaxHeight(30);
            auswahl.setPrefWidth(200);

            //--------------------------------------------------------

            //Info bezüglich der ComoBox
            info = new Alert(Alert.AlertType.INFORMATION);
            info.setHeaderText("Vorm eintragen, bitte eine Codierung auswählen");
            info.show();


            //--------------------------------------------------------

            root.getChildren().addAll(
                    codierer, decodierer,
                    eingabetext, losung1, losung2
                    ,eingabelabel, label1, label2,
                    auswahl
            );

        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void handle(ActionEvent event) {

        String klartext = eingabetext.getText();
        String lwuerfel1 = losung1.getText();
        String lwuerfel2 = losung2.getText();
        wuerfel1.setzeLosung(lwuerfel1);

        if(event.getSource() == codierer && auswahl.getSelectionModel().isSelected(1)){
            if(klartext.matches("[a-zA-Z]")) {
                eingabetext.setText(wuerfel1.kodiere((klartext)));
                klartext = eingabetext.getText();
            }
            if(lwuerfel2.equals("[a-zA-Z]")){
                wuerfel2.setzeLosung(lwuerfel2);
                eingabetext.setText(wuerfel2.kodiere(klartext));
            }
        }
    }


    //Main Methode, die alles startet
    public static void main(String[] args) {

        launch(args);

    }
}


//-----------------------------------------------------------------

package pis.hue;

import java.lang.StringBuilder;

public class Wuerfel implements Codec {

    private String schluessel;
    private int[] verschluessler;
    private StringBuilder sb;

    public Wuerfel(String schluessel) {
        this.schluessel = schluessel;
        sb = new StringBuilder();

        berechnenVers();
    }

    public Wuerfel() {

    }

    private void berechnenVers() {

        int counter = 0;
        verschluessler = new int[this.schluessel.length()];

        for (char c = 'a'; c <= 'z'; c++) {
            for (int i = 0; i < verschluessler.length; i++) {
                if (this.schluessel.charAt(i) == c || this.schluessel.charAt(i) == (c - 32)) {
                    counter++;
                }
            }
        }
    }


    @Override
    public String kodiere(String klartext) {
        int index = 0;
        String newString = "";
        String parts[];

        parts = new String[klartext.length() / this.schluessel.length() + 1];

        for (int i = 0; i < parts.length - 1; i++) {
            parts[i] = klartext.substring(index, index + this.schluessel.length());
            index += this.schluessel.length();
        }

        parts[parts.length - 1] = klartext.substring(index, klartext.toString().length());

        for (int i = 0; i < verschluessler.length; i++) {
            for (int j = 0; j < verschluessler.length; j++) {
                if (verschluessler[j] != i) {
                    continue;
                }

                for (int s = 0; s < parts.length; s++) {
                    if (parts[s].length() - 1 < j) {

                    } else {
                        newString += parts[s].charAt(j);
                    }
                }
            }
        }
        return newString;
    }

    @Override
    public String dekodiere(String geheimtext) {
        int index = 0;
        char[][] zeichen = new char[verschluessler.length][geheimtext.length() / this.schluessel.length()];
        int helper = geheimtext.length() % this.verschluessler.length;

        for (int i = 0; i < helper; i++) {
            zeichen[i] = new char[zeichen[i].length + 1];
        }

        String newString = "";

        for (int i = 0; i < verschluessler.length; i++) {
            for (int j = 0; j < verschluessler.length; j++) {
                if (verschluessler[j] != i)
                    continue;

                    for(int k = 0; k < zeichen[j].length; k++){
                        zeichen[j][k] = geheimtext.charAt(index);
                        index++;
                    }
            }
        }

        for (int i = 0; i < zeichen[zeichen.length - 1].length; i++) {
            for (int j = 0; j < zeichen.length; j++) {
                newString += zeichen[j][i];
            }
        }

        for (int i = 0; i < helper; i++) {
            newString += zeichen[i][zeichen[i].length - 1];
        }
        return newString;
    }

    @Override
    public String gibLosung() {
        return schluessel;
    }

    @Override
    public void setzeLosung(String schluessel) throws IllegalArgumentException {
        try {
            if (!schluessel.matches("[a-zA-Z]+") || schluessel.isBlank())
                throw new IllegalArgumentException("Nur Buchstaben von a-z und A-Z");
            else
                this.schluessel = schluessel;
            berechnenVers();
        } catch (IllegalArgumentException error) {
            System.out.println(error);
        }
    }

}