Polynome Übungsaufgabe uni

[Heyoka955]

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.

 

[Heyoka955]

Das sind die Tests

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.");
        }
    }
}

 

[Heyoka955]

Das ist mein Code. Brauche hilfe bei add und substract und ableitung

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 "";
    }
}

 

[httpdigest]

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.

 

[Heyoka955]

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]

das üroblem ist wie bekomme ich die werte vom objekt Polynom p in die toadd Methode rein?

Benutze den "Punktoperator", also: p.a bzw. p.b bzw. p.c bzw. p.d.

Die Methode "add" (und weitere in der Klasse Polynom) sind ja in der Klasse selbst deklariert, haben also Zugriff auf die a, b, c, d Felder.

 

[Heyoka955]

Benutze den "Punktoperator", also: p.a bzw. p.b bzw. p.c bzw. p.d.

Die Methode "add" (und weitere in der Klasse Polynom) sind ja in der Klasse selbst deklariert, haben also Zugriff auf die a, b, c, d Felder.

wie fern?

 

[httpdigest]

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
}

 

[Heyoka955]

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]

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

 

[Heyoka955]

ja aber was genau returne ich bei int map

 

[Heyoka955]

und wie gehe ich bei der Ableitung vor? wollte das mit for schleife machen aber ka

 

[MoxxiManagarm]

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

 

[Dompteur]

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 ?

Schau dir noch einmal die letzte Zuweisung an.

 

[Heyoka955]

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]

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.

 

[Heyoka955]

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;

 

[Heyoka955]

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]

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.

 

[Heyoka955]

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.

wie genau mache ich das?
habe es so gemacht jetzt

public int map(int x) {


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

return result;
}

 

[MoxxiManagarm]

ganz einfach so

public int map(int x) {
        return a * x * x * x
                + b * x * x
                + c * x
                + d;
    }

 

[Heyoka955]

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]

Ja das geht auch. Bei der add Methode musst du zuweisen. Da veränderst du das Polynom.

 

[Heyoka955]

Ja das geht auch. Bei der add Methode musst du zuweisen. Da veränderst du das Polynom.

wie nimmt man sowas aus der aufgabe heraus?

 

[MoxxiManagarm]

Nicht zwingend der Aufgabe, aber deinem Testcase. Der Testcase ist so konzipiert, dass du das tust.

 

[Heyoka955]

verstehe den test zu verstehen ist schwer ( wie liest man denn genau so einen test?

 

[MoxxiManagarm]

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.

 

[Heyoka955]

okay aber wie weiß ich ob ich di epolynome neu zuweisen musst oder nicht?

 

[MoxxiManagarm]

Beispiel:

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:

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

 

[Heyoka955]

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]

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.

 

[Heyoka955]

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]

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]

"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]

Vielleicht hilft dir das noch:

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.

 

[Heyoka955]

Vielleicht hilft dir das noch:

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

 

[mihe7]

Bro

Oje.

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

Lesen, was @MoxxiManagarm schreibt, würde helfen.

 

[Heyoka955]

Oje.


Lesen, was @MoxxiManagarm schreibt, würde helfen.

so habe ich das gemacht ! kompliiert auch
return new Polynom(p.a*3, p.b*2, p.c)

 

[mihe7]

Aha, geht doch. Hast Du auch verstanden, was hier passiert oder nur die Lösungen abgeschrieben?

 

[Heyoka955]

Aha, geht doch. Hast Du auch verstanden, was hier passiert oder nur die Lösungen abgeschrieben?

halb eher abgeschrieben.

 

[mihe7]

halb eher abgeschrieben.

Das ist nicht gut. Wo gibts Verständnisprobleme?

 

[Heyoka955]

w

halb eher abgeschrieben.

wir keigen ein objekt rein vom typ p und geben ein neues objekt vom typ derivatiob zuürck.

 

[MoxxiManagarm]

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]

derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:

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).

 

[Heyoka955]

derivation ist nur der Name der Funktion. Der Parameter und die Rückgabe sind vom Typ Polynom:

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]

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:

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.

 

[mihe7]

Ja aber er gibt doch so gesehen ein neues polybom Objekt Namens derivation zurück

Stell Dir einfache eine mathematische Funktion vor: f:NxN->N mit f(a,b) := a+b
Da sagst Du ja auch nicht, Du gibst eine Summe mit dem Namen f zurück.

 

[Heyoka955]

Stell Dir einfache eine mathematische Funktion vor: f:NxN->N mit f(a,b) := a+b
Da sagst Du ja auch nicht, Du gibst eine Summe mit dem Namen f zurück.

Ja klar sprachlich ncijt aber von Aspekt der Programmierung. Also was da abläuft.

 

[MoxxiManagarm]

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...

/**
 * 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 /*...*/ {}

 

[mihe7]

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:

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

Fall 1: Du führst folgendes aus:

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:

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:

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.

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.