Java Lösung

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

class caesar extends JFrame {

    public caesar() {
        // Fenstertitel setzen
        super("Caesar Verschlüsselung");
        // gui initiallisieren (zur besseren Lesbarkeit ausgelagert)
        init_gui();
    }

    public static void main(String[] args) {
        new caesar();
    }

    private String encode(String in, int shift) {
        /*
         * Die entscheidende Methode des Programms, die alle Buchstaben zwischen
         * a-z und A-Z um [shift] Stellen in der ascii-Tabelle zirkulär
         * verschiebt.
         *
         * Die für die Verschlüsselung wichtigen Randbereiche: 65 A 90 Z 97 a
         * 122 z
         */

        // um es zu vereinfachen, wird immer in eine Richtung verschoben
        // auch bei negantivem [shift] (dies ist durch die Kreisbewegung
        // möglich)
        if (shift < 0)
            shift += 26;

        // Variable zum Speichern des Ausgabestrings
        String out = "";

        // Zwischenvariable für die ascii Nummer eines jeden Buchstabens
        int c;

        // Zählschleife über alle Zeichen des Strings
        for (int i = 0; i < in.length(); i++) {
            // mit dieser Methode bekommt man die ascii-Zahl
            // des Buchstaben an der übergebenen Stelle im String
            c = in.codePointAt(i);

            // wenn die ascii-Zahl im zu codierenden Bereich liegt (vgl. oben),
            // wird der Abstand zum Grundwert (ascii-Zahl von a bzw. A) um
            // [shift]
            // erhöht. Durch den Modulo-operator wird sichergestellt, dass nach
            // z/Z
            // wieder a/A kommt.

            // Großbuchstaben
            if (c >= 65 && c <= 90)
                c = 65 + (c - 65 + shift) % 26;
            // Kleinbuchstaben
            if (c >= 97 && c <= 122)
                c = 97 + (c - 97 + shift) % 26;

            // nun wird die (evtl.) codierte ascii-Zahl wieder in einen
            // Buchstaben
            // umgewandelt und an den Ausgabestring angehängt.
            out += (char) c;
        }
        // Der Ausgabestring wird ausgegeben
        return out;

    }

    private void encode() {
        // Wrapper um encode mit den Werten von `textarea` und `spinMod`
        // als Parameter aufzurufen und das Ergebnis gleich zurück in
        // `textarea` zu schreiben
        textarea.setText(encode(textarea.getText(), spinMod.getNumber()
                .intValue()));
    }

    // zwei Buttons zum codieren und leeren des Textfeldes
    private JButton printButton, delButton;

    // ein Panel zur Gruppierung von Spin mit Label und Buttons
    private JPanel buttonPanel;

    // zwei Labels, eins als Überschrifft und eins für die [shift]-Eingabe
    private JLabel label, spinlab;

    // das Textfeld, in das der zu codierende Text eigebeben und der
    // codierte Text herauskopiert werden kann.
    private JTextArea textarea;

    // Um sich nicht um die Validierung des [shift]-Inputs kümmern zu
    // müssen, wird ein `JSpinner` zur Kontrolle eines `SpinnerNumberModel`s
    // genutzt, das dies übernimmt


    private JSpinner spin;

    private SpinnerNumberModel spinMod;

    private void init_gui() {
        // Aufbau der GUI

        // Programm mit GUI schließen
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Layout festlegen
        getContentPane().setLayout(new BorderLayout());

        // Label für Überschrifft erzeugen und auf die ContentPane legen
        label = new JLabel(
                "<html>Caesar Verschlüsselung by Julian Habrock<br><hr>"
                        + "<small>--->Es werden nur Klein- und Großbuchstaben von <em>aA - zZ</em> verschlüsselt!&lt;---<br>"
                        + "----------->Zum Decodieren mit negativem <em>shift</em> codieren!&lt;---------------</small></html>");
        getContentPane().add(label, BorderLayout.NORTH);

        // Textfeld erzeugen, mit einem Testtext füllen und auf CP. legen
        textarea = new JTextArea(10, 20);
        textarea.setText("Dies ist ein Testtext!\n" + "");
        getContentPane().add(textarea);

        // Spin erzeugen - Es wird die Eingabe von Zahlen von -26 bis 26
        // erlaubt (die Grenzzahlen sind mit 0 gleichzusetzen und wirkungslos),
        // der Startwert ist 1, ebenso die Schrittweite.
        spinMod = new SpinnerNumberModel(1, -26, 26, 1);
        spin = new JSpinner(spinMod);

        // `printButton` erzeugen und über einen annonymen ActionListener
        // mit der encode-Wrapperfunktion verknüpfen
        printButton = new JButton("codieren");
        printButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                encode();
            }
        });
        // Button zum Leeren des Textfelds erzeugen und ebenfalls direkt
        // mit einem ActionListener verknüpfen
        delButton = new JButton("leeren");
        delButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                textarea.setText("");
            }
        });
        // Label für [shift] Auswahl
        spinlab = new JLabel("shift:");

        // `buttonPannel` erzeugen und "beladen"
        buttonPanel = new JPanel();
        buttonPanel.add(spinlab);
        buttonPanel.add(spin);
        buttonPanel.add(printButton);
        buttonPanel.add(delButton);

        // `buttonPanel` auf die ContentPane legen
        getContentPane().add(buttonPanel, BorderLayout.SOUTH);

        // finales pack und setVisible
        pack();
        setVisible(true);
    }
}
tags: Java & Programmieren erstellt am 2.12.2008 20:29, zuletzt gendert am 2.12.2008 20:33