# Wurfparabel berechnen



## der_benning (27. Mai 2010)

hi ich soll ne wurfparabel der form

f(x)=tan(alpha)*x-g/(2v²*cos²(alpha))*x

und hab jetzt n problem mit den winkeln wi ich die einführe und wie ich generell mit denen umgehe.

das hab ich bis jetzt gemacht:


```
public class main wurfparabel{
      public static void main(String[] args):
       double g = 9.81;
       double v = Double.parseDouble(args[0]);
       double alpha = Double.parseDouble(args[1]);
       double x = Double.parseDouble(args[2]));
       double tangens = Math.tan (Double alpha);
       double cosinus = Math.cos (Double alpha);

      System.out.println("die Wurfparabel enspricht: " + wurf(double g,     	  double v, double aplha, double tangens, double cosinus);
      }
    
      public static double wurf(double g, double v, double alpha, double x){ 
      double ergebnis = ((Math.tan alpha) * x) - g / (2 * v * v * Math.cos alpha * 	 Math.cos alpha) * x * x);
      return ergebnis


      }


}
```

anders krieg ich das nich hin...es wäre ganz nett wenn jmd von euch da mal drüber gucken könnte!

mfg der benning


----------



## eRaaaa (27. Mai 2010)

Ohje, vllt solltest du erstmal noch ein wenig :rtfm:

- Bei Methodenaufrufen den Modifier weglassen, also anstelle von 
	
	
	
	





```
double tangens = Math.tan (Double alpha);
```
 -> 
	
	
	
	





```
double tangens = Math.tan(alpha);
```
Das selbe Spiel bei cosinus und bei dem Methodenaufruf wurf(...)

- Zeile 10: a ) du übergibst dort 5 Werte, die Methode erwartet doch aber nur 4 ?  b) aplha != alpha 
- Zeile 14: da fehlen wohl einige Klammern bei den Methodenaufrufen.. (Bsp.: Math.tan alpha <-- ???:L )

:autsch:


----------



## der_benning (27. Mai 2010)

ja ich bin grade am einsteigen und hab noch nich so wirklich plan davon!


```
public class main wurfparabel{
      public static void main(String[] args):
       double g = 9.81;
       double v = Double.parseDouble(args[0]);
       double alpha = Double.parseDouble(args[1]);
       double x = Double.parseDouble(args[2]));
       double tangens = Math.tan (alpha);
       double cosinus = Math.cos (alpha);

      System.out.println("die Wurfparabel enspricht: " + wurf(double g,     	  double v, double tangens, double cosinus);
      }
    
      public static double wurf(double g, double v, double x, double tanges, double cosinus){ 
      double ergebnis = ((Math.tan alpha) * x) - g / (2 * v * v * (Math.cos alpha) * 	 (Math.cos alpha) * x * x);
      return ergebnis


      }


}
```

so hab ichs jetzt geändert aber es funktioniert immer noch nich
hab jetzt zum testen die werte 

v=10
alpha=45
und
x=10

benutzt

aber bin mir irgendwie unsicher bei dem winkel kann ich den einfach so als "45" eingeben?


----------



## eRaaaa (27. Mai 2010)

der_benning hat gesagt.:


> aber bin mir irgendwie unsicher bei dem winkel kann ich den einfach so als "45" eingeben?



Bevor der Code nicht kompilierbar ist, macht es keinen Sinn sich über Winkel zu unterhalten...lies dir nochmal meinen Post durch und korrigiere alle Fehler !


----------



## der_benning (27. Mai 2010)

da muss ich mich in  ruhe heute abend noch mal dransetzen...ich meld mich heute abend noch mal 


aber trotzdem danke erstmal


----------



## Landei (27. Mai 2010)

Alle Winkelfunktionen in Math nehmen Bogenmaß (Radiant). Kurz den Dreisatz rausgekramt:
winkelRad = winkelGrad*Math.PI/180;
winkelGrad = winkelRad*180/Math.PI;


----------



## der_benning (30. Mai 2010)

hallo ich hab jetz noch mal ca. ne stunde dran gesessen und krieg das ding einfach nicht kompiliert 
und hab keinen plan was ich falsch hab hoffe ihr könnt mir noch mal helfen auch wenn ich totale vollnoob bin! 


```
public class main wurfparabel{
      public static void main(String[] args):
       double g = 9.81;
       double v = Double.parseDouble(args[0]);
       double alpha = Double.parseDouble(args[1]);
       double x = Double.parseDouble(args[2]));
       double tangens = Math.tan(alpha);
       double cosinus = Math.cos(alpha);

      System.out.println("die Wurfparabel enspricht: " + wurf(double g,     	  double v, double x, double tangens, double cosinus);
      }
    
      public static double wurf(double g, double v, double x, double tanges, double cosinus){ 
      double ergebnis = ((tanges) * x) - (g / (2 * v * v * (cosinus) * (cosinus) * x * x));
      return ergebnis


      }


}
```


----------



## ne0n2005 (30. Mai 2010)

[Java]
package kp;
import java.awt.Point;


public class Wurfparabel  { 
	private final double G = 9.81;	//evt nicht final setzten, je nach Verwendungszweck des Programmes

	public Wurfparabel()  {
		System.out.println("Die Kugel, welche mit einer Anfangsgeschwindikeit von 20m/s" +
				" unter einem Winkel von 45° geworfen wird , müsste "+wurfWeite(20,45)+"m weit fliegen.");
		for(int i=0;i<44;i++)  {
			System.out.println("Die Höhe der Kugel beträgt nach "+i+"m "+hoeheBerechnen(20,i,45) +"m");
		}
	}


	/*
	 * Berechnet die Höhe an der Stelle x in Abhängigkeit von dem Abwurfwinkel alpha.
	 */
	public double hoeheBerechnen(double v0, double x, double alpha)  {
		double hoehe;
		alpha = Math.toRadians(alpha);
		hoehe = Math.tan(alpha)*x -(G*x*x)/(2*v0*v0*Math.cos(alpha)*Math.cos(alpha));
		return hoehe;	
	}

	public double wurfWeite(double v0, double alpha)  {
		double weite;
		alpha = Math.toRadians(alpha);
		weite = v0*v0*Math.sin(2*alpha)/G;
		return weite;
	}





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


[/Java]


So in etwa könnte eine Grundlage für dein Programm aussehen.
Nun ist aber die Frage, was du mit deinem Programm berechnen willst. Du könntest dich z.B. für Geschwindigkeiten zu bestimmten Zeitpunkten interessieren oder ausrechnen lassen, wie nah dein Objekt an einer gewissen Koordinate vorbeifliegt.

Wichtig ist nur, dass du bedenkst das die Frigonometrischen-Funktionen (wie z.B. Math.sin) Winkel im Bogenmaß erwarten.


Wie mir scheint bist du in Java oder Programmierung allgemein noch sehr unerfahren, von daher würde ich dir raten ersteinmal versuchen mein Beispielprogramm zu verstehen. Falls du zu irgendwelchen Befehlen Fragen hast, bin ich (sowie sicherlich auch andere hier im Forum) gerne bereit dir weiter zu helfen.

Wie "eRaaaa" bereits schreib, brauchst du bei einem Methodenaufruf den Datentyp nicht nocheinmal mit angeben.


----------



## ne0n2005 (30. Mai 2010)

Ich dachte es würde besser aussehen 

```
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;

import javax.swing.JFrame;
import javax.swing.JOptionPane;


public class Wurfparabel  extends JFrame{ 
	private final double G = 9.81;	//evt nicht final setzten, je nach Verwendungszweck des Programmes
	private int alpha=30,v=30;
	private int wurfweite;
	
	public Wurfparabel()  {
		//JFrame
		this.setSize(500,500);
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setForeground(Color.BLUE);
		this.setVisible(true);
		
		wurfWeiteBerechnen();
	}
	
	/*
	 * Berechnet die Wurfweite, um beim zeihcnen nicht zusehr in den negativen Bereich zu gehen
	 */
	private void wurfWeiteBerechnen() {
		// TODO Auto-generated method stub
		this.wurfweite = (int) wurfWeite(v,alpha);
		
	}


	/*
	 * Berechnet die Höhe an der Stelle x in Abhängigkeit von dem Abwurfwinkel alpha.
	 */
	public double hoeheBerechnen(double v0, double x, double alpha)  {
		double hoehe;
		alpha = Math.toRadians(alpha);
		hoehe = Math.tan(alpha)*x -(G*x*x)/(2*v0*v0*Math.cos(alpha)*Math.cos(alpha));
		return hoehe;	
	}
	
	/*
	 * Berechnet wie weit ein Objekt bei einer Geschwindigkeit von v0 unter dem Abwurfwinkel alpha fliegt.
	 */
	public double wurfWeite(double v0, double alpha)  {
		double weite;
		alpha = Math.toRadians(alpha);
		weite = v0*v0*Math.sin(2*alpha)/G;
		return weite;
	}



    public void paint(Graphics g)  {
    	for(int i=0;i<=wurfweite;i++)  {
    		g.drawLine(i*5+50, 450, i*5+50, 450-(int)(hoeheBerechnen(v,i,alpha)*35));
    	}
    }

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


----------



## agentone (31. Mai 2010)

Bei Swing bitte nicht 'paint' sondern 'paintComponent' überschreiben. Das sieht unter Windows sonst ziemlich scheiße aus, da der Frame-Hintergrund nicht neu gezeichnet wird.

Zum Programm: Ich hab sowas auch schon mal ohne sin() und cos() geschafft! Du kannst dann zwar die Wurfhöhe und -weite nicht direkt ausrechnen, aber Simulationen gehen viel schöner. (Vorallem kann ich dabei den Wind mit beachten und erhalte folglich nicht nur Parabeln.)  Ich schau heut nachmittig mal und schick dann den code.


----------



## ne0n2005 (31. Mai 2010)

Arg, stimmt ich hatte erst ein normales Frame, aber ich ich wollte das ganze dann nicht noch mit dem WindowListener ... und dann hab ichs glatt vergessen 


aber genug der Ausreden, du hast natürlich recht, danke für den Nachtrag.


----------



## Ebenius (31. Mai 2010)

Um das genauer zu sagen: JFrame hat kein [c]paintComponent(…)[/c]. Dort setzt man ein JPanel als ContentPane und überschreibt dessen [c]paintComponent(…)[/c].

Ebenius


----------



## agentone (31. Mai 2010)

@Ebenius: das außerdem noch... hab ich ganz übersehen

Und hier wie versprochen das Programm zur Berechnung einer Flugbahn, ohne sinus und cosinus (OK, ein mal um den Winkel und die Stärke in x- und y-Vektoren umzurechnen. Das passiert aber nur ein Mal!)
Das Programm ist schon 1 Jahr alt und deshalb von mir etwas unschön programmiert.

Hier zunächst die Logik in der Klasse Flugobjekt:

```
public class Flugobjekt
{
        private double position_x;  //aktuelle position (x;y)
        private double position_y;
        private double bewegung_x; //speed in x bzw. y richtung
        private double bewegung_y;
        private double wind;  //wind
        private double schwerkraft;  //fallbeschleunigung
        private double masse; //masse des objekts
        private double aero;  //luftwiderstand

        Flugobjekt(int start_x, int start_y, double wurf_x, double wurf_y, double masse, double aero, double wind, double schwerkraft)
        {
                this.position_x=start_x;
                this.position_y=start_y;
                this.bewegung_x=wurf_x;
                this.bewegung_y=wurf_y;
                this.masse=masse;
                this.aero=aero;
                this.wind=wind;
                this.schwerkraft=schwerkraft;
        }
        
        public void nextStep()
        {
                bewegung_x+=wind*aero;
                bewegung_y+=schwerkraft*masse;
                position_x+=bewegung_x;
                position_y+=bewegung_y;
        }
        
        public int getX()
        {
                return (int)position_x;
        }
        
        public int getY()
        {
                return (int)position_y;
        }
}
```

Und jetzt die GUI in Gestalt der Klasse FlugAnimation mit ein paar kleine Grafikbugs. (Manchmal werden die Kreise nicht gezeichnet.)


```
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;

public class FlugAnimation extends Frame implements Runnable, ActionListener
{
        public static void main(String args[])
        {
                new FlugAnimation();
        }

        private Vector<Flugobjekt> objekte;
        
        private TextField [] tf;
        private Label lbl_info;
        

        public FlugAnimation()
        {
                System.out.println("program:\tini");
                objekte=new Vector<Flugobjekt>(10,5);
                
                int screenw=(int)Toolkit.getDefaultToolkit().getScreenSize().getWidth();   //hole bildschirmbreite und höhe
                int screenh=(int)Toolkit.getDefaultToolkit().getScreenSize().getHeight();
                
                //oberfläche
                setBackground(new Color(230,230,230));
                setLayout(null);
                setBounds(0,0,screenw,screenh);
                setExtendedState(Frame.MAXIMIZED_BOTH);
                setTitle("Programm: Berechnung einer Ziemlich-Realistischen-Flugbahn");
                addWindowListener(new Exit());
                
                
                //panel fuer die einstellungen
                Panel p=new Panel();
                p.setBounds(0,0,150,getHeight());
                p.setBackground(new Color(200,200,200));
                p.setLayout(null);
                add(p);
                
                //Label und Textfelder erstellen
                int anz_werte=8;
                tf=new TextField[anz_werte];
                String labels[]=new String[]{"Startposition x","Startposition y","Winkel","Stärke","Masse","Aerodynamik","Wind","Schwerkraft"};
                String defaults[]=new String[]{"10",""+(getHeight()-50),"45","15","1","1","-0.1","0.2"};
                for(int i=0; i<anz_werte; i++)
                {
                        tf[i]=new TextField(defaults[i]);
                        tf[i].setBounds(85,50+25*i,60,20);
                        p.add(tf[i]);
                        
                        Label lbl=new Label(labels[i]);
                        lbl.setBounds(5,50+25*i,80,20);
                        p.add(lbl);
                }
                
                Button btn_s=new Button("Start");
                btn_s.setBounds(10,50+25*anz_werte,100,20);
                btn_s.setActionCommand("start");
                btn_s.addActionListener(this);
                p.add(btn_s);
                
                Button btn_l=new Button("Löschen");
                btn_l.setBounds(10,75+25*anz_werte,100,20);
                btn_l.setActionCommand("delete");
                btn_l.addActionListener(this);
                p.add(btn_l);
                
                lbl_info=new Label("Herzlich Willkommen");
                lbl_info.setBounds(5,100+25*anz_werte,140,20);
                lbl_info.setForeground(Color.RED.darker());
                p.add(lbl_info);
                
                setVisible(true);
                
                new Thread(this).start();
                System.out.println("program:\tstart");
        }
        
        public void actionPerformed(ActionEvent ae)
        {
                String cmd=ae.getActionCommand();
                if(cmd.equals("start"))
                {
                        try
                        {
                                int x=Integer.parseInt(tf[0].getText()); //position
                                int y=Integer.parseInt(tf[1].getText());

                                double m=Double.parseDouble(tf[4].getText());//Masse
                                double a=Double.parseDouble(tf[5].getText());//Aerodynamik

                                double kw=Double.parseDouble(tf[6].getText());  //wind
                                double kg=Double.parseDouble(tf[7].getText());  //gravitation

                                double w=Double.parseDouble(tf[2].getText());   //winkel
                                double s=Double.parseDouble(tf[3].getText());   //staerke

                                double sx=Math.sin(Math.toRadians(w))*s;
                                double sy=-Math.cos(Math.toRadians(w))*s;

                                objekte.add(new Flugobjekt(x,y,sx,sy,m,a,kw,kg));
                                lbl_info.setText("Flugobjekt gestartet.");
                        }
                        catch(Exception e)
                        {
                                lbl_info.setText("Bitte Zahlen eingeben!");
                        }
                }
                else if(cmd.equals("delete"))
                {
                        dbg.setColor (getBackground ());
                        dbg.fillRect (0, 0, getWidth(), getHeight());
                        
                        objekte=new Vector<Flugobjekt>(10,5);
                        
                        lbl_info.setText("Bildschirm gelöscht.");
                }
        }
        
        public void run()
        {
                while(true)
                {
                        for(int i=0; i<objekte.size(); i++)
                        {
                                Flugobjekt fo=objekte.get(i);
                                fo.nextStep();
                                if(fo.getX()>getWidth() || fo.getX()<0 || fo.getY()>getHeight() || fo.getY()<0)
                                {
                                      objekte.remove(i);
                                }
                        }
                        repaint();
                        try{Thread.sleep(40);}catch(Exception e){System.out.println("Thread-Fehler");}
                }
        }
        
        private Image dbImage;
        private Graphics2D dbg;

        public void update (Graphics g)
        {
               if (dbImage == null)
               {
                  dbImage = createImage (getWidth(), getHeight());
                  dbg = (Graphics2D)dbImage.getGraphics ();
                  dbg.translate(150,0);
               }

               dbg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);

               //dbg.setColor (getBackground ());
               //dbg.fillRect (0, 0, getWidth(), getHeight());

               dbg.setColor (getForeground());
               paint(dbg);

               g.drawImage (dbImage, 0, 0, this);
        }
        
        public void paint(Graphics g)
        {
                //int x=Integer.parseInt(tf[0].getText()); //position
                //int y=Integer.parseInt(tf[1].getText());
                for(int i=0; i<objekte.size(); i++)
                {
                        Flugobjekt fo=objekte.get(i);
                        g.drawOval(fo.getX()-5,fo.getY()-5,10,10);
                        //g.drawLine(x,y,fo.getX(),fo.getY());
                }
        }
        
        private class Exit extends WindowAdapter
        {
                public void windowClosing(WindowEvent we)
                {
                        System.out.println("program:\tend");
                        System.exit(0);
                }
        }
}
```

Wie gesagt, dass wichtigste ist die Klasse Flugobjekt. In dieser wird die Flugbahn nach und nach berechnet.

Viel Spaß beim Ausprobieren.


----------



## ne0n2005 (31. Mai 2010)

Wieso fallen denn Objekte mit größerer Masse schneller ?
Ich will mein Vakuum zurück.


----------

