Create a polynom and do some calculations with it.

Polynom.java

// Polynom.java

 /* Anmerkung: In diesem Programm werden keine negativen Koeffizienten erzeugt,
  * d.h., dass Polynome mit positivem Grad niemals Nullstellen besitzen.
  *
  * Außerdem wird die Nullstellenberechnung bei sehr hohem Grad des Polynoms
  * ungenau, was wohl an Rundungsfehlern liegt.
  */

import java.util.*;
import java.io.*;

public class Polynom {

  private int[] coeff;
  private int grad;

  protected Polynom() {
    //Identitaetsfunktion erzeugen
   
    this.grad = 1;
    coeff = new int[grad+1];
    coeff[0] = 0;
    coeff[1] = 1;

  } //Ende Polynom


  protected Polynom(int grad) {
    //Konstruktur, der gewuenschte Gradzahl uebergeben bekommt

      this.grad = grad;
      Random rnd = new Random();
      coeff = new int[grad+1];
      int i = 0;

      for (i = 0; i < grad; i++ ) {
        coeff[i] = (rnd.nextInt(10))+1; //Die Koeffizienten sind <= 10
      }                                 //Negative Koeffizienten sind nicht vorgesehen

      coeff[i] = (rnd.nextInt(10))+1;

  } //Ende Polynom


  protected void fktWert(int x) {
    //Berechnen des Funktionswertes fuer ein einzusetzendes x

    int fktWert = 0;
    int i = 0;
    int j = coeff.length - 1;

    while (i != coeff.length - 1) {
      fktWert += coeff[i] * Math.pow(x, j);
      i++;
      j--;
    }

    fktWert += coeff[i];

    System.out.println();
    System.out.println();
    System.out.println("Der Funktionswert fuer x = " + x + " lautet: " + fktWert);
  } //Ende fktWert


  protected void newton() {
    //Finden einer Nullstelle mit dem Newton-Verfahren

    //1. Schritt: 1. Ableitung des Polynoms bilden
      System.out.println();
      System.out.println("Die 1. Ableitung des Polynoms lautet: ");

      int[] ableitung;
      ableitung = new int[coeff.length - 1];
      int i = 0;
      int j = coeff.length - 1;

      while (i < coeff.length - 1) {
        ableitung[i] = (coeff[i] * j);

        if (j-1 == 0) {
          System.out.print(ableitung[i]);
          break;
        }

        else {
          System.out.print(ableitung[i] + "x^" + (j-1) + " + ");
          i++;
          j--;
        }
      }

      System.out.println();
      System.out.println();

      //2. Schritt: Naeherungsweises Bestimmen einr Nullstelle
      //-> Verschiedene x-Werte sollen eingesetzt werden, um festzustellen,
      //wann der Funktionswert zwischen <0 und >0 wechselt

      int x = -5; //x-Werte von -5 bis 5 zur Wertetabellenerstellung

      double[] wertetabelle;
      wertetabelle = new double[2 * Math.abs(x) + 1]; //Wertetabelle mit 20 Plaetzen

      double[] grenze;  //Hier werden die zwei Werte gespeichert, zwischen denen die Nullstelle liegt
      grenze = new double[2];
      grenze[0] = 6;
      grenze[1] = 6; //"Dummy-Werte", um später Fehler bei der Array-Initialisierung zu vermeiden

      //Schleifen, die die Wertetabelle fuellen
      System.out.println("Die Wertetabelle für x = " + x + " bis " + Math.abs(x) + " lautet: ");

      i = 0;
      int k = 0; //Zweite Zaehlvariable
      j = coeff.length - 1;
      int sum = 0; //Zur Aufsummierung der einzelnen Funktionswerte

      while (i != wertetabelle.length) {

        while (k < coeff.length - 1) {
          sum += coeff[k] * Math.pow(x, j);
          k++;
          j--;
        }

        wertetabelle[i] = sum + coeff[k];

        if (wertetabelle[0] > 0) {
          System.out.println("... Unrelevant, denn dieses Polynom besitzt keine Nullstelle.");
          break;
        }

        else if (wertetabelle[i] == 0) {
          System.out.println("--------------------------------------------------------------");
          System.out.println("!--- Es wurde eine Nullstelle bei x = " + x + " gefunden! ---!");
          System.out.println("--------------------------------------------------------------");
        }

        else if (wertetabelle[i] > 0 && grenze[0] == 6 && grenze[1] == 6) {
          grenze[0] = x - 1;
          grenze[1] = x;
        }

        System.out.print("(" + wertetabelle[i] + ") ");
        i++;
        x++;
        k = 0;
        j = coeff.length - 1;
        sum = 0;
      }

      if (grenze[0] != 6 && grenze[1] != 6) {
        System.out.println();
        System.out.println();
        System.out.println("Die Nullstelle liegt irgendwo zwischen " + grenze[0] + " und " + grenze[1]);

      //3. Schritt: Nun wird der Wert von grenze, der dichter an 0 liegt, ueber mehrere
      //Iterationsschritte in die Formel eingefuegt, um die Nullstelle naeherungsweise
      //zu bestimmen

        double wert;

        if (Math.abs(grenze[1]) > Math.abs(grenze[0])) {
          wert = grenze[0];
        }
        else {
          wert = grenze[1];
        }

          System.out.println();
          System.out.println();
          System.out.println("Einzusetzender Wert wurde auf " + wert + " festgelegt.");
          System.out.println();

        double nullstelle = 0;

        //Nullstelle = wert - (/*wert eingesetzt in Ausgangspolynom*/ / /*Wert eingesetzt in 1. Ableitung*/);
        //-> ueber mehrere Iterationsschritte (Newton-Verfahren)

        k = 0;
        /*double zaehler = 0;
        double nenner = 0;
        i = 0;
        j = coeff.length - 1;*/

        while (k != 10) {

          i = 0;
          j = coeff.length - 1;
          double zaehler = 0;
          double nenner = 0;

          while (i != coeff.length - 1) {
            zaehler += coeff[i] * Math.pow(wert, j);
              //System.out.println("Zaehler Rechnung: " + coeff[i] + " * (" + wert + "^" + j + ") = " + (coeff[i] * Math.pow(wert, j)));
            i++;
            j--;
          }

          zaehler += coeff[i];

          i = 0;
          j = ableitung.length - 1;

          while (i != ableitung.length - 1) {
            nenner += ableitung[i] * Math.pow(wert, j);
              //System.out.println("Nenner Rechnung: " + ableitung[i] + " * (" + wert + "^" + j + ") = " + (ableitung[i] * Math.pow(wert, j)));
            i++;
            j--;
          }

          nenner += ableitung[i];

          nullstelle = wert - (zaehler / nenner);

            //System.out.println("Nullstelle Rechnung: " + wert + " - (" + zaehler + " / " + nenner + ") = " + nullstelle);

          wert = nullstelle;

          System.out.println("Nullstelle (Iteration #" + (k+1) + "): " + nullstelle);

          k++;
        }

        System.out.println();
        System.out.println("Die Nullstelle liegt naeherungsweise bei " + nullstelle);
        System.out.println();

      }

  } //Ende newton


  protected void add() {
    //Addition des Polynoms mit sich selbst

    while (true) {
      try {

        int[] summe;
        summe = new int[coeff.length + 1];
        int i = 0;

        while (i != coeff.length) {
          summe[i] = (coeff[i] * 2);
          i++;
        }

        int j = coeff.length;
        System.out.println();
        System.out.println("Die Addition des Polynoms mit sich selbst ergibt: ");

        for (i = 0; i != coeff.length; i++) {

          if (j-1 == 0) {
            System.out.print(summe[i]);
            break;
          }

          else {
            System.out.print(summe[i] + "x^" + (j-1) + " + ");
            j--;
          }

        }

        break;
      }

      catch (NullPointerException e) {
        System.out.println("Fehler - Null Pointer Exception: " + e.getMessage());
        break;
      }
    }
  } //Ende add


  protected void print() {
    //Gibt das Polynom auf die Konsole aus

    int i = 0;
    int j = 0;

    while(true) {
      try {
          j = coeff.length;
          System.out.println("Das generierte Polynom lautet: ");

          while (i != coeff.length) {

            if (j-1 == 0) {
              System.out.print(coeff[i]);
              break;
              }

              System.out.print(coeff[i] + "x^" + (j-1) + " + ");
              i++;
              j--;
            }

        break;
      }

      catch(NullPointerException e) {
        System.out.println("Error - Null Pointer Exception: " + e.getMessage());
        break;
      }
    }
  } //Ende print



  public static void main(String [] args) throws Exception {
  //Main-Funktion

    BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in));

    int n = 0;
    int auswahl = 100; //"Dummy-Wert"

    System.out.println();
    System.out.println("Polynom.java - Hausaufgabe 4");
    System.out.println("****************************");
    System.out.println();

    while (true) {
      try {
        System.out.print("Geben Sie die gewuenschte Gradzahl des Polynoms an: ");
        n = Integer.parseInt(keyboard.readLine());

        while (n < 0) {
          System.out.print("Grad muss >= 0 sein! Bitte erneut eingeben: ");
          n = Integer.parseInt(keyboard.readLine());
        }
        break;
      }

      catch (NumberFormatException e) {
        System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage());
      }
    }

    Polynom p = new Polynom(n);
    System.out.println();
    p.print();

    while (auswahl != 0) {

        System.out.println();
        System.out.println();
        System.out.println("  Menue");
        System.out.println("  ---------------------------");
        System.out.println("  [1] Funktionswert berechnen");
        System.out.println("  [2] Nullstelle berechnen");
        System.out.println("  [3] Polynom mit sich selbst addieren");
        System.out.println("  [0] Ende");
        System.out.print("  Bitte treffen Sie eine Auswahl: ");


        while (true) {
          try {
            auswahl = Integer.parseInt(keyboard.readLine());
            while (auswahl > 3 || auswahl < 0) {
              System.out.print("Ungueltige Auswahl - bitte erneut eingeben: ");
              auswahl = Integer.parseInt(keyboard.readLine());
            }
            break;
          }

          catch (NumberFormatException e) {
            System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage());
            auswahl = 100; //"Dummy-Wert"
            break;
          }
        }


          if (auswahl == 1) {

            System.out.println();
            System.out.println();
            System.out.print("Fuer welches Argument soll der Funktionswert berechnet werden?: ");
            int x = 0;

            while (true) {
              try {
                x = Integer.parseInt(keyboard.readLine());
                p.fktWert(x);
                break;
              }

              catch (NumberFormatException e) {
                System.out.println("Fehler - Number Format Exception bei Eingabe: " + e.getMessage());
                break;
              }

            }
          }

          if (auswahl == 2) {
            if (p.grad <= 2) {
              System.out.println();
              System.out.println("Fuer Polynome 2. Grades oder kleiner existieren in diesem Programm keine Nullstellen!");
              //...da das letzte konstante Glied des Polynoms immer positiv ist - siehe Konstruktor.
              //Dieser if-switch ist noetig, da sonst der Weg ueber grenze[0] und [1] nicht funktioniert.
              //-> siehe p.newton
            }
            else {
              p.newton();
            }
          }

          if (auswahl == 3) {
            p.add();
          }
        }

        System.out.println();
        System.out.println();

      }
}