Methoden Berechnung von Anfangsgeschwindigkeit und Winkel

CptK

Bekanntes Mitglied
Hallo, ich habe folgende Klasse, die eine Kanonenkugel erstellt:
Java:
package Data;

import java.util.Timer;
import java.util.TimerTask;

public class Kanonenkugel {
  
    private Timer timer;
    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 = 0;  //wind
    private double schwerkraft;  //fallbeschleunigung
    private double masse; //masse des objekts
    private double aero;  //luftwiderstand
    private int size;

    public Kanonenkugel(int start_x, int start_y, double wurf_x, double wurf_y, double masse, double aero, double schwerkraft, int size) {
        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.schwerkraft=schwerkraft;
        this.size = size;
      
        timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                nextStep();
            }
        }, 0, 20);  
    }
  
    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;
    }
  
    public int getSize() {
        return size;
    }

}

Mithilfe von einem Abschusswinkel und einer Abschussgeschwindigkeit werden die beiden Vektoren der Bewegung berechnet:
Code:
   double s = ?;  //Anfangsgeschwindigkeit
            double w =?;  //Abschusswinkel
            //Berechnet die Kräfte in x und y Richtung
            double sx=Math.sin(Math.toRadians(w))*s;
            double sy=-Math.cos(Math.toRadians(w))*s;

Mein Problem ist jetzt folgendes:
Ich habe einen Anfangspunkt A(x|y) und einen Zielpunkt Z(x|y).
Wie berechne ich jetzt die Anfangsgeschwindigkeit und den Winkel, sodass die Kugel bei A losfliegt und Punkt Z auf der Flugbahn liegt?
 

mihe7

Top Contributor
Bevor das so weitergeht:
Java:
import java.awt.geom.Point2D;

public class Wurfparabel {
     public static final double G = 9.81;
     private final Point2D start;
     private final double winkel;
     private final double geschwindigkeit;

     public Wurfparabel(Point2D start, double winkel, double geschwindigkeit) {
         this.start = start;
         this.winkel = winkel;
         this.geschwindigkeit = geschwindigkeit;
     }

     public Point2D start() { return start; }
     public double winkel() { return winkel; }
     public double geschwindigkeit() { return geschwindigkeit; }

     public Point2D punkt(double zeit) {
         double x = start.getX() + geschwindigkeit * zeit * Math.cos(winkel);
         return new Point2D.Double(x, y(x));
     }

     public double y(double x) {
         return start.getY() + yRelative(x - start.getX());
     }

     public double yRelative(double x) {
         double cos = Math.cos(winkel);
         return x * Math.tan(winkel) - G * x * x /
             (2 * geschwindigkeit * geschwindigkeit * cos * cos);
     }

     public Wurfparabel treffe(Point2D ziel, double zeit) {
         double y = ziel.getY() - start.getY();
         double x = ziel.getX() - start.getX();
         double w = Math.atan((2 * y + G * zeit * zeit) / (2 * x));
         double v = x / (zeit * Math.cos(w));
         return new Wurfparabel(start, w, v);
     }

     public static Wurfparabel treffe(Point2D start, Point2D ziel,
                                      double zeit) {
         return new Wurfparabel(start, 0, 0).treffe(ziel, zeit);
     }
}
 

httpdigest

Top Contributor
Und hier hat jemand nicht in Physik aufgepasst:
`bewegung_y+=schwerkraft*masse;`
Die Fallgeschwindigkeit ist im freien Fall (also ohne Luftwiderstand) unabhängig von der Masse des Körpers. Grund: Es wirkt zwar aufgrund der höheren Masse eine höhere Anziehungskraft auf den Körper, allerdings wird diese wieder durch die Massenträgheit des Körpers annulliert. Ein Körper mit größerer Masse benötigt eben auch eine größere auf ihn einwirkende Kraft, um ihn in gleichem Maße zu beschleunigen wie einen Körper mit geringerer Masse.
 
X

Xyz1

Gast
Arbeitet hier vielleicht jemand in der Forensischen Ballistik? :D (SORRY, den schlechten Wortwitz konnte ich mir jetzt nicht verkneifen ;))
 

CptK

Bekanntes Mitglied
Und hier hat jemand nicht in Physik aufgepasst:
`bewegung_y+=schwerkraft*masse;`
Die Fallgeschwindigkeit ist im freien Fall (also ohne Luftwiderstand) unabhängig von der Masse des Körpers. Grund: Es wirkt zwar aufgrund der höheren Masse eine höhere Anziehungskraft auf den Körper, allerdings wird diese wieder durch die Massenträgheit des Körpers annulliert. Ein Körper mit größerer Masse benötigt eben auch eine größere auf ihn einwirkende Kraft, um ihn in gleichem Maße zu beschleunigen wie einen Körper mit geringerer Masse.
Also was das angeht habe ich keine Ahnung und die Kugel fliegt ne Kurve so wie ich mir das vorstelle also ist mir das relativ egal :p
 

CptK

Bekanntes Mitglied
Ich habe nochmal ne Frage: Wieso brauche ich die Zeit in der Klasse Wurfparabel? Geht das nicht unabhängig davon?
 

httpdigest

Top Contributor
Du wolltest fragen: "Wieso benötige ich in der Methode, die zu einem Startpunkt und einem Zielpunkt die Wurfparabel berechnet, auch noch die Zeit als zusätzlichen Parameter?"
Antwort: Weil es unendlich viele mögliche Parabeln gibt zwischen Start und Ende. Du kannst einen Ball von einem Startpunkt auf einen Zielpunkt entweder sehr direkt mit sehr flachem Winkel und sehr hoher Geschwindigkeit werfen, oder du wirst ihn in gaaaanz hohem Bogen nahzu senkrecht nach oben mit sehr hoher Geschwindigkeit, so dass er irgendwann in ein paar Tagen den Zielpunkt erreicht. Und alles zwischen diesen Extremen ist auch möglich.
 

CptK

Bekanntes Mitglied
Und irgendwie funktioniert das nicht: Egal was ich eingebe, ich kriege NIE einen Winkel der größer als 2 oder kleiner als -2 ist, das kann doch irgendwie nicht sein oder?
 

CptK

Bekanntes Mitglied
In welche Richtung ist denn 0°? oben/unten/links/rechts?
Ich habe jetzt folgende Punkte getestet:
Start: 900|200
Ziel: 70 | 420
Der Winkel müsste als ungefähr -70 oder so was in die Richtung sein (Wenn 0° im Kreis nach oben ist).
Wenn ich das aber mit Zeit = 10 mache für
Java:
Wurfparabel parabel = new Wurfparabel(new Point2D.Double(900,200), 0, 0).treffe(new Point2D.Double(70, 420), 10);
        double winkel = Math.toDegrees(parabel.winkel);
bekomme ich für den winkel -0.27096785933509615 raus.
 

httpdigest

Top Contributor
Benutze atan2, denn atan alleine kann nicht zwischen allen vier Quadranten unterscheiden.
Also ändere:
`double w = Math.atan((2 * y + G * zeit * zeit) / (2 * x));`
zu:
`double w = Math.atan2(2 * y + G * zeit * zeit, 2 * x);`
 

CptK

Bekanntes Mitglied
Joa, der Winkel ist schon mal sinnvoller allerdings habe ich jetzt das Problem, wenn ich das ganze mit der Klasse die ich ganz am Anfang gezeigt habe benutze, da nicht der Punkt getroffen wird den ich haben will.
Falls es jetzt mal jemand selbst testen will schicke ich nochmal beide Klassen so, wie ich sie gerade habe:
Java:
package TEST;

import java.awt.geom.Point2D;

public class Wurfparabel {
     public static final double G = 9.81;
     private final Point2D start;
     private final double winkel;
     private final double geschwindigkeit;

     public Wurfparabel(Point2D start, double winkel, double geschwindigkeit) {
         this.start = start;
         this.winkel = winkel;
         this.geschwindigkeit = geschwindigkeit;
     }

     public Point2D start() { return start; }
     public double winkel() { return winkel; }
     public double geschwindigkeit() { return geschwindigkeit; }

     public Point2D punkt(double zeit) {
         double x = start.getX() + geschwindigkeit * zeit * Math.cos(winkel);
         return new Point2D.Double(x, y(x));
     }

     public double y(double x) {
         return start.getY() + yRelative(x - start.getX());
     }

     public double yRelative(double x) {
         double cos = Math.cos(winkel);
         return x * Math.tan(winkel) - G * x * x /
             (2 * geschwindigkeit * geschwindigkeit * cos * cos);
     }

     public Wurfparabel treffe(Point2D ziel, double zeit) {
         double y = ziel.getY() - start.getY();
         double x = ziel.getX() - start.getX();
         double w =  Math.atan2(2 * y + G * zeit * zeit, 2 * x);
         double v = x / (zeit * Math.cos(w));
         return new Wurfparabel(start, w, v);
     }

     public static Wurfparabel treffe(Point2D start, Point2D ziel,
                                      double zeit) {
         return new Wurfparabel(start, 0, 0).treffe(ziel, zeit);
     }
   
     public static void main(String[] args) {
        treffe(new Point2D.Double(900,200), new Point2D.Double(70, 420), 10);
        Wurfparabel parabel = new Wurfparabel(new Point2D.Double(900,200), 0, 0).treffe(new Point2D.Double(70, 420), 1);
        double winkel = Math.toDegrees(parabel.winkel);
        winkel += 90;
        double s = 10;
        double sx=Math.sin(Math.toRadians(winkel))*s;
        double sy=-Math.cos(Math.toRadians(winkel))*s;
        System.out.println(sx +  " " + sy);
        new Kanonenkugel(900, 200, sx, sy, 0.1, 1);
      
    }
}
Java:
package TEST;

import java.util.Timer;
import java.util.TimerTask;

public class Kanonenkugel {
  
    private Timer timer;
    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 schwerkraft;  //fallbeschleunigung
    private int size;

    public Kanonenkugel(int start_x, int start_y, double wurf_x, double wurf_y, double schwerkraft, int size) {
        this.position_x=start_x;
        this.position_y=start_y;
        this.bewegung_x=wurf_x;
        this.bewegung_y=wurf_y;
        this.schwerkraft=schwerkraft;
        this.size = size;
      
        timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                nextStep();
            }
        }, 0, 1);  
    }
  
    public void nextStep() {
        bewegung_y+=schwerkraft;
        position_x+=bewegung_x;
        position_y+=bewegung_y;
        System.out.println(getX() + " | " + getY());
        if(getX() > 1100 || getX() < 0) {
            System.exit(0);
        }
    }
  
    public int getX() {
        return (int)position_x;
    }
  
    public int getY() {
        return (int)position_y;
    }
  
    public int getSize() {
        return size;
    }

}
 
Zuletzt bearbeitet:

httpdigest

Top Contributor
Du integrierst auch über viel zu große Zeitintervalle von einer Sekunde linear. Es gilt ja:
`a = dv/dt`, somit: `dv = a * dt` und:
`v = ds/dt`, somit: `ds = v * dt`
Du müsstest jetzt also eine numerische Integration über möglichst kleine `dt` vornehmen.
Das Problem ist, dass deine Berechnung quasi eine Simulation per numerischer Integration ist, statt denn eine analytische Gleichung.
 

httpdigest

Top Contributor
Praktisch gesehen, ändere:
Java:
bewegung_y+=schwerkraft;
position_x+=bewegung_x;
position_y+=bewegung_y;
zu:
Java:
bewegung_y += schwerkraft * dt;
position_x += bewegung_x * dt;
position_y += bewegung_y * dt;
für möglichst kleine `dt`.

Die analytische Lösung von @mihe7 für den Winkel und die Geschwindigkeit erfordert, dass `dt` gegen Null geht, was bei numerischer Integration aus praktischen Gründen nicht geht. Du wirst also niemals ganz exakt den Zielpunkt treffen, sondern kannst dich diesem nur beliebig gut annähern mit kleinerem `dt`.
 

httpdigest

Top Contributor
Also: Deine Simulation, wenn es z.B. ein Echtzeitspiel ist, hat ja eine gewisse Tickrate (bei reiner grafischer Ausgabe auch Framerate genannt). Diese sagt ja quasi, wieviele Frames (bzw. in deinem Fall Simulationsschritte) du pro Sekunde berechnen kannst. Das Zeitintervall zwischen jeweils zwei Schritten nennen wir mal dT (hier mal mit einem großen 'T'). Wenn du z.B. alle 10 Millisekunden einmal einen Simulationsschritt berechnest, wäre `dT = 0.01`, also 10 Millisekunden in Sekunden umgerechnet.
Ein Simulationsschritt wäre bei dir etwa eine Ausführung der run() Methode vom TimerTask.
Was du jetzt machen müsstest, ist, erstmal die Zeit messen, die zwischen jeweils zwei Ausführungen der TimerTask.run() Methode vergehen. Die kann nämlich stark von der gewünschten Zeit abweichen. Z.B. wird der TimerTask garantiert nicht eine Granularität von 1ms. erreichen können. Das Zeitintervall könntest du möglichst genau mit der Differenz von `System.nanoTime() / 1E9f` zwischen jeweils zwei Aufrufen des Timers in Sekunden erreichen.
Wenn du diesen Wert hast, könntest du jetzt noch dein gewünschtes Integrationsintervall`dt` (mit kleinem 't') festlegen. Wenn du willst, dass eine möglichst genaue Simulation vorgenommen wird, kannst du z.B. einfach mal `float dt = 1E-4f` verwenden. Jetzt müsstest du nur noch solange wiederholt deine nextStep() Methode mit eben diesem `dt` als Argument aufrufen, bis die aufkumulierten `dt`s deinem `dT` entsprechen, das heißt also, bis die Simulation die aktuell vergangene Echtzeit eingeholt hat. Das kannst du z.B. mit einer einfachen `do { nextStep(dt); dT -= dt; } while (dT > dt);` Schleife erreichen. Das wäre zwar noch nicht 100%ig korrekt so, aber reicht für den Anfang.
 

CptK

Bekanntes Mitglied
Gut, ich wollte schon fragen ob es da nicht irgendwas einfacheres gibt, aber wirklich weiter komme ich da auch nicht
 

mihe7

Top Contributor
Du merkst Dir den Zeitpunkt der Schussabgabe und berechnest in Deinem Timer die Differenz -> damit weißt Du, welche Zeit seit Schussabgabe vergangen ist und das setzt Du in die Methode ein und bekommst den Punkt zurück, an dem sich die Kugel zu diesem Zeitpunkt befindet.
 

mihe7

Top Contributor
Zum Beispiel:
Java:
long start = System.currentTimeMillis();
// im Timer:
double zeit = (System.currentTimeMillis() - start) / 1000.0;
EDIT: nicht long zeit, sondern double zeit...
 

CptK

Bekanntes Mitglied
Klappt schonmal ganz gut, jetzt muss ich nur noch die Anfangsgeschwindigkeit anpassen lasse, sodass auch die Reichweite passt
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
I File Uploader... Statusanzeige, Berechnung des Status etc. Java Basics - Anfänger-Themen 0
Bugs Bunny Fehlerhafte Berechnung beim erneuten Durchlaufen der Schleife Java Basics - Anfänger-Themen 5
Jamie logische Verknüpfung zur Schaltjahr-Berechnung Java Basics - Anfänger-Themen 30
Stephan_kl Reihenwert-Berechnung, Ergebnis mit vorherigem Ergebnis vergleichen Java Basics - Anfänger-Themen 11
Abraham42 Berechnung der Kühlung Java Java Basics - Anfänger-Themen 12
S Hashcode-Berechnung + ^ Java Basics - Anfänger-Themen 2
J Median-Berechnung von 2D-Teilarrays Java Basics - Anfänger-Themen 56
F Tabelle - Berechnung Rang Java Basics - Anfänger-Themen 2
B Berechnung der Position von Kinderelemente von einem Elternknoten Java Basics - Anfänger-Themen 23
S Berechnung der sleep time ist falsch Java Basics - Anfänger-Themen 46
S Switch-Case zur Berechnung der Einkommensteuer Java Basics - Anfänger-Themen 15
F Berechnung der Rektaszension und Deklination eines Sterns Java Basics - Anfänger-Themen 7
2 Taschenrechner mit GUI Problem bei der Berechnung Java Basics - Anfänger-Themen 8
V Erste Schritte Pi Berechnung Java Basics - Anfänger-Themen 47
M Berechnung der Reststrecke bei Graphen Java Basics - Anfänger-Themen 1
V Algorithmus zur fortlaufenden Berechnung des duechscjnt Java Basics - Anfänger-Themen 1
B Berechnung zu einer Schleife formen Java Basics - Anfänger-Themen 6
B Berechnung Median mit Methode Java Basics - Anfänger-Themen 7
K Erste Schritte Berechnung der Summe zweier Arrays Java Basics - Anfänger-Themen 15
S Erste Schritte Berechnung des Paketportos - Problem/Frage Java Basics - Anfänger-Themen 52
J Gleitkommazahlen, Berechnung von pi Java Basics - Anfänger-Themen 4
J Berechnung liefert falsches Ergebnis Java Basics - Anfänger-Themen 2
kilopack15 Verzweiflung wegen Berechnung mit Multithreading Java Basics - Anfänger-Themen 1
A Die Werte zur Berechnung müssen als Parameter übergeben werden? Java Basics - Anfänger-Themen 7
Salo Berechnung von Winkeln Java Basics - Anfänger-Themen 28
M Restbuchwert Berechnung geht nicht Java Basics - Anfänger-Themen 45
Ghostman1711 Pi berechnung Methode aufrufen Java Basics - Anfänger-Themen 2
L Rekursive Methode zur Berechnung der Potenz q hoch p Java Basics - Anfänger-Themen 17
beatles Operatoren Operatoren - Berechnung Java Basics - Anfänger-Themen 40
K Best Practice Algorithmus für Berechnung von Zahlenreihenfolge Java Basics - Anfänger-Themen 12
N Verzögerte Berechnung "Lazy" Java Basics - Anfänger-Themen 8
J Erste Schritte Rundungsproblem - Berechnung Notendurchschnitt Java Basics - Anfänger-Themen 13
S Variablen Vektor zur Berechnung verwenden Java Basics - Anfänger-Themen 4
T Java double berechnung fehler Java Basics - Anfänger-Themen 2
M Berechnung in Java Java Basics - Anfänger-Themen 4
S Berechnung der Arbeitstage in einem Zeitraum Java Basics - Anfänger-Themen 9
E Problem bei rekursiver Berechnung des Binomialkoeffizienten Java Basics - Anfänger-Themen 5
T Iterative Pi Berechnung in Rekursive Java Basics - Anfänger-Themen 2
S Double, int, Berechnung Java Basics - Anfänger-Themen 3
C Nach Berechnung runden und Wert ausgeben Java Basics - Anfänger-Themen 7
E Berechnung für Shop einbinden Java Basics - Anfänger-Themen 8
S Klassen Formel zur Berechnung .... Bitte um Hilfe Java Basics - Anfänger-Themen 7
S Euklid Algorithmus zur Berechnung des GGTs Java Basics - Anfänger-Themen 2
OnDemand Berechnung in die start und paint Methode eines Applets Java Basics - Anfänger-Themen 28
P Schleife zur Berechnung von einer Summe Java Basics - Anfänger-Themen 16
F Berechnung einer linearen Abschreibung Java Basics - Anfänger-Themen 5
E Berechnung von Punkten Java Basics - Anfänger-Themen 4
D Berechnung des Abstandes von zwei Punkten in einem Koordinatensystem Java Basics - Anfänger-Themen 14
A Methoden PI-Berechnung Java Basics - Anfänger-Themen 22
S Erste Schritte Berechnung mit Daten aus CSV und Date Objekt Java Basics - Anfänger-Themen 2
C Programm zur Berechnung der Spur einer Matrix Java Basics - Anfänger-Themen 4
P Pythagoras Baum - Berechnung der Punkte Java Basics - Anfänger-Themen 9
A Erste Schritte Steuer Berechnung, Alters Abhängig Java Basics - Anfänger-Themen 5
T Erste Schritte Berechnung von gerade und ungerade Zahlen Java Basics - Anfänger-Themen 10
J Erste Schritte Berechnung Ratten vermehrung Java Basics - Anfänger-Themen 4
P falsches ergebnis bei einfacher berechnung Java Basics - Anfänger-Themen 3
T Iterative Berechnung einer Satellitenbahn Java Basics - Anfänger-Themen 20
M Java Berechnung mit mehreren Lösungen? Java Basics - Anfänger-Themen 9
D Nullstellen-Berechnung Java Basics - Anfänger-Themen 10
L Fehlermeldung bei falscher Berechnung anzeigen Java Basics - Anfänger-Themen 31
A berechnung multiplikatives inverses Java Basics - Anfänger-Themen 5
J Berechnung des aktuellen Alters auf Basis des Geburtstags Java Basics - Anfänger-Themen 45
J Datentypen Fehler bei Berechnung mit Double und Int-Werten Java Basics - Anfänger-Themen 22
G Berechnung von Winkeln mit Cosinussatz Java Basics - Anfänger-Themen 2
B Arrays verwenden für Berechnung Java Basics - Anfänger-Themen 3
R Merkwürdige Modulo Berechnung Java Basics - Anfänger-Themen 7
B Hausaufgabe Berechnung quadratischer Funktion Java Basics - Anfänger-Themen 16
U Alter Berechnung + sortierung Java Basics - Anfänger-Themen 6
P Berechnung wird nicht durchgeführt Java Basics - Anfänger-Themen 2
D Berechnung von Ostern und Ramadan! Java Basics - Anfänger-Themen 24
N Algorithmus für Berechnung einer Quersumme Java Basics - Anfänger-Themen 9
D Berechnung von Geldausgabe Java Basics - Anfänger-Themen 22
F Berechnung von Kugeln! Java Basics - Anfänger-Themen 9
M rekursive Funktion zur Berechnung der Spiegelzahl Java Basics - Anfänger-Themen 7
S Hausaufgabe: Java-Programm schreiben zur Berechnung von x und y Java Basics - Anfänger-Themen 9
Y Ergebnis einer Berechnung an die Main Methode übergeben Java Basics - Anfänger-Themen 11
Semox Ersten Wert eines Intervalls bei Berechnung einschließen Java Basics - Anfänger-Themen 8
J Logarithmische Berechnung und Arrays Java Basics - Anfänger-Themen 2
B LinkedList - Berechnung des Produkts Java Basics - Anfänger-Themen 6
B Berechnung von Preisen per Java-Programm Java Basics - Anfänger-Themen 27
M Alters berechnung aus Geburtsjahr aus dem Buch Java Basics - Anfänger-Themen 5
O Fehler in der String-Distanz-Berechnung Java Basics - Anfänger-Themen 5
-horn- "Berechnung vorwärts, Optimierung rückwärts?" - Wie würdet ihr das machen? Java Basics - Anfänger-Themen 8
P iterative Berechnung Java Basics - Anfänger-Themen 9
1 Berechnung von PI mithilfe von Buffons Nadelproblem Java Basics - Anfänger-Themen 2
G Berechnung zwei Komplexen Zahlen Java Basics - Anfänger-Themen 34
N Rekursive Berechnung der Höhe eines binären Baumes Java Basics - Anfänger-Themen 4
J Programm für interaktive Berechnung von Temperaturverläufen Java Basics - Anfänger-Themen 9
K Annährende ganzzahlige Berechnung der Wurzel Java Basics - Anfänger-Themen 8
L Berechnung von Perioden Java Basics - Anfänger-Themen 4
D einfach berechnung einer onlinezeit Java Basics - Anfänger-Themen 25
S Euklid Klasse mit Methoden zur Berechnung des ggT Java Basics - Anfänger-Themen 23
G Frage zur Primzahlen berechnung Java Basics - Anfänger-Themen 11
G Berechnung von N-Tageslinien von Aktienkursen Java Basics - Anfänger-Themen 13
G Rekursive Berechnung von n über k schlägt fehl Java Basics - Anfänger-Themen 5
G Einfache Berechnung liefert falsches Ergebnis Java Basics - Anfänger-Themen 2
W Schaltjahr Berechnung Java Basics - Anfänger-Themen 24
A Probleme mit Programm zur Pi-Berechnung Java Basics - Anfänger-Themen 6
X Temperatur-Berechnung /Array(?) Java Basics - Anfänger-Themen 5
L Berechnung Summe Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben