Klasse Optimierung

[Generic1]

Hallo,

ich habe jetzt eine Klasse geschrieben, welche aus der Konsole einen Pin einließt, der Pin hat immer 6 Stellen.
Wenn man zwischen 2 Pineingaben länger als 5s wartet, wird der Buffer sb gelöscht.

Meine Frage wäre jetzt ob wer Fehler bzw. Optimierungen sieht (außer das ich statt den chars 0-9 auch default nehmen könnte)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    KeyThread kt;

    public Main() throws IOException {
        kt = new KeyThread();
        kt.setState(false);
        kt.setWait(5000);
        kt.start();

        final InputStreamReader isr = new InputStreamReader(System.in);
        final BufferedReader br = new BufferedReader(isr);
        String s = "";
        while((s = br.readLine()) != null) {
            handlePinpadKey(s.charAt(0));
            }
        }

    Thread th = null;
    final StringBuffer sb = new StringBuffer();
    private void handlePinpadKey(final char key) {
        switch(key) {
            case 'c':
            case 'e':
                kt.setState(true);
                sb.delete(0, sb.length());
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                kt.setState(false);
                if(sb.length() < 5) {
                    sb.append(key);
                    kt.setState(true);
                    kt.setWait(5000);
                    }
                else {
                    sb.append(key);
                    System.out.println("Pin else: " + sb);
                    sb.delete(0, sb.length());
                    }
                break;
            default:
                System.out.println(key + " nicht gültig");
            }
        }

    private void deleteKeys() {
        sb.delete(0, sb.length());
        System.out.println("Keys wurden gelöscht");
        }

    private final class KeyThread extends Thread {

        private boolean state;
        private long wait;

        public KeyThread() {}

        @Override
        public void run() {
            while(true) {
                if(state && wait < System.currentTimeMillis()) {
                    state = false;
                    deleteKeys();
                    }
                try {
                    Thread.sleep(1000);
                    }
                catch (InterruptedException ex) {
                    System.out.println("asdfd");
                    }
                }
            }
        
        public void setState(final boolean state) {
            this.state = state;
            }
        
        public void setWait(final int wait) {
            this.wait = System.currentTimeMillis() + wait;
            }
        }

    public static void main(String[] args) throws IOException {
        new Main();
        }
}

 

[Camill]

[JAVA=9] public Main() throws IOException {[/code]
[JAVA=82] System.out.println("asdfd");[/code]
[JAVA=96] public static void main(String[] args) throws IOException {[/code]

Das kann man sicherlich noch verbessern 😉

 

[Marcinek]

Ich starte das Program und weiß nicht, was ich machen soll.

Dann will ich es beenden und weiß auch nicht wie das geht.

Und

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 0
	at java.lang.String.charAt(Unknown Source)
	at Main.<init>(Main.java:19)
	at Main.main(Main.java:97)

Gruß,

Martin

 

[Final_Striker]

Nicht das ganze Programm in den Konstruktor rein quetschen und ordentliche Variablennamen vergeben.

 

[Generic1]

So Verbesserung, Vielleicht kann der eine oder andere nochmal drüberschaun ob man nicht noch was optimieren/kompakter machen könnte.
lg

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public final class Main {

    private static final int WAITFOR_KEY;
    private final StringBuffer sb;
    private KeyThread kt;

    static {
        WAITFOR_KEY = 5000;
        }

    public Main() throws IOException {
        sb = new StringBuffer();
        handleKeys();
        }

    private void handleKeys() throws IOException {
        kt = new KeyThread();
        kt.setState(false, 0);
        kt.start();

        System.out.println("Nacheinander Keys eingeben und Enter drücken. Mit \"Ende\" programm beenden. \nWenn zwischen 2 Eingaben eine Zeit länger als 5s vergeht, werden die vorher eingegebenen Keys gelöscht");

        final InputStreamReader isr = new InputStreamReader(System.in);
        final BufferedReader br = new BufferedReader(isr);
        String s = "";
        while((s = br.readLine()) != null) {
            if(s.equalsIgnoreCase("Ende"))
                System.exit(0);
            handlePinpadKey(s.charAt(0));
            }
        }

    private void handlePinpadKey(final char key) {
        switch(key) {
            case 'c':
            case 'e':
                kt.setState(true, WAITFOR_KEY);
                sb.delete(0, sb.length());
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                kt.setState(false, 0);
                if(sb.length() < 5) {
                    sb.append(key);
                    kt.setState(true, WAITFOR_KEY);
                    }
                else {
                    sb.append(key);
                    System.out.println("Pin else: " + sb);
                    sb.delete(0, sb.length());
                    }
                break;
            default:
                System.out.println(key + " nicht gültig");
            }
        }

    private void deleteKeys() {
        System.out.println("Keys " + sb + " gelöscht");
        sb.delete(0, sb.length());
        }

    private final class KeyThread extends Thread {

        private boolean state;
        private long wait;

        public KeyThread() {}

        @Override
        public void run() {
            while(true) {
                if(state && wait < System.currentTimeMillis()) {
                    state = false;
                    deleteKeys();
                    }
                try {
                    Thread.sleep(800);
                    }
                catch (InterruptedException ex) {
                    System.out.println("Exception in class KeyThread in run: " + ex);
                    }
                }
            }
        
        public void setState(final boolean state, final int wait) {
            this.state = state;
            this.wait = System.currentTimeMillis() + wait;
            }
        }

    public static void main(String[] args) throws IOException {
        new Main();
        }
}

 

[xehpuk]

Auf

state

und

wait

wird von mehr als einem Thread zugegriffen, es gibt aber weder Synchronisierung, noch sind sie

volatile

.
Warum wartet der KeyThread immer 800 ms?

 

[Generic1]

die 800ms sind dazu da dass ich nicht die ganze CPU für die Endlosschleife verbrate, Es reicht wenn es ca. 5s sind (also im schlechtesten Fall 5,8s)

Wie würdest du das mit dem wait und synchronized machen?
lg