eine Schleife zeitlich begrenzt ausführen

lupal11

Grünschnabel
Hi ihr und danke jetzt schon für eure Hilfe.

Ich versuche gerade (ein klein wenig verzweifelt) eine Schleife zu programmieren, die nach einer bestimmten Zeit abgebrochen wird.
Der Befehl innerhalb der Schleife soll sich alle 1000 ms (bzw. 1s) so lange wiederholen, bis ein Countdown von 10 Sekunden abgelaufen ist.
Da ich bisher größtenteils eigentlich ausschließlich mit niedrigeren Sprachen programmiert habe, macht mir Java da echt zu schaffen.

Der Quelltext (bisher ziemlicher Mi**) sieht so aus:
Code:
public class ktest
{
    private int timer;
    private int a;
    private int d;
    private int m;
    private int g;
    private kalkminus a;
    public kerneltest ()
    {
        timer = 10;
        addipunkte = 0;
        divipunkte = 0;
        multipunkte = 0;
        gespunkte = 0;
    }
    
    public int testStart()
    {
        import java.util.*
        /**
         * Hier muss noch eine Sprungmarke hinein!
         */
        
        a= 0;
        timer = 10;
        //Countdown startet
        Timer timer = new Timer();
        timer.schedule(a.kminus(),0,1000);
        
       /*   
        * if (timer > 0) {
        * a= a+ 1;
        * goto Sprungmarke
        * }
        * else 
        */
       /**
        * Sprung zur nächsthöheren Sprungmarke
        */
       
       
       divipunkte = 10000;
       
       timer = 10;
       /*
        * if (timer > 0){
        *     d= d - 1;
        *     goto Sprungmarke
        *     }
        *     else
        */
       /**
        * Sprung zur nächsthöheren Sprungmarke
        */
       
       
       multipunkte = 0;
       
       timer = 10;
       /*
        * if (timer > 0){
        *     m = m * 2;
        *     goto Sprungmarke
        *     }
        *     else
        */
       /**
        * Sprung zur nächsthöheren Sprungmarke
        */
       
       g= a+ ( 10000 - d) + m;
       return g;
       
       
    }
}

Die zweite Klasse (kalkminus), die den Countdown beinhalten sollte sieht so aus:
Code:
public class kalkminus
{
    // Instanzvariablen - ersetzen Sie das folgende Beispiel mit Ihren Variablen
    private int tkalk;

    /**
     * Konstruktor für Objekte der Klasse kalkminus
     */
    public kalkminus()
    {
        // Instanzvariable initialisieren
        this.tkalk = tkalk;
    }

    /**
     * Ein Beispiel einer Methode - ersetzen Sie diesen Kommentar mit Ihrem eigenen
     * 
     * @param  y    ein Beispielparameter für eine Methode
     * @return        die Summe aus x und y
     */
    public void kminus()
    {
        tkalk = tkalk - 1;
    }
}

Mir ist es auch sehr recht, wenn am Ende alles in einer Klasse funktioniert.
Vielen Dank hier (noch einmal) für eure Hilfe
 

sheel

I love Asm
Hi und Willkommen bei tutorials.de,

Muss das Programm während der Wartezeit was anderes machen
bzw. auf Benutzereingaben reagieren können?
Nein? Dann Thread.sleep(1000); ?
Eine Schleife, die bis 10 zählt, herum, dazu den anderen Code und fertig.
Kommt am Nähesten an zB. sleep aus C heran.
 

ikosaeder

Teekannen-Agnostiker
Kein Goto verwenden! Was du brauchst ist eine while Schleife. Vielleicht mal ein Javabuch nehmen und nachlesen.
 

sheel

I love Asm
Wenn man den Code so anschaut...
if, goto, "Sprung zur nächsthöheren Sprungmarke"...
wo sind die Adressenoffsets und Asm-Befehle :suspekt:
Wusste gar nicht, dass es goto in Java gibt (oder vergessen)...

Stichworte while, for; eventuell auch break, continue...
...oder gleich die ganze Javainsel lesen.
 

lupal11

Grünschnabel
Ich danke euch. (Die Javainsel ist beim Buchhändler schon bestellt (lag gerade auf dem Weg). Mir wurde von vieler Seite schon gesagt, dass die sehr zu empfehlen ist.)

goto Befehle gibt es (leider) nicht.

Die Frage für mich ist es halt, wie ich es schaffe, dass der Countdown ohne Berücksichtigung des restlichen Programmtextes einfach weiter runterzählt.
Das Problem ist: Die Addition soll laufen, während der Countdown kontinuierlich kürzer wird.

Danke für eure bisherige Hilfe.
 

youza

Erfahrenes Mitglied
hi hatte grad a bissal Zeit und hab dir mal nen Timer geschrieben ;)

Die Klasse Timer:
Java:
package com.youza.test;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;


//Die Klasse erbt von JFrame (Fenster von Swing) und hat das Interface ActionListener
//welches eine Actionevent abfangen kann welches Beispielsweise aufgerufen wird wenn 
//eine Schaltfläche betätigt wird
public class Timer extends JFrame implements ActionListener {
	/**
	 * 
	 */
	private static final long serialVersionUID = 9146652505139821149L;

	//Bereich zur eingabe der der Zeit
	private JPanel jp_input = new JPanel();
	private JTextField jtf_hour = new JTextField();
	private JTextField jtf_minute = new JTextField();
	private JTextField jtf_second = new JTextField();
	
	//Bereich für die Schaltfläche
	private JPanel jp_button = new JPanel();
	private JButton jb_countdown = new JButton("Start");
	
	//Bereich zum Ausgeben der der aktuellen zeit
	private JLabel jl_show_time = new JLabel();
	

	public Timer() {
		//In diesem Bereich werden die Eigenschaften für das Fenster gesetzt
		//legt fest das beim betätigen der X-Schaltfläche wirklich beendet werden soll
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		//Festlegen des äußeren Layoutmanager (3-Reihen (input/Button/Output), 1-Spalte)
		this.setLayout(new GridLayout(3,1));
		
		//Aufruf der Methoden zum initialisieren der JPanels
		init_jp_input();
		init_jp_button();
		init_jl_show_time();
		
		//Titel des Fensters
		this.setTitle("Timer");

		//Hinzufügen der Bereiche zum Fenster
		this.add(jp_input);
		this.add(jp_button);
		this.add(jl_show_time);
		
		//Festelegen der Fenstergröße
		this.setSize(300,200);
		
		//Sichtbar keit des Fensters auf wahr setzten
		this.setVisible(true);
	}
	
	//Initialisierung des input panels
	private void init_jp_input(){
		jp_input.setLayout(new GridLayout(1,3));
		jp_input.add(jtf_hour);
		jp_input.add(jtf_minute);
		jp_input.add(jtf_second);
	}
	
	//Initialisierung des button panels
	private void init_jp_button(){	
		jb_countdown.addActionListener(this);
		jp_button.add(jb_countdown);
	}
	
	//Initialisierung der Ausgabe
	private void init_jl_show_time(){
		
		//Festlegen, dass die schrift in der Mitte stehen soll
		jl_show_time.setVerticalAlignment(JLabel.CENTER);
		jl_show_time.setHorizontalAlignment(JLabel.CENTER);
		
		//Festlegen der Schrift
		jl_show_time.setFont(new Font("Serif", Font.BOLD, 34));
		
		//Aufrufen der Funktion zum setzten des Outputs
		setJl_show_time(0);
	}
	
	//Startpunkt des Programmes
	public static void main(String[] args) {
		//Aufrufen der Timerklasse
		new Timer();
	}
	
	//Funktion zum setzten des Output Panels
	public void setJl_show_time(int seconds){
		
		//Berechnen der Bestandteile
		int hours;
		int minutes; 
		hours = seconds/(60*60);
		seconds = seconds - hours*60*60;
		minutes = seconds/60;
		seconds = seconds - minutes*60;
		
		//Setzten des Label Textes
		jl_show_time.setText(checkValue(hours)+":"+checkValue(minutes)+":"+checkValue(seconds));
	}
	
	//Hilfsfunktion zur besseren Anzeige des Label Textes
	private String checkValue(int x){
		if(x<10)
			return "0" + x;
		return String.valueOf(x);
	}
	
	//Berechnung der Sekunden aus den Textfeldern
	private int calculateSeconds(){
		int seconds = 0;
		//Abfrage ob das Textfeld leer ist
		if(!jtf_hour.getText().isEmpty())
			seconds = Integer.parseInt(jtf_hour.getText())*60*60;
		if(!jtf_minute.getText().isEmpty())
			seconds = seconds + Integer.parseInt(jtf_minute.getText())*60;
		if(!jtf_second.getText().isEmpty())
			seconds = seconds + Integer.parseInt(jtf_second.getText());
		return seconds;
	}
	@Override
	public void actionPerformed(ActionEvent arg0) {		
		
		//Methode welche aufgerufen wird beim betätigen der Schaltfläche
		//Neuer Thread um die Zeit herunter zu zählen
		new Thread() {
			@Override
			public void run() {
				int seconds = calculateSeconds();
				//Schläfe zum Runterzählen
				for (int i = seconds; i >= 0; i--) {
					try {
						//Setzen des Label Textes
						setJl_show_time(i);
						//Pausieren für eine Sekunde
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

Viel Spaß mit Java
Youza

Achja ich empfehle dir noch Eclipse runterzuladen erleichtet das entwickeln :)

@Edit:
des Package rauslassen falls du die Klasse ganz normal ausführen willst mit den Packages wird sich dir mit der zeit erschließen wenn du Eclipse benutzt...
 
Zuletzt bearbeitet: