Polynome Übungsaufgabe uni

H

Heyoka955

Gast
Hallo Leute, ich habe ein Problem mit einer Uni aufgabe und zwar sollen wir eine Klasse schreiben wo wir ein Obhekt vom Typ Polynom programmieren sollen und ich habe schon die Instanzen festgelegt und doe Kontruktoren belegt jedoch scheitere ich bei der toAdd Methode und die restlichen. Ich werde die Aufgabe euch senden und die Aufgabenstellung un ddie junit Tests. Also die Polynomaufgabe. Ich würde gerne die junit Tests hochladen und mein Code aber weiß ich nicht wie das machen soll.
 

Anhänge

  • blatt06 (7).pdf
    67,9 KB · Aufrufe: 13
H

Heyoka955

Gast
Das sind die Tests
Java:
import static org.junit.Assert.*;
import org.junit.Test;
public class PolynomTest {
    Polynom p1 = new Polynom(2, 0, 1, 3);
    Polynom p2 = new Polynom(1, 2, 6, 5);
    Polynom p3 = new Polynom(3, 3, 0, 3);
    Polynom p4 = new Polynom(6, 4, 10, 5);
    Polynom p5 = new Polynom(8, 9, 6, 0);
    Polynom p6 = new Polynom(0, 2, 5, 8);
    Polynom p7 = new Polynom(6, 5, 4, 9);
    Polynom p8 = new Polynom(5, 7, 0, 1);
    [USER=5814]@test[/USER]
    public void constructor1() {
        Polynom p = new Polynom(5);
        assertEquals(5, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor2() {
        Polynom p = new Polynom(1, 2);
        assertEquals(12, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor3() {
        Polynom p = new Polynom(1, 2, 3);
        assertEquals(123, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void constructor4() {
        Polynom p = new Polynom(1, 2, 3, 4);
        assertEquals(1234, p.map(10), "constructor");
    }
    [USER=5814]@test[/USER]
    public void test1() {
        assertEquals("2*x^3 + x + 3", p1.toString(), "toString");
        assertEquals(21, p1.map(2), "map");
        assertEquals("6*x^2 + 1", Polynom.derivation(p1).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test2() {
        assertEquals("x^3 + 2*x^2 + 6*x + 5", p2.toString(), "toString");
        assertEquals(329, p2.map(6), "map");
        assertEquals("3*x^2 + 4*x + 6", Polynom.derivation(p2).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test3() {
        assertEquals("3*x^3 + 3*x^2 + 3", p3.toString(), "toString");
        assertEquals(2433, p3.map(9), "map");
        assertEquals("9*x^2 + 6*x", Polynom.derivation(p3).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test4() {
        assertEquals("6*x^3 + 4*x^2 + 10*x + 5", p4.toString(), "toString");
        assertEquals(25, p4.map(1), "map");
        assertEquals("18*x^2 + 8*x + 10", Polynom.derivation(p4).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test5() {
        assertEquals("8*x^3 + 9*x^2 + 6*x", p5.toString(), "toString");
        assertEquals(0, p5.map(0), "map");
        assertEquals("24*x^2 + 18*x + 6", Polynom.derivation(p5).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test6() {
        assertEquals("2*x^2 + 5*x + 8", p6.toString(), "toString");
        assertEquals(26, p6.map(2), "map");
        assertEquals("4*x + 5", Polynom.derivation(p6).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test7() {
        assertEquals("6*x^3 + 5*x^2 + 4*x + 9", p7.toString(), "toString");
        assertEquals(24, p7.map(1), "map");
        assertEquals("18*x^2 + 10*x + 4", Polynom.derivation(p7).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void test8() {
        assertEquals("5*x^3 + 7*x^2 + 1", p8.toString(), "toString");
        assertEquals(433, p8.map(4), "map");
        assertEquals("15*x^2 + 14*x", Polynom.derivation(p8).toString(), "derivation");
    }
    [USER=5814]@test[/USER]
    public void add1() {
        p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p6.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add2() {
        p2.add(p7);
        assertEquals("7*x^3 + 7*x^2 + 10*x + 14", p2.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add3() {
        p3.add(p4);
        assertEquals("9*x^3 + 7*x^2 + 10*x + 8", p3.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void add4() {
        p5.add(p1);
        assertEquals("10*x^3 + 9*x^2 + 7*x + 3", p5.toString(), "add");
    }
    [USER=5814]@test[/USER]
    public void sub1() {
        p7.subtract(p2);
        assertEquals("5*x^3 + 3*x^2 - 2*x + 4", p7.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub2() {
        p3.subtract(p5);
        assertEquals("-5*x^3 - 6*x^2 - 6*x + 3", p3.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub3() {
        p1.subtract(p6);
        assertEquals("2*x^3 - 2*x^2 - 4*x - 5", p1.toString(), "subtract");
    }
    [USER=5814]@test[/USER]
    public void sub4() {
        p4.subtract(p8);
        assertEquals("x^3 - 3*x^2 + 10*x + 4", p4.toString(), "subtract");
    }
 
    public static void assertEquals(int expected, int actual, String method) {
        System.out.print("Testing " + method + " ");
        if (expected != actual) {
            System.out.println("failed. Expected " + expected + " but got " + actual + ".");
            } else {
                System.out.println("succeeded.");
        }
    }
   
    public static void assertEquals(String expected, String actual, String method) {
        System.out.print("Testing " + method + " ");
        if (expected == null || !expected.equals(actual)) {
            System.out.println("failed.");
            System.out.println("## Expected:");
            System.out.println(expected);
            System.out.println("## Actual:");
            System.out.println(actual);
            if (expected.length() != actual.length()) {
             System.out.println("Length of the Strings differ. Expected "+ expected.length() + " but got " + actual.length());
            } else {
                System.out.println("Length are ok.");
                for (int i = 0; i < expected.length(); i++) {
                    if (expected.charAt(i) != actual.charAt(i)) {
                        System.out.println("Difference at position " + i + " expected " + expected.charAt(i) + " but got " + actual.charAt(i));
                    }
                }
            }
        } else {
            System.out.println("succeeded.");
        }
    }
}
 
Zuletzt bearbeitet von einem Moderator:
H

Heyoka955

Gast
Das ist mein Code. Brauche hilfe bei add und substract und ableitung
Java:
public class Polynom {
    int a;
    int b;
    int c;
    int d;
   
   
    public Polynom(int d) {
        this.d=d;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 1
     */
    public Polynom(int c, int d) {
        this.c=c;
        this.d=d;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 2
     */
    public Polynom(int b, int c, int d) {
         this.c=c;
        this.d=d;
        this.b=b;
    }
    /**
     * Konstruktor fuer Polynom mit Grad 3
     */
    public Polynom(int a, int b, int c, int d) {
        this.a=a;
        this.c=c;
        this.d=d;
        this.b=b;
    }
    /**
     * Addiere ein weiteres Polynom auf die aktuelle Instanz.
     *
     * @param p Polynom, welches auf die aktuelle Instanz addiert werden soll
     */
    public void add(Polynom p) {
       
    }
 
    /**
     * Subtrahiere ein Polynom von der aktuellen Instanz.
     *
     * @param p Polynom, welches von der aktuellen Instanz subtrahiert werden soll
     */
    public void subtract(Polynom p) {
        // TODO
    }
    /**
     * Berechne den Wert des Polynoms an der uerbgebenen Stelle x.
     *
     * @param x Wert von x
     * [USER=49078]@Return[/USER] Resultat der Berechnung an der Stelle x
     */
    public int map(int x) {
        // TODO
        return 0;
    }
    /**
     * Berechne die Ableitung eines Polynoms und gebe das Ergebnis als neue Instanz/neues Objekt zurueck.
     *
     * @param p Polynom dessen Ableitung berechnet werden soll
     * [USER=49078]@Return[/USER] Neues Polynom, welches die Ableitung des Polynoms p darstellt
     */
    public static Polynom derivation(Polynom p) {
        // TODO       
        return null;
    }
    /**
     * Erzeugt eine lesbare Darstellung des Polynoms (z.B. 8*x^3 + 9*x^2 + 6*x).
     * Weitere Beispiele finden Sie in den beiliegenden Tests.
     *
     * [USER=49078]@Return[/USER] Polynom als lesbare darstellung als String-Objekt.
     */
    public String toString() {
        // TODO
        return "";
    }
}
 
Zuletzt bearbeitet von einem Moderator:

httpdigest

Top Contributor
Zu "add": Na überleg doch mal. Wenn du die (a, b, c, d)-Koeffizienten des Polynoms `ax³ + bx² + cx + d` hast, und du addierst jetzt die Koeffizienten (e, f, g, h) dazu, die dem Polynom `ex³ + fx² + gx + h` entsprechen. Was hast du dann als Ergebnis?
Oder als einfachere Aufgabe mit konkreten Werten: Was ist das Ergebnis von `2 + 3`? Richtig: 5. Und `2` kann ja gesehen werden als das Polynom: `0x³ + 0x² + 0x + 2`, sowie `3` als das Polynom `0x³ + 0x² + 0x + 3`. Vielleicht noch ein Beispiel: `2x + 3x`? Richtig: `5x`. Und `2x + 1` + `3x + 2`?
Ich hoffe, das grundlegende Prinzip sollte jetzt klar geworden sein. :)
Bezüglich "derivation": Das ist 11./12. Klasse Stoff Differentialrechnung. Also einfach Ableitung eines Polynoms.

Einfachste Schul-Algebra. Das ist noch weit von Uni-Level entfernt. :)
 
H

Heyoka955

Gast
das üroblem ist wie bekomme ich die werte vom objekt Polynom p in die toadd Methode rein?
ich habe das objekt Polynom p übergeben bekommen und das ist wieder eine polynomgleichung des dritten grades und dieses objekt soll ich auf das vorherige addieren. mein Problem ist wie bekomme ich da die werte raus aus dem übergebenen objekt polnyom p? ich hatte vor das objekt polyno p zu casten und dann eine get Methode für alle Variablen im P zu returnen umso darauf zuzugreifen aber leider ist dies zu aufwendig. Gibt es eine alternative?
 

httpdigest

Top Contributor
Java:
public void add(Polynom p) {
  System.out.println(p.a); // <- gibt 'a' von 'p' aus
  // Jetzt musst du natürlich das machen, was eigentlich in 'add' erwartet wird
}
 
H

Heyoka955

Gast
Java:
public void add(Polynom p) {
  System.out.println(p.a); // <- gibt 'a' von 'p' aus
  // Jetzt musst du natürlich das machen, was eigentlich in 'add' erwartet wird
}
public void add(Polynom p) {
a = a + p.a;
b = b + p.b;
c = c + p.c;
d = c + p.d;
}

So habe ich das gemacht jetzt ?
 

MoxxiManagarm

Top Contributor
Ganz ehrlich, ich finde bei der Aufgabe die toString Methode am herausfordernsten ^^
Ableitung: f(x)=2⋅x^3 → f′(x)=2⋅(3⋅x^(3−1))=6⋅x^2
 

MoxxiManagarm

Top Contributor
map ist die Berechnung der Formel mit x als Parameter.
map(3) -> Gib Ergebnis von a * 3^3 + b * 3^2 + c*3 + d

Bei der Ableitung erstellst du ein neues Polynom. Beim neuen Polynom ist a immer 0. b vom neuen Polynom ist dann 3 * a usw
 
H

Heyoka955

Gast
habe den fehler längst geändert bei der letzten Zuweisung aber verstehe das mit der Ableitung nicht bei int map nicht genau?

ich habe das so gemacht jetzt
this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
 

MoxxiManagarm

Top Contributor
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
 
H

Heyoka955

Gast
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
ist doch das ?


this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
 
H

Heyoka955

Gast
Nein Map ist einfach die Berechnung deines Polynoms mit eingesetztem x (Parameter) für x.
Da ist nichts anderes als eine ausgeführte Berechnung. Keine Zuweisung, nur ein return

Und bei der Ableitung (derive) erstellst du ein neues Polynom.
public int map(int x) {
this.a = a*x*x*x;
this.b = b*x*x;
this.c = c*x;
this.d = d;
int result = a + b + c + d;

return result;
}
das hier
 

MoxxiManagarm

Top Contributor
Nein, du solltest a keinen neuen Wert zuweisen. Damit veränderst du das Polynom selbst ja. Du willst aber das Polynom nur berechnen, nicht verändern.
 
H

Heyoka955

Gast
public int map(int x) {


int result = a*x*x*x + b*x*x + c*x + d;

return result;
}

so geht aucgh oder? ist meine toAdd Methode auch nicht falsch dann?
 

MoxxiManagarm

Top Contributor
Führe ihn einfach aus, der sagt dir das Meiste... Ansonsten der Test hat verschiedene Polynome initial. @test wird durchgeführt beim Run. In der Methode steht welche Polynome vewendet werden und was erwartet wird.
 

MoxxiManagarm

Top Contributor
Beispiel:

Java:
Polynom p5 = new Polynom(8, 9, 6, 0);
    Polynom p6 = new Polynom(0, 2, 5, 8);

@Test
    public void add1() {
        p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p6.toString(), "add");
    }

Das Ergebnis wird auf Basis von p6 asserted. Also hält p6 das Ergebnis. Wäre es ein neues Polynom würde es heißen:
Java:
@Test
    public void add1() {
        Polynom p = p6.add(p5);
        assertEquals("8*x^3 + 11*x^2 + 11*x + 8", p.toString(), "add");
    }
 
H

Heyoka955

Gast
achso verstehe also ändern wir die Zuweisung so gesehen, verstehe aber wie lese ich das bei int map also den x wert? anhand vom test ?
 

MoxxiManagarm

Top Contributor
Eventuell garnicht. Es macht einfach nur keinen Sinn das Polynom bei einer einfachen Berechnung zu verändern. Vielleicht willst du das Gleiche Polynom ja nochmal verwenden und für ein anderes x ausrechnen.
 
H

Heyoka955

Gast
Eventuell garnicht. Es macht einfach nur keinen Sinn das Polynom bei einer einfachen Berechnung zu verändern. Vielleicht willst du das Gleiche Polynom ja nochmal verwenden und für ein anderes x ausrechnen.
Bro wie mache ich das x bei der Ableitung ? Ich weiß nicht wie ich das x mit einbeziehen soll? Ich wollte das x einfach als ein String behandeln
 

httpdigest

Top Contributor
Du "machst das x" überhaupt nicht bei der Ableitung. Die Ableitung soll einfach die Koeffizienten der ersten Ableitung des Polynoms `ax³ + bx² + cx + d` berechnen und daraus ein neues Polynom-Objekt bauen, mit eben den neuen Koeffizienten, die sich aus der Ableitung ergeben haben.

Fürs erste: Ermittle für das allgemeine Polynom `ax³ + bx² + cx + d` (ohne jetzt konkrete Werte für a, b, c oder d zu haben) die Ableitung. Also rein symbolisch auf Papier.
 

MoxxiManagarm

Top Contributor
"ax³ + bx² + cx + d" speicherst du in der Form garnicht, du speicherst nur a b c d und weißt, dass a der Wert vor x^3 ist. Für die Ableitung verwendest du die Produktregel
Demnach ist f'(x) = (3*a) x^2 + (2*b) x + c

Du hast ein vollkommen neues Polynom mit a = 0 und einem neuen b c d in Abhängigkeit von den vorherigen a b c.
Demnach ist das b vom neuen Polynom a*3 vom alten Polynom usw.
 

MoxxiManagarm

Top Contributor
Vielleicht hilft dir das noch:

Java:
public static Polynom derivation(Polynom p) {
    return new Polynom(/*new a*/, /*new b*/, /*new c*/, /*new d*/);
}

Ich habe schon so viel geschrieben, eigentlich könnte ich dir schon fast die Lösung anstatt der /**/-comments reinschreiben. Was du für a-d einsetzen musst steht in mehreren Vorgängerbeiträgen. Ich hoffe aber dass es bei dir nun endlich mal Klick macht und du die Zeile selber vervollständigen kannst.
 
H

Heyoka955

Gast
Vielleicht hilft dir das noch:

Java:
public static Polynom derivation(Polynom p) {
    return new Polynom(/*new a*/, /*new b*/, /*new c*/, /*new d*/);
}

Ich habe schon so viel geschrieben, eigentlich könnte ich dir schon fast die Lösung anstatt der /**/-comments reinschreiben. Was du für a-d einsetzen musst steht in mehreren Vorgängerbeiträgen. Ich hoffe aber dass es bei dir nun endlich mal Klick macht und du die Zeile selber vervollständigen kannst.


public static Polynom derivation(Polynom p) {

return 3*p.a + 2*p.b + p.d;
}

zeigt leider ein fehler an dass er das objekt nicht in int konevrtieren kann
 

MoxxiManagarm

Top Contributor
Nein du gibst ein neues Polynom-Objekt zurück. derivation heißt die statische Methode. Auf Deutsch heißt derivation soviel wie ableiten. Es ist also deine Ableitungsmethode
 

mihe7

Top Contributor
derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:
Code:
Polynom derivation(Polynom eingabe)
Das, was vor dem Methodennamen steht, ist der Typ der Rückgabe, das was in den Klammern steht, sind Typen und Namen der Parameter (hier nur ein Parameter vom Typ Polynom mit dem Namen eingabe).
 
H

Heyoka955

Gast
derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:
Code:
Polynom derivation(Polynom eingabe)
Das, was vor dem Methodennamen steht, ist der Typ der Rückgabe, das was in den Klammern steht, sind Typen und Namen der Parameter (hier nur ein Parameter vom Typ Polynom mit dem Namen eingabe).
Ja aber er gibt doch so gesehen ein neues polybom Objekt Namens derivation zurück ?
 

MoxxiManagarm

Top Contributor
Aber du solltest doch auch langsam mal an die toString Methode machen. Von allen Methoden die du ergänzen sollst ist das entsprechend den Tests nämlich die Komplexeste. Alles andere sind 1-4 Zeiler.

Natürlich wäre es schön, wenn du einfach schreiben könntest:
Java:
return a + "*x^3 + " + b + "*x^2 + " + c + "*x + " + d;

Aber es sind verschiedene Fälle zu betrachten wie z.B.
0-Werte & Negative Werte

Ja aber er gibt doch so gesehen ein neues polybom Objekt Namens derivation zurück ?
Nein das Polynom hat keinen "Namen" in dem Sinne.
 

MoxxiManagarm

Top Contributor
Wer weiß, vielleicht magst du ja noch weiter gehen, falls der Groschen irgendwann mal bei dir fällt.

Hier ein paar Ideen, vielleicht helfen Sie auch beim Verständnis...
Java:
/**
 * Provides the order of the polynom
 */
public int getOrder() {
    if(a != 0) return 3;
    if(b != 0) return 2;
    if(c != 0) return 1;
    return 0;
}

/**
 * Multiplicates two polynoms, if the resulting order is not higher then 3
 */
public void mult(Polynom p) throws IllegalArgumentException {
    if(getOrder() + p.getOrder() > 3) throw new IllegalArgumentException("Result order not capable.");
 
    this.a = this.d * p.a + this.c * p.b + this.b * p.c + this.a * p.d;
    this.b = this.d * p.b + this.c * p.c + this.b * p.d;
    this.c = this.d = p.c + this.c * p.d;
    this.d = this.d * p.d;
}

/**
 * Checks, if the given x is a null point. f(x) = 0
 */
public boolean isNullPoint(int x) {
    return map(x) == 0;
}

/**
 * Provides any null point in the given range low <= x <= high
 */
public int guessNullPoint(int low, int high) throws NoSuchElementException {
    for(int x = low; x <= high; x++) {
        if(isNullPoint(x)) return x;
    }
 
    throw new NoSuchElementException("No integer null point in the given range.");
}

// public int[] getNullPoints() throws /*...*/ {}
// public void div(Polynom p) throws /*...*/ {}
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Ja klar sprachlich ncijt aber von Aspekt der Programmierung. Also was da abläuft.
Da ist es nicht anders. Du rufst eine Funktion mit Parametern auf und bekommst ggf. irgendwas zurück.

Ich versuch es mal einfach, wenn auch nicht ganz korrekt.

Das, was Du zurückbekommst, hat aber keinen Namen (genauso wenig, wie die Summe vorhin). Um dem Spaß einen "Namen zu verpassen", musst Du den Rückgabewert einer Variablen zuweisen.

Beispiel:
Java:
int add(int a, int b) {
    return a + b;
}

Fall 1: Du führst folgendes aus:
Java:
add(3, 4);

Dabei wird die Methode add mit den Parametern 3 und 4 aufgerufen. In der Methode wird 3 + 4 berechnet und das (namenlose) Ergebnis (7) zurückgegeben. Mit dem Ergebnis passiert weiter nichts, d. h. Du hast nach dieser Anweisung keine Möglichkeit mehr, auf das Ergebnis zuzugreifen. Das wäre in diesem Fall natürlich ziemlich sinnlos.

Fall 2:
Java:
int ergebnis = add(3, 4);
Jetzt wird das Ergebnis (die 7) der Variablen "ergebnis" zugewiesen. Nach dieser Anweisung kannst Du auf das Ergebnis über die Variable "ergebnis" zugreifen. Zum Beispiel könntest Du das Ergebnis ausgeben lassen: System.out.println(ergebnis);

Fall 3:
Java:
int ergebnis = add(add(3,4), 5);
Hier wird zuerst add(3, 4) ausgeführt. Dieser Aufruf liefert das (namenlose) Ergebnis 7. Daher wird im zweiten Schritt add(7, 5) ausgeführt. Dieser Aufruf liefert als Ergebnis dann 12, das abschließend der Variable ergebnis zugewiesen wird.

Dir muss klar sein, dass die Daten eines jeden Objekts im Hauptspeicher an jeweils anderer Stelle abgelegt werden. Die in der Klasse deklarierten Variablen existieren sozusagen für jedes Objekt separat.

Java:
Polynom p1 = new Polynom(1,2,3,4);
Polynom p2 = new Polynom(5,6,7,8);
Hier werden zunächst zwei Instanzen (Objekte) der Klasse Polynom erzeugt. Das erste Objekt wird der Variablen p1 zugewiesen, das zweite der Variablen p2. Tatsächlich verhält es sich ein wenig anders, ich will Dich jetzt aber nicht zusätzlich verwirren. Wichtig ist: mit p1 und p2 kannst Du auf zwei verschiedene Objekte zugreifen.

Mit p1.a = 10; würde man also die Variable a von Objekt p1 verändern. Die Variable a von Objekt p2 dagegen bliebe unverändert.
 
Zuletzt bearbeitet von einem Moderator:
Ähnliche Java Themen
  Titel Forum Antworten Datum
X Polynome implementieren Java Basics - Anfänger-Themen 3
G Polynome Java Basics - Anfänger-Themen 3
G Polynome Java Basics - Anfänger-Themen 3
A Laufzeitfehler bei Übungsaufgabe Java Basics - Anfänger-Themen 4
jonathanpizza Hilfe bei einer Übungsaufgabe Java Basics - Anfänger-Themen 6
K Rundbeet Übungsaufgabe Java Basics - Anfänger-Themen 3
J Hilfe bei Übungsaufgabe Java Basics - Anfänger-Themen 17
Z Unklarheit bei Übungsaufgabe [Anfänger] Java Basics - Anfänger-Themen 22
H Übungsaufgabe Java Basics - Anfänger-Themen 21
K Übungsaufgabe... Verständnisproblme (java 8.191) Java Basics - Anfänger-Themen 4
H Übungsaufgabe algorithmen Java Basics - Anfänger-Themen 2
L Übungsaufgabe zu Schleifen Java Basics - Anfänger-Themen 7
H Frage zu Übungsaufgabe, Array Java Basics - Anfänger-Themen 7
T Übungsaufgabe Event Handling Java Basics - Anfänger-Themen 0
T Übungsaufgabe abstrakte Klasse Java Basics - Anfänger-Themen 21
B Hilfe bei Übungsaufgabe von Freitagsrunde Java Basics - Anfänger-Themen 5
B Übungsaufgabe Java Basics - Anfänger-Themen 5
M Übungsaufgabe Problem Java Basics - Anfänger-Themen 6
N Übungsaufgabe aus Java Buch bringt Fehler. Java Basics - Anfänger-Themen 10
B Übungsaufgabe zu Klassen, Methoden ... Java Basics - Anfänger-Themen 2
K Methoden Uhr als Übungsaufgabe Klassen/Objekte Java Basics - Anfänger-Themen 3
S Verständnisproblem einer Übungsaufgabe Java Basics - Anfänger-Themen 6
J Hilfe bei Übungsaufgabe Java Basics - Anfänger-Themen 5
D Brauche Hilfe bei Modulo (Übungsaufgabe) Java Basics - Anfänger-Themen 14
U Erste Schritte Fehler in Übungsaufgabe Java Basics - Anfänger-Themen 22
W Übungsaufgabe:Dynamische Datenstrukturen Java Basics - Anfänger-Themen 10
pg1337 Übungsaufgabe für Anfänger Java Basics - Anfänger-Themen 26
N Übungsaufgabe mit static Wert Java Basics - Anfänger-Themen 27
P Datentypen Frage zu einer Übungsaufgabe Java Basics - Anfänger-Themen 15
N Übungsaufgabe mit Interface Java Basics - Anfänger-Themen 2
F Schleifen Übungsaufgabe Java Basics - Anfänger-Themen 4
A Übungsaufgabe lösen - Problem mit true und false Java Basics - Anfänger-Themen 6
D Schiedermeier 1. Semester Übungsaufgabe Problem Java Basics - Anfänger-Themen 8
C Übungsaufgabe Java Basics - Anfänger-Themen 10
R Problem bei Übungsaufgabe Java Basics - Anfänger-Themen 7
M Hilfe bei Übungsaufgabe :'( nooby Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben