Timer über Button starten


Julbe

Grünschnabel
#1
Hallo zusammen,
für ein Projekt an der Uni soll ich ein kleines Programm zur schiefen Ebene in Java programmieren.

Soweit funktionieren auch die Berechnungen und die Animation, nur kann ich diese nicht über einen Button starten...

Des weiteren bekomme ich auch keine Werte in meine Animationsklasse, also z.B. den Winkel (Für die anderen Klassen habe ich es immer mit getters&setters gelöst, hier klappt es nicht). Hier zeigt es mit den Fehler "The method setNeigungswinkel(double) is undefined for the type JPanel"

Ich füge mal den code meines Hauptfensters, der Berechnungsklasse und meiner beiden Animationsklassen ein.

Vielleicht hat einer von euch einen Rat, wie ich das lösen kann oder besser aufbauen kann.

Durch die If-Anweisungen beim Button Berechnen sollen Fehlermeldungen angezeigt werden, wenn der Nutzer eine nicht korrekte Eingabe tätigt, die lasse ich mal weg, da es sonst hier zu viel wird.

Hauptfenster:
Java:
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JTextPane;
import javax.swing.ImageIcon;

@SuppressWarnings("serial")
public class GUI_SchiefeEbene extends JFrame {

    private JPanel contentPane;
    private JTextField txtNeigungswinkel;
    private JTextField txtGewicht;
    private JTextField txtReibungskoeffizient;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    GUI_SchiefeEbene frame = new GUI_SchiefeEbene();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public GUI_SchiefeEbene() {
        setTitle("Schiefe Ebene");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 1000, 850);
        setResizable(false);
        setLocationRelativeTo(null);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);
        
        //Felder der Eingabe
        txtNeigungswinkel = new JTextField();
        txtNeigungswinkel.setBounds(230, 150, 141, 32);
        contentPane.add(txtNeigungswinkel);
        txtNeigungswinkel.setColumns(10);
        
        txtGewicht = new JTextField();
        txtGewicht.setBounds(230, 200, 141, 32);
        contentPane.add(txtGewicht);
        txtGewicht.setColumns(10);
        
        txtReibungskoeffizient = new JTextField();
        txtReibungskoeffizient.setBounds(230, 250, 141, 32);
        contentPane.add(txtReibungskoeffizient);
        txtReibungskoeffizient.setColumns(10);
        
        //Beschriftungen für die Eingabefelder
        JLabel lblEingabe = new JLabel("Werteeingabe");
        lblEingabe.setBounds(21, 95, 150, 26);
        contentPane.add(lblEingabe);
        
        JLabel lblNeigungswinkel = new JLabel("Neigungswinkel");
        lblNeigungswinkel.setBounds(21, 150, 159, 26);
        contentPane.add(lblNeigungswinkel);
        
        JLabel lblGewicht = new JLabel("Gewicht");
        lblGewicht.setBounds(21, 200, 92, 26);
        contentPane.add(lblGewicht);
        
        JLabel lblReibungskoeffizient = new JLabel("Reibungskoeffizient");
        lblReibungskoeffizient.setBounds(21, 250, 181, 26);
        contentPane.add(lblReibungskoeffizient);
        
        //Beschriftungen der Ausgabefelder
        JLabel lblWerteausgabe = new JLabel("Werteausgabe");
        lblWerteausgabe.setBounds(21, 305, 181, 26);
        contentPane.add(lblWerteausgabe);
        
        JLabel lblNormalkraft = new JLabel("Normalkraft");
        lblNormalkraft.setBounds(21, 360, 181, 26);
        contentPane.add(lblNormalkraft);
        
        JLabel lblHangabtriebskraft = new JLabel("Hangabtriebskraft");
        lblHangabtriebskraft.setBounds(21, 410, 174, 26);
        contentPane.add(lblHangabtriebskraft);
        
        JLabel lblReibungskraft = new JLabel("Reibungskraft");
        lblReibungskraft.setBounds(21, 460, 181, 26);
        contentPane.add(lblReibungskraft);
        
        JLabel lblBewegungskraft = new JLabel("Beschleunigungskraft");
        lblBewegungskraft.setBounds(21, 510, 207, 26);
        contentPane.add(lblBewegungskraft);
        
        //Felder der Ausgabe
        JTextPane txtNormalkraft = new JTextPane();
        txtNormalkraft.setBounds(230, 360, 141, 32);
        contentPane.add(txtNormalkraft);
        
        JTextPane txtHangabtriebskraft = new JTextPane();
        txtHangabtriebskraft.setBounds(230, 410, 141, 32);
        contentPane.add(txtHangabtriebskraft);
        
        JTextPane txtReibungskraft = new JTextPane();
        txtReibungskraft.setBounds(230, 460, 141, 32);
        contentPane.add(txtReibungskraft);
        
        JTextPane txtBeschleunigungskraft = new JTextPane();
        txtBeschleunigungskraft.setBounds(230, 510, 141, 32);
        contentPane.add(txtBeschleunigungskraft);
        
        //Einheiten der Eingaben
        JLabel lblNeigungswinkelEinheit = new JLabel("\u00B0");
        lblNeigungswinkelEinheit.setBounds(380, 150, 92, 26);
        contentPane.add(lblNeigungswinkelEinheit);
        
        JLabel lblGewichtEinheit = new JLabel("kg");
        lblGewichtEinheit.setBounds(380, 200, 92, 26);
        contentPane.add(lblGewichtEinheit);
        
        //Einheiten der Ausgaben
        JLabel lblNormalkraftEinheit = new JLabel("N");
        lblNormalkraftEinheit.setBounds(380, 360, 92, 26);
        contentPane.add(lblNormalkraftEinheit);
        
        JLabel lblHangabtriebskrafteinheit = new JLabel("N");
        lblHangabtriebskrafteinheit.setBounds(380, 410, 92, 26);
        contentPane.add(lblHangabtriebskrafteinheit);
        
        JLabel lblReibunsgkraftEinheit = new JLabel("N");
        lblReibunsgkraftEinheit.setBounds(380, 460, 92, 26);
        contentPane.add(lblReibunsgkraftEinheit);
        
        JLabel lblBeschleunigungskraftEinheit = new JLabel("N");
        lblBeschleunigungskraftEinheit.setBounds(380, 510, 92, 26);
        contentPane.add(lblBeschleunigungskraftEinheit);
        
        //DHBW LOGO
        JLabel lblDHBWLogo = new JLabel("");
        lblDHBWLogo.setIcon(new ImageIcon("\\\\Mac\\Home\\Documents\\Hochschule\\Informatik\\Projekt Schiefe Ebene\\DHBW Logo.jpeg"));
        
        lblDHBWLogo.setBounds(21, 570, 181, 181);
        contentPane.add(lblDHBWLogo);
        
        //Zeichenpanel, das mit der Klasse draw_Ebene verbunden ist
        JPanel drawEbene = new Ebene();   
        drawEbene.setBounds(525, 60, 400, 703);
        contentPane.add(drawEbene);
        drawEbene.setLayout(null);
        
        JPanel Animation = new Animation();
        Animation.setBounds(0, 0, 400, 703);
        drawEbene.add(Animation);
        Animation.setOpaque(false);
        
        //Button Information, soll die Methode aus der Klasse GUI_Information aufrufen
        JButton btnInformation = new JButton("Information");
        btnInformation.setBounds(21, 25, 159, 35);
        contentPane.add(btnInformation);
        
        //Aufrufen der Methode aus der Klasse GUI_Information
        btnInformation.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                
                GUI_Information guiinformation = new GUI_Information();
                guiinformation.newScreen();
            }
        });
        //Button Berechnen
        JButton btnBerechnen = new JButton("Berechnen");
        btnBerechnen.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent e) {
                
                    //Definition von Hilfsobjekten
                       double EingabeNeigungswinkel;
                    double EingabeGewicht;
                    double EingabeReibungskoeffizient;
                  
                    //Eingabe entegegen nehmen
                    EingabeNeigungswinkel = Double.parseDouble(txtNeigungswinkel.getText());
                    EingabeGewicht = Double.parseDouble(txtGewicht.getText());
                    EingabeReibungskoeffizient = Double.parseDouble(txtReibungskoeffizient.getText());
                    
                    //Reibungskoeffzient mit if-Anweisung auf Richtigkeit prüfen
                    if ( EingabeReibungskoeffizient <= 1 & EingabeReibungskoeffizient >= 0) {
                        
                        //Bedingung erfüllt - Weitergabe der Eingabewerte an Klasse Berechnen
                        Berechnungen.setNeigungswinkel(EingabeNeigungswinkel);
                        Berechnungen.setGewicht(EingabeGewicht);
                        Berechnungen.setReibungskoeffizient(EingabeReibungskoeffizient);
                        
                        //Winkel an Ebene geben
                        Ebene.setNeigungswinkel(EingabeNeigungswinkel);
                        
                    }
                    
                    else {
                        GUI_Warnung_Reibungskoeffizient guiwarnungReibungskoeffizient = new GUI_Warnung_Reibungskoeffizient();
                        guiwarnungReibungskoeffizient.newScreen();
                        
                    }       
                    
                    //Eingabewinkel mit if-Anweisung auf Richtigkeit prüfen
                    if (EingabeNeigungswinkel <= 70 & EingabeNeigungswinkel > 0) {
                        
                            //Bedingung erfüllt - Weitergabe der Eingabewerte an Klasse Berechnen
                            Berechnungen.setNeigungswinkel(EingabeNeigungswinkel);
                            Berechnungen.setGewicht(EingabeGewicht);
                            Berechnungen.setReibungskoeffizient(EingabeReibungskoeffizient);
                            
                            //Winkel an draw_Ebene geben
                            Ebene.setNeigungswinkel(EingabeNeigungswinkel);
                            repaint();//Um erneut zu zeichnen, bei geänderter Eingabe
                                                    
                        }
                        else {
                            GUI_Warnung_Eingabewinkel guiwarnung = new GUI_Warnung_Eingabewinkel();
                            guiwarnung.newScreen();
                        }
                                            
                    //Rundungsformat festlegen     
                    DecimalFormat f = new DecimalFormat("#0.00");
                    
                    //Ausgabe
                    txtHangabtriebskraft.setText(f.format(Berechnungen.getHangabtriebskraft()));
                    txtNormalkraft.setText(f.format(Berechnungen.getNormalkraft()));
                    txtReibungskraft.setText(f.format(Berechnungen.getReibungskraft()));
                    
                    //Prüfen, ob die Beschleunigungskraft > 0 ist.
                    if (Berechnungen.getBeschleunigungskraft() > 0) {
                        
                        txtBeschleunigungskraft.setText(f.format(Berechnungen.getBeschleunigungskraft()));
                        
                    }
                    else {
                        GUI_Warnung_keineBewegung guiwarnungkeineBewegung = new GUI_Warnung_keineBewegung();
                        guiwarnungkeineBewegung.newScreen();
                        
                        txtBeschleunigungskraft.setText(f.format(Berechnungen.getBeschleunigungskraft()));
                    }
                }
        });
        btnBerechnen.setBounds(230, 570, 141, 35);
        contentPane.add(btnBerechnen);
                
        // Button Start startet die Animation auf der schiefen Ebene
        JButton btnStart = new JButton("Start");
        btnStart.setBounds(230, 630, 141, 35);
        contentPane.add(btnStart);
        btnStart.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {         
                
                  double EingabeNeigungswinkel;
                  //Eingabe entegegen nehmen
                  EingabeNeigungswinkel = Double.parseDouble(txtNeigungswinkel.getText());
                  
                  Animation.setNeigungswinkel(EingabeNeigungswinkel);
                  Animation.setBeschleunigungskraft(Berechnungen.getBeschleunigungskraft());
                
                  repaint();
                                
              }
        });
        
        //Button Abbruch - schließt das Fenster
        JButton btnAbbruch = new JButton("Abbruch");
        btnAbbruch.setBounds(230, 690, 141, 35);
        contentPane.add(btnAbbruch);
        btnAbbruch.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
                  System.exit(0);
              }
        });       
    }
}
Berechnungsklasse:

Java:
public class Berechnungen {
    
    //Objekte, aus denen die getters & setters konstruiert wurden
    private static double Neigungswinkel = 0.0;
    private static double Gewicht = 0.0;
    private static double Hangabtriebskraft = 0.0;
    private static double Normalkraft = 0.0;
    private static double Reibungskoeffizient = 0.0;
    private static double Reibungskraft = 0.0;   
    private static double Beschleunigungskraft = 0.0;
    private static double g = 9.81;
    private static double Gewichtskraft = 0.0;
    private static double WinkelinBogenmass = 0.0;
    
    //Alle get Klassen
    public static double getGewichtskraft() {
        return getGewicht() * getG();
    }
    public static double getWinkelinBogenmass() {
        return 2*Math.PI / 360 * getNeigungswinkel();
    }
    public static double getNeigungswinkel() {
        return Neigungswinkel;
    }
    public static double getGewicht() {
        return Gewicht;
    }
    public static double getHangabtriebskraft() {
        return getGewichtskraft() * Math.sin( getWinkelinBogenmass() );
    }
    public static double getNormalkraft() {
        return getGewichtskraft() * Math.cos( getWinkelinBogenmass() );
    }
    public static double getReibungskoeffizient() {
        return Reibungskoeffizient;
    }
    public static double getReibungskraft() {
        return getNormalkraft() * getReibungskoeffizient();
    }
    public static double getBeschleunigungskraft() {
        return getHangabtriebskraft() - getReibungskraft();
    }
    public static double getG() {
        return g;
    }
    
    //Alle set Klassen
    public static void setNeigungswinkel(double α) {
        Neigungswinkel = α;
    }
    public static void setGewicht(double m) {
        Gewicht = m;
    }
    public static void setReibungskoeffizient(double µ) {
        Reibungskoeffizient = µ;
    }
    public static void setG(double g) {
        Berechnungen.g = g;
    }
}
Klasse für die Ebene:

Java:
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JPanel;


public class Ebene extends JPanel {
        
        //getters and setters, um die Werte von der Eingabe zu bekommen
        private static double Neigungswinkel = 45.0; //Anfangswert 45, um am Anfang eine Ebene zu haben
        private static double WinkelinBogenmass = 0.0;
            
        public static double getNeigungswinkel() {
            return Neigungswinkel;
            }
        public static double getWinkelinBogenmass() {
            return (Math.PI / 180) * Neigungswinkel;
            }

        public static void setNeigungswinkel(double α) {
            Neigungswinkel = α;
            }
        public static void setWinkelinBogenmass(double winkelinBogenmass) {
            WinkelinBogenmass = winkelinBogenmass;
            }
                
    public void paintComponent (Graphics g) {       
        
        super.paintComponent(g);
        
        Graphics2D g2d = (Graphics2D) g;
        
        //Für bessere Konturen
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        
        //Farbe aus schwarz festgelegt
        g.setColor(Color.BLACK);
        
        //Zeichendicke festlegen auf 5 Pixel
        ((Graphics2D) g).setStroke(new BasicStroke(5));
            
        //Startwerte für die Ebene
        int x = 50;
        int y = 700;
        int ak = 250; //Länge der Ankatete
        int b = x + 250; //Wert rechts unten am 90 Grad Winkel
            
        //Gegenkatete ausrechnen
        double l = Math.tan(getWinkelinBogenmass()) * ak;
            
        //Umwandlung von double zu int
        int hoehe = (int)Math.round(l);
        int h = 700 - hoehe; //Weil die Höhe von oben ausgehend bestimmt wird.
                    
        //Befehle zum Linienzeichnen
        //Ankatete - länge 250
        g.drawLine( x , y, x + ak, y);
            
        //Gegenkatete
        g.drawLine( b , y, b , h);
            
        //Hypothenuse
        g.drawLine(x , y , b , h);
    
        }
                    
}

Animationsklasse:
Java:
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Animation extends JPanel implements ActionListener {
        
    //getters and setters, um die Werte von der Eingabe zu bekommen
    private static double Neigungswinkel = 45.0;
    private static double Beschleunigungskraft = 1.0;
        
    public static void setBeschleunigungskraft(double b) {
        Beschleunigungskraft = b;
    }
    
    public static void setNeigungswinkel(double α) {
        Neigungswinkel = α;
    }

    double WinkelimBogenmass = (Math.PI / 180) * Neigungswinkel;

    //Fuer die Animation
     
    Timer tm = new Timer(20, this); //20 gibt den sleep für 20 ms an


    double hoehe = Math.round(700 - Math.tan(WinkelimBogenmass) * 250); // 700- da von oben ausgehend
    
    //Schrittweite in y-Richtung als Variable konstruieren
    int bk = (int)Math.round(Beschleunigungskraft);
    int swy = bk;// Schrittweite in y-Richtung
    
    //Schrittweite in x-Richtung
    double schrittweitex = Math.tan(Math.PI/2 - WinkelimBogenmass) * swy;
    int swx = (int)Math.round(schrittweitex);
    
    //Variablen der Höhe und Breite für die Animation konstruieren, Vel gibt die Schrittweite für die Animation an
    int x1 = 300 , Velb = -swx ;
    int y1 = (int)Math.round(hoehe) , Velh = swy;   
    
    //Grösse des Klotzes festlegen
    double b = 30; // Länge der oberen und unteren Seite des Klotzes in Pixel
    double h = 15; // Länge der rechten und linken Seite des Klotzes in Pixel
    
    double x33 = x1 - Math.cos(-WinkelimBogenmass) * b; // - 2 * Winkel, da es nur so wegen dem Koordinatensystem klappt
    double y33 = y1 - Math.sin(-WinkelimBogenmass) * b;
    double x22 = x1 + Math.sin(- WinkelimBogenmass) * h;
    double y22 = y1 - Math.cos(- WinkelimBogenmass) * h;
    double x11 = x22 - Math.cos(WinkelimBogenmass) * b;
    double y11 = y22 - Math.sin(- WinkelimBogenmass) * b;
        
    int y2 = (int)Math.round(y33);
    int x2 = (int)Math.round(x33);
    int x3 = (int)Math.round(x11);
    int y3 = (int)Math.round(y11);
    int x4 = (int)Math.round(x22);
    int y4 = (int)Math.round(y22);
            
public void paintComponent (Graphics g) {   
    
    super.paintComponent(g);
    
    Graphics2D g2d = (Graphics2D) g;
    
    //Für bessere Konturen
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    
    //Farbe aus schwarz festgelegt
    g.setColor(Color.BLACK);
    
    //Zeichendicke festlegen auf 5 Pixel
    ((Graphics2D) g).setStroke(new BasicStroke(5));
    
    //Klotz
        
    //Für bessere Konturen
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    
    //Farbe als schwarz festgelegt
    g.setColor(Color.BLACK);
    
    //Zeichendicke festlegen auf 3 Pixel
    ((Graphics2D) g).setStroke(new BasicStroke(3));
    
    //Untere Gerade
    g.drawLine( x2, y2, x1, y1);
    
    //Obere Gerade
    g.drawLine( x3, y3, x4, y4);
    
    //Rechte Gerade
    g.drawLine( x1, y1, x4, y4);
    
    //Linke Gerade
    g.drawLine( x2, y2, x3, y3);
    
    tm.start();
    
    if (y1 > 700) {
        
        tm.stop();
                                
    }
}

 public void actionPerformed(ActionEvent e) {
                
    x1 = x1 + Velb;
    y1 = y1 + Velh;
    x2 = x2 + Velb;
    y3 = y3 + Velh;
    y2 = y2 + Velh;
    x4 = x4 + Velb;
    y4 = y4 + Velh;
    x3 = x3 + Velb;
    repaint();               
    
     }   
}
 

Neue Beiträge