Erste Schritte Rechnen mit Brüchen

Dodi.Hudori

Mitglied
Sooo, ich bins mal wieder, nachdem mir hier bei meinen Problemen mit der letzten Aufgabe super geholfen habe stehe ich schonwieder vor dem nächsten Problem (generell kann man aber sagen es macht immer mehr Spaß, vorausgesetzt die Programme die man schreibt laufen auch :D )

Ich soll eine Klasse RatNumber implementieren mit den Variablen num (Zähler) und denom (Nenner).

Der Konstruktor soll:

a. Prüfen ob der Nenner Null ist, falls ja eine Fehlermeldung ausgeben

b. Den Bruch so weit wie möglich kürzen

c. setzen der beiden Attribute num und denom

Dazu soll ich vier Methoden schreiben die addieren, subtrahieren, multiplizieren und dividieren. Außerdem sollen Getters eingebaut werden (das hab ich). CompareTo soll zwei RatNumber vergleichen und toString soll die RatNumber als String ausgeben.

das hier macht die ganze Sache aber irgendwie komisch:

Hinweis: Es soll in den Methoden zum Addieren und Subtrahieren jeweils ein neues Objekt RatNumber zurückgegeben werden, This darf dabei also nicht verändert werden.

mein erstes Problem: in meinem Code wird auch ein nicht kürzbarer Bruch gekürzt und der Rest "vergessen" wie kann ich das umgehen? Hatte gedacht eine IF Schleife mit der Bedingung % 0, allerdings bekomm ich das nicht zum laufen

in der Main Methode habe ich erst einmal meine ggT Funktion geprüft und ausgeben lassen (um das ganze nachzuvollziehen), diese Zeilen bitte einfach nicht beachten ;) .

Nun steh ich wie der Ochse vorm Berg, wie soll ich ohne
Java:
this.num
und
Java:
this.denom
die add sub mult und div Konstruktoren schreiben? :/

Das ist bis jetzt mein (lauffähiger) Code, ein paar Teile habe ich erst einmal "ausgeklammert" als KOmmentar.

Java:
public class RatNumber implements Comparable<RatNumber>{
	private int num; //Zaehler
	private int denom; //Nenner
	
	public RatNumber(int n, int d) {

		n = this.num;
		d = this.denom;
		
		//Fehlernachricht wenn Nenner = 0
		if(d==0){
			System.out.println("Nenner darf nicht Null sein");
			
		//sonst ggT ermitteln
		}else{
			
			ggT(this.num, this.denom);

			}
			
		}
	
	//ggT ermitteln zum kürzen
	static int ggT(int a, int b){
    if(a==b||b==0) return a;
    if(b==1) return a;
    else return ggT(b,a%b);

}
	
	
	public int getNum() {
		return num;
	}
	
	public int getDenom() {
		return denom;
	}
	/*
	public int compareTo(RatNumber n){

		// TODO: source code
	}
	*/
	public RatNumber add(RatNumber r) {
		
		
		return r;
	}
	/*
	public RatNumber sub(RatNumber r) {

		// TODO: source code
                // returns a ***new*** RatNumber
	}
	
	public RatNumber mult(RatNumber r) {

		// TODO: source code
                // returns a ***new*** RatNumber
	}
	
	public RatNumber div(RatNumber r) {

		// TODO: source code
                // returns a ***new*** RatNumber
	}
	*/
	
	public String toString() {
		return "(" + num + "/" + denom + ")";
	}

	public static void main(String[] args) {
		
		int a = 12;	//Zaehler
		int b = 4;	//Nenner
		System.out.println("ggT von " +a+ "/" +b+ " ist " +ggT(a,b));
		System.out.println(+a+ "/" +b+ "  gekürzt: " +a/ggT(a,b)+ "/" +b/ggT(a,b));	
		
		RatNumber r1 = new RatNumber(12,4);
		RatNumber r2 = new RatNumber(4,12);
		
		
	}
}

Die Konsole liefert mir:

Java:
ggT von 12/4 ist 4
12/4  gekürzt: 3/1
Nenner darf nicht Null sein
Nenner darf nicht Null sein
 
N

nillehammer

Gast
Nun steh ich wie der Ochse vorm Berg, wie soll ich ohne ... die add sub mult und div Konstruktoren schreiben? :/
So war der Hinweis nicht gemeint. Der Hinweis war so zu verstehen, dass die Methoden einen neuen Bruch mit den richtigen Werten zurückliefern sollen und nicht zu dem bestehenden die Werte addiert werden sollen. Der Code dafür muss also irgendwie so aussehen:
Java:
public RatNum add(RatNum ratNumToAdd) {
  int newZaehler = ... hilfsMethodeDieDieAdditionsRegelnBeiBrüchenBeachtet 
  int newNenner = ... hilfsMethodeDieDieAdditionsRegelnBeiBrüchenBeachtet 
  return new RatNum(newZaehler, newNenner);
}
 
Zuletzt bearbeitet von einem Moderator:

Dodi.Hudori

Mitglied
so ich hab das ganze mal wie folgt umgesetzt, allerdings is da wieder das this drin. -.-

Java:
	public RatNumber add(RatNumber r) {
		
		int z1 = this.num * r.denom;
		int z2 = r.num * this.denom;
		int n = this.num * r.num;
		return new RatNumber(z1 + z2, n);	
	}

Das hier wäre meine Lösung für die Multiplikation:

Java:
	public RatNumber mult(RatNumber r) {

			return new RatNumber(this.num * r.num,
			this.denom * r.denom);
		
	}
 
Zuletzt bearbeitet:

Suinos

Bekanntes Mitglied
Wie nillehammer schon geschrieben hat, darfst du die Werte schon verwenden, nur nicht verändern.

Und du musst sie ja verwenden, denn sonst hast du ja keinen Kontext, zu welchem du die andere Zahl hinzu addieren kannst!
Code:
a + 2 = ?
kannst du ja nur dann ausrechnen, wenn du weisst was in
Code:
a
steht; du musst auf diesen Wert zugreifen. Das ist aber noch lange nicht das gleiche wie
Code:
a
zu verändern, einen neuen Wert zuzuweisen!

Klassen wie wir sie hier haben, welche ihren ursprünglichen, im Konstruktor gesetzten Wert nicht mehr verändern, sind
Code:
immutable
, unveränderbar.
Es gibt in Java ein keyword, welches uns hilft diese Unveränderbarkeit einzuhalten:
Code:
final
:
Java:
public class RatNumber implements Comparable<RatNumber>{
    private final int num; //Zaehler
    private final int denom; //Nenner
    // [...]
}
(
Code:
final
ist hier optional, du musst es nicht verwenden, aber wenn du es tust wird sich der Compiler bemerkbar machen, falls du beim Programmieren einen Fehler machst und einen Wert änderst.
Ich verwende es wo es nur möglich ist, da ein Compilerfehler wesentlich einfacher zu finden / analysieren ist, als wenn zur Laufzeit das Programm irgendwie nicht das macht was ich wollte...)

Jetzt wird der Compiler eine Fehlermeldung ausgeben, falls die Variablen:
  • Im Konstruktor nicht genau ein Mal gesetzt werden (also Fehler wenn gar nicht oder mehr als einmal gesetzt).
  • Irgendwo sonst gesetzt werden.

Sobald du das gemacht hast, solltest du etwas feststellen ...
[JAVA=4]
public RatNumber(int n, int d) {

n = this.num;
d = this.denom;
// [...]
}
[/code]
 

Dodi.Hudori

Mitglied
danke Suinos für deine Mühen. Ich habe meinen Code gestern Abend (Nacht :D ) noch einmal umgeschrieben. nun funktioniert das rechnen mit Brüchen sehr gut, allerdings funktioniert meine Funktion zum kürzen nicht oder ich bin zu doof sie aufzurufen :(

Java:
public class RatNumber implements Comparable<RatNumber> {
	private int num; //zaehler
	private int denom; //nenner
 
	
	 // Konstruktor
	 
	public RatNumber() {
		this.num = 0;
		this.denom = 0;
	}
	
	 // Konstruktor
	 
	public RatNumber(int zaehler, int nenner) {
		this.num = zaehler;
		this.denom = nenner;
	}
	
	 // Ausgabe als String
	 
	public String toString() {
		if(this.denom == 1)
			return this.num+"";
		return this.num+"/"+this.denom;
	}
	
	 // Addition
	 
	RatNumber add(RatNumber r) {
		int nenner=0,xzaehler=0;
		if(this.denom > r.denom) {
			nenner = this.denom;
			r.num *= this.denom / r.denom;
			xzaehler = this.num;
		} else {
			nenner = r.denom;
			xzaehler = this.num * r.denom / this.denom;
		}
 
		return new RatNumber(xzaehler+r.num, nenner);
	}
	
	 // Subtraktion = Addition mit umgekehrtem Vorzeichen
	 
	RatNumber sub(RatNumber r) {
		return this.add(new RatNumber(r.num*-1, r.denom));
	}
	
	 // Multiplikation
	 
	RatNumber mult(RatNumber r) {
		return new RatNumber(this.num*r.num, this.denom*r.denom);
	}
	
	 // Division = Multiplikation mit Kehrwert
	 
	RatNumber div(RatNumber r) {
		return this.mult(new RatNumber(r.denom, r.num));
	}
	
	public static int ggt(int x, int y) {

		//ggT ermitteln
        if(y != 0) 
        	return ggt(y, x%y);
        else
        	return x;
    }
	
	public RatNumber shorten(RatNumber r) {
		int ggt = ggt(r.num, r.denom);
		r.num /= ggt;
		r.num /= ggt;
		return new RatNumber(r.num, r.denom);
	}
	
	//main
	
	public static void main(String[] args) {
		RatNumber a = new RatNumber(3, 2);
		RatNumber b = new RatNumber(10, 4);
		
		//a.shorten();
		
		System.out.println("a : " + a);
		System.out.println("b : " + b);
		System.out.println("a+b : " + a.add(b));
		System.out.println("a*b : " + a.mult(b));
		System.out.println("a/b : " + a.div(b));
	}
}

wenn cih deinen Vorschlag einbaue:

Java:
	private final int num; //zaehler
	private final int denom; //nenner

bekomme ich in Zeile 35 den Fehler "The final field RatNumber.num cannot be
assigned" woran kann das liegen? ebenso in Zeile 74/75
 
Zuletzt bearbeitet:
T

TryToHelp

Gast
du musst sie mit einer RatNumber als parameter aufrufen, so wie du sie implementiert hast, also
Code:
shorten(a);
und nicht
Code:
a.shorten();
 
S

SlaterB

Gast
ein Aufruf ist tatsächlich in deinem Code nicht enthalten, nur auskommentiert,
a zu kürzen dürfte auch nicht viel bringen im Gegensatz zu b..

und bedenke auch dass du den Parameter nicht änderst sondern ein neues Objekt erzeugst,
du musst den Rückgabewert auch verwenden..

edit: ok, der Parameter wird zusätzlich auch geändert, was mit dem final kollidiert,
final heißt eben nicht mehr zu ändern, neues Objekt als Rückgabewert ist da schon besser,
nutze andere lokale Variablen für Zwischenwerte

r.num /= ggt;
r.num /= ggt;
ändert übrigens zweimal das gleiche
 
Zuletzt bearbeitet von einem Moderator:

Dodi.Hudori

Mitglied
okay, also wenn ich aus
Java:
a.shorten();
ein
Java:
shorten(a);
mache bekomme ich trotz allem wieder ne Fehlermeldung -.-

Code:
Cannot make a static reference to the non-static method shorten(RatNumber) from the type RatNumber
 
S

SlaterB

Gast
siehe auch mein Posting inklusive edit zwischendurch, geht ja drunter und drüber,
kannst du nachschauen was static bzw. nicht static heißt usw.?
da lohnt sich ruhig mal 2 Stunden zu lernen statt gleich einfach ne Frage zu stellen,


puh, da gibt es so viel zu korrigieren, die Methode könnte statisch gemacht werden, dazu die diversen anderen Fehler,
oder auch nicht statisch bleiben, dann kann der Parameter weg, dann war der alte Aufruf richtig,
dann mit eigenen Variablen arbeiten
(vergleiche toString(), arbeitet ja auch mit eigenen Variablen statt einem Parameter)

ohne fertigen Code zu posten hilft dir wohl alles wenig, ich belasse es vorerst soweit bei allgemeinen Anmerkungen,
vielleicht antworten ja andere konkreter oder du versuchst ein wenig selber und stellst etwas genauere Fragen,
die mir nicht nach 'ich probiere blind irgendwas aus, was genau kann ich auch gar nicht sagen, dabei kommen Fehler die ich nicht kenne, bitte korrigieren' aussehen

(sorry für zuviel Murren schon nach so kurzer Zeit ;) )
 

Toastiie

Neues Mitglied
Hast du keine Lerngruppe? ;)
Ansonsten, könntest du dich ja zu uns gesellen, wir wollten uns am Sonntag nämlich treffen um die Aufgaben zusammen zu lösen.
 

Suinos

Bekanntes Mitglied
[...]
wenn cih deinen Vorschlag einbaue:

Java:
	private final int num; //zaehler
	private final int denom; //nenner

bekomme ich in Zeile 35 den Fehler "The final field RatNumber.num cannot be
assigned" woran kann das liegen? ebenso in Zeile 74/75

Hast du gelesen was ich geschrieben habe?
Jetzt wird der Compiler eine Fehlermeldung ausgeben, falls die Variablen:

[...]
Irgendwo sonst gesetzt werden.
Das ist doch genau der ganze Sinn dahinter, eine Variable als
Code:
final
zu deklarieren: Der Compiler zeigt dir (zumindest zum Teil) deine Logikfehler auf!

Sieh dir doch die Zeilen an, welche bemängelt werden:
[JAVA=35]
r.num *= this.denom / r.denom;
[/code]
Was glaubst du denn, was hier geschieht?

-

Was sollte in dieser Methode
Code:
public RatNumber shorten(RatNumber r)
geschehen? (nur von der Logik / dem Sinn dieser Methode her, nicht in Details von Java-Code)
  • Was ist der Input? (Parameter)
  • Was geschieht mit dem Input? Soll dieser verändert werden?
  • Was ist der Output? (Rückgabewert)
  • Was geschieht mit dem eigenen Objekt? Soll dieses verändert werden?
Das sind ganz allgemeine Fragen, welche bei jeder Methode gestellt werden können.
Antworten darauf sollten möglichst durch den Code selber (aussagekräftiger Methoden- & Parametername) oder den Kommentar zu dieser Methode (javadoc) ersichtlich sein. (Vorzugsweise durch den Code selber)
Bevor du selber eine Methode erstellst, müssen dir die Antworten auf diese Fragen schon klar sein.

Mir hilft es enorm, wenn ich zuerst den Kommentar schreibe, und erst nachher den Inhalt der Methode, da ich mir dann vollkommen im Klaren sein muss, was dort alles geschehen muss.
Falls es mir schwer fällt den Kommentar zu schreiben, dann ist das ein Anzeichen dafür, dass mir nicht ganz klar ist, was geschehen soll.
Zeit für Stift, Papier & Pseudocode

-

Was sagt deine Aufgabenstellung dazu?
Hinweis: Es soll in den Methoden zum Addieren und Subtrahieren jeweils ein neues Objekt RatNumber zurückgegeben werden, This darf dabei also nicht verändert werden.
Hier steht nichts über die anderen Methoden, rein theoretisch könntest du also das
Code:
final
weglassen,
und dann ein paar Methoden haben, welche das Objekt nicht verändern, und ein paar andere Methoden haben welche einfach in die Werte schreiben.

Theoretisch.

Gründe für das weglassen von
Code:
final
:
  • ... mir fällt jetzt gerade nichts ein ...
Gründe gegen das weglassen von
Code:
final
:
  • Inkonsistente API, macht das ganze weniger durchschaubar
  • Keine Compilerfehler mehr, welche dir genau sagen was und wo das Problem ist, ...
  • ... sondern 'merkwürdiges' Verhalten zur Laufzeit, bei welchem du in mühseliger Arbeit all deinen Code nochmals prüfen musst

---

Das ändert dann aber immer noch nichts an der Tatsache, dass (versucht wird) das Objekt in dieser Methode zu verändern, was dem Compiler aber nicht passt.

Schlussendlich könnte es so aussehen:
Java:
a = a.shorten();
 
T

TryToHelp

Gast
Deinen Einwänden / Hinweisen stimme ich zu
...
Das ändert dann aber immer noch nichts an der Tatsache, dass (versucht wird) das Objekt in dieser Methode zu verändern, was dem Compiler aber nicht passt.
Ja aber nur wenn er dein final drinnen hat, ohne das final geht es, mit dem final, muss er die shorten funktion umendern, in dem er es in eine neue Varaible speichert.
Java:
a = a.shorten();
Ja das würde reichen, aber nicht mit dem funktionskopf den er hat, da seine funktion momentan ein parameter erwatet das sie bearbeitet, was ja einen fehler wirft ;-)
Java:
// so sollte die funktion eher aussehen
public RatNumber shorten() {
        int ggt = ggt(this.num, this.denom);
        return new RatNumber(this.num/ggt, this.denom/ggt);
    }
// und dann so der aufruf
a = a.shorten();
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
C Rechnen mit Brüchen, ist meine Lösung soweit richtig? Java Basics - Anfänger-Themen 4
P Rechnen mit Brüchen - objektorientierte Programmierung Java Basics - Anfänger-Themen 18
C Kann mir jemand sagen warum ich nicht mal rechnen kann ? Java Basics - Anfänger-Themen 32
Liroyd Methode mit Objektvariabel rechnen? Java Basics - Anfänger-Themen 6
I Output BigDecimal anstatt double / Problem beim Rechnen Java Basics - Anfänger-Themen 16
Zeppi Geteilt rechnen Java Basics - Anfänger-Themen 2
D Mit Objekten rechnen, Textfield, JavaFX, Noob Java Basics - Anfänger-Themen 8
L Mit Zahlen im String rechnen Java Basics - Anfänger-Themen 19
L Datentypen Rechnen und abrunden mit double Java Basics - Anfänger-Themen 7
S Hamster Simulator rechnen lernen Parameter int Java Basics - Anfänger-Themen 6
D Operatoren Mit Objekten rechnen Java Basics - Anfänger-Themen 7
S Rechnen mit MaxValue Java Basics - Anfänger-Themen 7
L Rechnen mit Objekten Java Basics - Anfänger-Themen 3
W Erste Schritte Rechnen mit Schleifen? Denkanstoß gesucht Java Basics - Anfänger-Themen 15
W Seltames Problem bei Rechnen mit BigIntegers Java Basics - Anfänger-Themen 2
A Rechnen mit Text und Zahl Java Basics - Anfänger-Themen 4
S Jede Ziffer einer Zahl auslesen, damit rechnen und beim Ergebnis wiederholen ? Java Basics - Anfänger-Themen 20
S Dezimalzahlen rechnen Java Basics - Anfänger-Themen 3
kilopack15 Rechnen mit großen Zahlen Java Basics - Anfänger-Themen 6
D Rechnen mit numerischen Datentyp Frage Java Basics - Anfänger-Themen 16
E Best Practice Exaktes Rechnen mit (Pseudo-)Rationalen/Realen Zahlen. Operations Zuweisung für (eigene) Klassen Java Basics - Anfänger-Themen 3
1 Mit Java Rechnen Java Basics - Anfänger-Themen 10
T Einstieg in "grafische Progammierung" + Rechnen in Flussdiagramm Java Basics - Anfänger-Themen 2
W Variablen float rundet beim Bruch rechnen Java Basics - Anfänger-Themen 3
N Oracle SQL mit Zwischenergebnis rechnen Java Basics - Anfänger-Themen 2
Y Variable Menge von Objekten erzeugen und mit ihren Attributen rechnen Java Basics - Anfänger-Themen 7
S Double mithilfe eines Scanners so einlesen, dass ich damit rechnen kann Java Basics - Anfänger-Themen 4
J Char-Rechnen Java Basics - Anfänger-Themen 8
A Rechnen mit Set/Get? Java Basics - Anfänger-Themen 2
Z Erste Schritte Instanzmethoden Rechnen (Bruch) Java Basics - Anfänger-Themen 18
M Mit Werten aus Arrays in anderen Methoden rechnen? Java Basics - Anfänger-Themen 3
J Mit Datum rechnen Java Basics - Anfänger-Themen 11
F Erste Schritte [GUI] Dual in Dezimal rechnen Java Basics - Anfänger-Themen 5
D rechnen mit Stunden und Minuten Java Basics - Anfänger-Themen 14
N mit Werten aus einer mysql datenbank in java rechnen Java Basics - Anfänger-Themen 17
G Rechnen mit Long Variablen Java Basics - Anfänger-Themen 4
N Probleme beim Rechnen mit Integer und double Java Basics - Anfänger-Themen 4
W Variablen Rechnen mit "char" Java Basics - Anfänger-Themen 2
Joew0815 Compiler-Fehler Unexpected Type - Problem mit Variablen rechnen Java Basics - Anfänger-Themen 7
F Werte aus Tabelle vergleichen/rechnen Java Basics - Anfänger-Themen 5
C Mit Potenzen rechnen "Problem" Java Basics - Anfänger-Themen 3
M Mit Array rechnen Java Basics - Anfänger-Themen 9
T Rechnen in Arrays Java Basics - Anfänger-Themen 11
B von Ergebniss weiter rechnen Java Basics - Anfänger-Themen 3
S Rechnen mit Datum bzw. Uhrzeit Java Basics - Anfänger-Themen 3
S Datentypen Operatoren und Ausdrücke (formel richtig rechnen) Java Basics - Anfänger-Themen 8
N Mit long rechnen Java Basics - Anfänger-Themen 2
K Übungsblatt 13 Aufgabe 6 (Rechnen) Java Basics - Anfänger-Themen 12
C Mit Gleitkommazahlen rechnen Java Basics - Anfänger-Themen 20
T Rechnen mit Operatoren Java Basics - Anfänger-Themen 2
W Mit (char) rechnen Java Basics - Anfänger-Themen 3
F Mit Arrays rechnen Java Basics - Anfänger-Themen 12
H Datentypen Rechnen mit signed Byte-Array - unsinged byte Java Basics - Anfänger-Themen 3
B mit benutzereingaben rechnen Java Basics - Anfänger-Themen 4
L Bruch rechnen Java Basics - Anfänger-Themen 29
B mit Datum rechnen Java Basics - Anfänger-Themen 10
D Rechnen mit int Array Java Basics - Anfänger-Themen 9
M mit Uhrzeit rechnen Java Basics - Anfänger-Themen 11
T mit Winkel & Sinus rechnen / sin(30°)=2,5 Java Basics - Anfänger-Themen 7
A Rechnen mit big integer Java Basics - Anfänger-Themen 29
L Mit matrizen rechnen Java Basics - Anfänger-Themen 19
W Probleme mit double rechnen Java Basics - Anfänger-Themen 4
J Datentypen Rechnen mit unterschiedlichen Datentypen Java Basics - Anfänger-Themen 3
K mit einer int rechnen Java Basics - Anfänger-Themen 10
M Warum -48 rechnen? Java Basics - Anfänger-Themen 3
K Java Code rechnen Java Basics - Anfänger-Themen 7
F Rechnen mit komplexen Zahlen Java Basics - Anfänger-Themen 23
C Datentypen Unklarheiten beim Rechnen Java Basics - Anfänger-Themen 5
W Modulo rechnen Java Basics - Anfänger-Themen 3
H Datentypen Rechnen und Runden Java Basics - Anfänger-Themen 2
S Rechnen mit Zeitangaben Java Basics - Anfänger-Themen 5
Binary.Coder Doppeltes Hashing verläuft in "Endlosscheife" beim rechnen per Hand Java Basics - Anfänger-Themen 8
F Mit Anzahl Startparametern rechnen Java Basics - Anfänger-Themen 17
T mit List<Integer> rechnen Java Basics - Anfänger-Themen 9
O einfaches rechnen mit zahlen Java Basics - Anfänger-Themen 4
K Stunden zusammen Rechnen Java Basics - Anfänger-Themen 4
T mit Typen Date rechnen Java Basics - Anfänger-Themen 6
S mit Werten aus 2D-Array rechnen Java Basics - Anfänger-Themen 32
J Anfänger-Problem: Rechnen mit Java Java Basics - Anfänger-Themen 3
J Mit Java exp Rechnen ? Java Basics - Anfänger-Themen 4
P Mit double und BigDecimal rechnen Java Basics - Anfänger-Themen 6
K Wie zerlege Ich einen String zum Rechnen? Java Basics - Anfänger-Themen 3
D Rechnen mit zwei Klassen Java Basics - Anfänger-Themen 19
J Mit Zeitzonen rechnen! Java Basics - Anfänger-Themen 3
G Float schneidet nach dem Rechnen auf eine Stelle ab Java Basics - Anfänger-Themen 9
L Eingeben Rechnen Ausgeben - Leider nicht so einfach Java Basics - Anfänger-Themen 31
G Mit tastatureingaben rechnen Java Basics - Anfänger-Themen 10
B Großer Java bug beim rechnen? Java Basics - Anfänger-Themen 66
S mit Strings rechnen Java Basics - Anfänger-Themen 16
D mit request.getParameter("x") rechnen Java Basics - Anfänger-Themen 3
T mit byte rechnen. ? Java Basics - Anfänger-Themen 8
MrTical Zahlen einlesen um damit zu rechnen Java Basics - Anfänger-Themen 5
Safado modulo rechnen Java Basics - Anfänger-Themen 5
F mit Dualzahlen rechnen Java Basics - Anfänger-Themen 5
J Rechnen mit Dualzahlen Java Basics - Anfänger-Themen 5
C Bedingtes Rechnen Java Basics - Anfänger-Themen 64
G mit Strings rechnen (Unicode) Java Basics - Anfänger-Themen 15
H Modulo rechnen Java Basics - Anfänger-Themen 17
T Rechnen Java Basics - Anfänger-Themen 3
G Taschenrechner.aber Rechnen bring ich nicht zam! Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Neue Themen


Oben