Ideenlos

DerEisige

Erfahrenes Mitglied
Hallo Leute

Ich weiß nicht so recht ob das hier hergehört aber ich habe kein besser passendes Forum gefunden.


Ich bin auf der Suche nach einer Idee für ein Java Projekt in der Schule, das soll kein mega großes Programm werden, es reicht wen das Programm eine kleine GUI, 2-4 Klassen und zirka 300 Zeilen Code hat.

Das dann noch in einem Pflichtenheft dokumentiert reicht schon aus.

Mein Problem ist leider das mich einfach keine Idee habe was das programm tuen soll!


Als Beispiel: ich habe das letzte Mal ein kleine GUI gebastelt auf der Butten mit Tieren waren, bei Aktivierung des Battens würde dann ein Geräusch abgespielt (Kuh = Muhen, Hahn = Krähen…)



Nun hoffe ich auf konstruktive Anregungen von euch

Mfg. derEisige
 

Technipion

Erfahrenes Mitglied
Hallo DerEisige,
als mein Bruder noch in die Schule ging (hat mittlerweile Abi) musste er auch solche Aufgaben bearbeiten. Da er kein Java konnte haben wir dann die Programme immer zusammen ausgetüftelt. Ich kann mich sehr gut an ein (gelungenes) Projekt erinnern, bei dem er die Polybios-Chiffre implementiert hat.
Siehe hierzu auch http://de.wikipedia.org/wiki/Polybios.
Unser Programm sah damals so aus, dass wir eine Eingabezeile hatten. Dort konnte man einen beliebigen Text eingeben (mittels Enter). Die Eingabe wurde dann auf ihre Gültigkeit geprüft. Neben der Eingabezeile war eine Tabelle zu sehen - die aktuelle Chiffre. Durch Radiobuttons am rechten Rand des Programms konnten verschiedene Chiffren gewählt werden.
Der eingegebene Text wurde ggf. gekürzt (damit er gültig wurde) und dann mittels der Chiffre verschlüsselt. Die Ausgabe war ganz unten in der Ausgabezeile zu sehen.
Insgesamt implementierten wir einen "normal"-Modus, einen Modus in dem die Chiffre rückwärts geordnet war, einen Modus in dem die Chiffre transponiert war (da sie ja eine Matrix ist) und einen Modus in dem sie sowohl rückwärts, als auch transponiert war.
Ich schätze mal, das war ein ganz gelungenes kleines "Projekt" :D.
Falls du dich entscheiden solltest auch solch ein Programm zu schreiben, habe ich dir als Anregung/Hilfestellung mal unseren damaligen Code hier reingepackt. Du weißt sicherlich, dass deine Lehrer Suchmaschinen benutzen, also Abschreiben ist nicht ;).
Der Code ist übrigens nicht hochprofessionell, mein Bruder wollte es "realistisch" aussehen lassen...

Java:
/*
Polybios Chiffre - Schulprojekt
*/

import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Random;


public class polybios extends javax.swing.JFrame implements ActionListener {
   
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                polybios inst = new polybios();
                inst.setLocationRelativeTo(null);
                inst.setVisible(true);
            }
        });
    }
   
    public polybios() {
        super();
        initGUI();
    }
   
    private void initGUI() {
        try {
            setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            setSize(610, 520);
            setResizable(false);
            this.setLayout(null); // set to AbsoluteLayout
            setTitle("Polybios-Chiffre");
            createForm();
        } catch (Exception e) {
            CharArrayWriter cw = new CharArrayWriter();
            PrintWriter pw = new PrintWriter(cw);
            e.printStackTrace(pw);
            pw.close();
            JOptionPane.showMessageDialog(null, cw.toString(),
                "Ein Error ist aufgetreten!", JOptionPane.NO_OPTION);
            System.exit(1);
        }
    }
   
    private void createForm() {
        createInputAndOutputLine();
        createButtonGroup();
        createDrawTable();
    }

    private void createInputAndOutputLine() {
        jInputLine = new JTextField();
        jOutputLine = new JTextField();
        jInputLineLabel = new JLabel("Eingabe");
        jOutputLineLabel = new JLabel("Ausgabe");

        getContentPane().add(jInputLine);
        getContentPane().add(jOutputLine);
        getContentPane().add(jInputLineLabel);
        getContentPane().add(jOutputLineLabel);

        jInputLine.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
        jOutputLine.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));

        jInputLine.setLocation      (30, 370);
        jOutputLine.setLocation     (30, 430);
        jInputLineLabel.setLocation (30, 350);
        jOutputLineLabel.setLocation(30, 410);
        jInputLine.setSize          (550, 30);
        jOutputLine.setSize         (550, 30);
        jInputLineLabel.setSize     (550, 20);
        jOutputLineLabel.setSize    (550, 20);

        jInputLine.addActionListener(this);
        jInputLine.setActionCommand(ActionTranslate);

        jOutputLine.setEditable(false);
    }

    private void createButtonGroup() {
        jRButtonNormal = new JRadioButton("Normal");
        jRButtonTransposed = new JRadioButton("Transponiert");
        jRButtonReverse = new JRadioButton("Rückwärts");
        jRButtonRandom = new JRadioButton("Zufällig");
        jRButtonReverseAndTransposed = new JRadioButton("Rückwärts und Transponiert");

        getContentPane().add(jRButtonNormal);
        getContentPane().add(jRButtonTransposed);
        getContentPane().add(jRButtonReverse);
        getContentPane().add(jRButtonRandom);
        getContentPane().add(jRButtonReverseAndTransposed);

        jRButtonNormal.setActionCommand(ModeNormal);
        jRButtonTransposed.setActionCommand(ModeTransposed);
        jRButtonReverse.setActionCommand(ModeReverse);
        jRButtonRandom.setActionCommand(ModeRandom);
        jRButtonReverseAndTransposed.setActionCommand(ModeReverseAndTransposed);

        jRButtonNormal.addActionListener(this);
        jRButtonTransposed.addActionListener(this);
        jRButtonReverse.addActionListener(this);
        jRButtonRandom.addActionListener(this);
        jRButtonReverseAndTransposed.addActionListener(this);

        jRButtonNormal.setLocation              (360, 70);
        jRButtonTransposed.setLocation          (360, 120);
        jRButtonReverse.setLocation             (360, 170);
        jRButtonRandom.setLocation              (360, 270);
        jRButtonReverseAndTransposed.setLocation(360, 220);
        jRButtonNormal.setSize                  (230, 30);
        jRButtonTransposed.setSize              (230, 30);
        jRButtonReverse.setSize                 (230, 30);
        jRButtonRandom.setSize                  (230, 30);
        jRButtonReverseAndTransposed.setSize    (230, 30);

        ButtonGroup ModeGroup = new ButtonGroup();
        ModeGroup.add(jRButtonNormal);
        ModeGroup.add(jRButtonTransposed);
        ModeGroup.add(jRButtonReverse);
        ModeGroup.add(jRButtonRandom);
        ModeGroup.add(jRButtonReverseAndTransposed);

        currentMode = ModeNormal;
        jRButtonNormal.setSelected(true);
    }

    private void createDrawTable() {
        jDrawTable = new JDrawMatrix();
        getContentPane().add(jDrawTable);
        jDrawTable.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
        jDrawTable.setLocation(30, 30);
        jDrawTable.setSize(300, 300);
        actualizeTranslation(); // first setup
    }

    private class JDrawMatrix extends JPanel {
       
        public JDrawMatrix() {
            setPreferredSize(new Dimension(300, 300));
        }
       
        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
           
            g.setFont(tableFont);
           
            for (int y = 1; y < 6; y++) {
                g.drawLine(0, 50 * y, 300, 50 * y);
                drawStringCentered(g, Integer.toString(y), 1, y + 1);
            }
            for (int x = 1; x < 6; x++) {
                g.drawLine(50 * x, 0, 50 * x, 300);
                drawStringCentered(g, Integer.toString(x), x + 1, 1);
            }
           
            if (alphabet != null) { // prevent nullptr exception
                int counter = 0;
                for (int y = 1; y < 6; y++) {
                    for (int x = 1; x < 6; x++) {
                        drawStringCentered(g, "" + alphabet.charAt(counter), x + 1, y + 1);
                        counter++;
                    }
                }
            }
        }
       
        private void drawStringCentered(Graphics g, String s, int column, int row) {
            double stringWidth = g.getFontMetrics().getStringBounds(s, g).getWidth();
            double stringHeight = g.getFontMetrics().getStringBounds(s, g).getHeight();
            double posX = (50 - stringWidth) / 2;
            double posY = (50 - stringHeight) / 2 + g.getFontMetrics().getAscent();
            g.drawString(s, (int)(posX + 50 * column - 50), (int)(posY + 50 * row - 50));
        }
       
        public void changeAlphabet(String newAlphabet) {
            alphabet = newAlphabet;
            this.repaint();
        }
       
        private Font tableFont = new Font("Verdana", Font.BOLD, 30);
        private String alphabet = null;
    }
   
    public void actionPerformed(ActionEvent e) {
        switch(e.getActionCommand()) {
            case ActionTranslate:
                translateEnteredText();
                break;
            case ModeNormal:
                currentMode = ModeNormal;
                actualizeTranslation();
                break;
            case ModeTransposed:
                currentMode = ModeTransposed;
                actualizeTranslation();
                break;
            case ModeReverse:
                currentMode = ModeReverse;
                actualizeTranslation();
                break;
            case ModeRandom:
                currentMode = ModeRandom;
                actualizeTranslation();
                break;
            case ModeReverseAndTransposed:
                currentMode = ModeReverseAndTransposed;
                actualizeTranslation();
                break;
            }
    }

    private void actualizeTranslation() {
        transformAlphabet();
        jDrawTable.changeAlphabet(transformedAlphabet);
        translateEnteredText();
    }
   
    private void transformAlphabet() {
        switch (currentMode) {
            case ModeNormal:
                transformedAlphabet = Alphabet;
                break;
            case ModeTransposed:
                transformedAlphabet = transposedString(Alphabet);
                break;
            case ModeReverse:
                transformedAlphabet = new StringBuilder(Alphabet).reverse().toString();
                break;
            case ModeRandom:
                transformedAlphabet = randomAlphabet(Alphabet, 100);
                break;
            case ModeReverseAndTransposed:
                transformedAlphabet = transposedString(
                    new StringBuilder(Alphabet).reverse().toString());
                break;
        }
    }

    private String transposedString(String specificAlphabet) {
        StringBuffer transposedInputString = new StringBuffer();
        for (int i = 0; i < 24; i++) {
            transposedInputString.append(specificAlphabet.charAt(5 * i % 24));
        }
        transposedInputString.append(specificAlphabet.charAt(specificAlphabet.length() - 1));
        return transposedInputString.toString();
    }

    private String randomAlphabet(String specificPool, int numberOfIterations) {
        int posA, posB;
        char charBuffer;
        StringBuffer randomizedAlphabetBuffer = new StringBuffer(specificPool);
        int upperLimit = specificPool.length() - 1;
        for (int i = 0; i < numberOfIterations; i++) {
            posA = randomInteger(0, upperLimit);
            posB = randomInteger(0, upperLimit);
            // swap operation:
            charBuffer = randomizedAlphabetBuffer.charAt(posB);
            randomizedAlphabetBuffer.setCharAt(posB, randomizedAlphabetBuffer.charAt(posA));
            randomizedAlphabetBuffer.setCharAt(posA, charBuffer);
        }
        return randomizedAlphabetBuffer.toString();
    }
   
    private static int randomInteger(int min, int max) {
        Random randomGenerator = new Random();
        return (int)(randomGenerator.nextInt((max - min) + 1) + min);
    }
   
    private void translateEnteredText() {
        String enteredString = jInputLine.getText().toUpperCase();
        StringBuffer inputStringBuffer = new StringBuffer();
        char currentChar;

        for (int i = 0; i < enteredString.length(); i++) {
            currentChar = enteredString.charAt(i);
            switch (currentChar) {
                case 'Ä':
                    inputStringBuffer.append("AE");
                    break;
                case 'Ö':
                    inputStringBuffer.append("OE");
                    break;
                case 'Ü':
                    inputStringBuffer.append("UE");
                    break;
                case 'ß':
                    inputStringBuffer.append("SS");
                    break;
                case 'J':
                    inputStringBuffer.append("I");
                    break;
                case ' ':
                    break;
                default:
                    inputStringBuffer.append(currentChar);
                    break;
            }
        }
        String inputString = inputStringBuffer.toString();
        jInputLine.setText(inputString); // show what we translated
        boolean faults = false;
        // check if composed of letters (A - Z)
        for (int i = 0; i < inputString.length(); i++) {
            if (Alphabet.indexOf(inputString.charAt(i)) < 0) {
                faults = true;
            }
        }
        if (!faults) { // only letters
            translateTextToNumbers(inputString);
            return;
        }
        // check if composed of numbers (1 - 5)
        if ((inputString.length() % 2) != 0) {
            jOutputLine.setText("Zahlenpaare bestehen aus x- UND y-Koordinaten!");
            return;
        }
        faults = false;
        final String allowedCharacters = "12345";
        for (int i = 0; i < inputString.length(); i++) {
            if (allowedCharacters.indexOf(inputString.charAt(i)) < 0) {
                faults = true;
            }
        }
        if (!faults) { // only numbers
            translateNumbersToText(inputString);
            return;
        }
        jOutputLine.setText("Bitte geben Sie entweder Buchstaben (A - X) oder Zahlenpaare (11 - 55) ein!");
    }
   
    private void translateTextToNumbers(String inputString) {
        StringBuffer translatedInput = new StringBuffer();
        int position, posX, posY;
        for (int i = 0; i < inputString.length(); i++) {
            posX = transformedAlphabet.indexOf(inputString.charAt(i)) % 5 + 1;
            posY = (int)(transformedAlphabet.indexOf(inputString.charAt(i)) / 5) + 1;
            position = posY + 10 * posX;
            translatedInput.append("" + position);
        }
        jOutputLine.setText(translatedInput.toString());
    }
   
    private void translateNumbersToText(String inputString) {
        StringBuffer translatedInput = new StringBuffer();
        String numberStr;
        int position, positionString;
        for (int i = 0; i < inputString.length() / 2; i++) {
            numberStr = "" + inputString.charAt(2 * i) + inputString.charAt(2 * i + 1);
            position = Integer.parseInt(numberStr);
            positionString = 5 * (position % 10 - 1) + (int)(position / 10) - 1;
            translatedInput.append(transformedAlphabet.charAt(positionString));
        }
        jOutputLine.setText(translatedInput.toString());
    }
   
    private JTextField jInputLine;
    private JTextField jOutputLine;

    private JLabel jInputLineLabel;
    private JLabel jOutputLineLabel;

    private JRadioButton jRButtonNormal;
    private JRadioButton jRButtonTransposed;
    private JRadioButton jRButtonReverse;
    private JRadioButton jRButtonRandom;
    private JRadioButton jRButtonReverseAndTransposed;

    private JDrawMatrix jDrawTable;

    private String currentMode;
    private String transformedAlphabet;

    private final String ModeNormal = "Mode=Normal";
    private final String ModeTransposed = "Mode=Transposed";
    private final String ModeReverse = "Mode=Reverse";
    private final String ModeRandom = "Mode=Random";
    private final String ModeReverseAndTransposed = "Mode=ReverseAndTransposed";

    private final String ActionTranslate = "Action=Translate";
   
    private final String Alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ";
}

Es gibt natürlich noch unzählige weitere Ideen, dies sollte nur eine kleine Anregung sein.

Hoffe ich konnte helfen.
Gruß Technipion
 

DerEisige

Erfahrenes Mitglied
Danke für die Antwort Technipion.


Ich habe mir mahl deinen Code angeschaut und ich muss sagen, das mir das Projekt sehr gefällt.
Ich möchte nun etwas ganz ähnliches machen und wollte nun fragen ob es oke ist wenn ich teile deines Codes verwende?
Ich will das Programm in 3 bis 4 Klasen aufteilen, eine kleinere GUI aber nur zwei der fünf Chiffren Anbieten und wenn ich die Zeit habe werde ich auch die Chiffren Tabelle verändern.
 

Technipion

Erfahrenes Mitglied
Hallo DerEisige,
für mich geht das absolut in Ordnung. Ich habe den Code ja extra hochgeladen, damit du dich ggf. davon "inspirieren" lassen kannst :D.
Falls du vor hast, Teile des Codes unverändert zu verwenden, solltest du dies allerdings vorher mit deinem Lehrer/Betreuer besprechen. Niemand ist dir böse, wenn du dir im Internet Inspirationsquellen suchst, aber Code einfach zu kopieren könnte man dir als Fälschung vorwerfen...

Es freut mich, dass dir das Projekt so gefällt. Ich persönlich fand Kryptographie auch schon immer interessant. Falls dich das Thema auch interessiert, kannst du dir ja mal ganz allgemein ein paar klassische Verfahren anschauen: http://de.wikipedia.org/wiki/Kategorie:Klassische_Kryptologie.
Womöglich willst du dann gar nicht mehr die Polybios-Chiffre implementieren, sondern eine ganz andere ;).

Ich drücke dir bei deinem Vorhaben jedenfalls die Daumen, bei Fragen kannst du dich natürlich hier melden.
Grüße Technipion