Taschenrecher 3.0

import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.Locale;
import java.util.InputMismatchException;

public class Taschenrechner2 {

        public static void main(String[] args){

                DecimalFormat df = new DecimalFormat("###,###,###.###"); // Fuer die Uebersichlichkeit sont zu lange Nachkommastellen
                Locale.setDefault(Locale.GERMAN); // Deutsche Tastatur anstatt . jetzt , moeglich

                String wert = null; char vorzeichen = 0; Boolean while_schleife = true;  // String/Char/Boolean Variablen
                double berechneter_wert = 0; double wert_double = 0; // Double Variablen
                int pruefung_Werte = 0; int counter = 0; int hilfe = 1;
                Scanner scanner, scanner2; // Scanner Variablen

                System.out.println("Hallo beim Taschenrechner, die Operatoren + , - , * , ! = Fakultaet , ^ = Potenz / sind erlaubt. Parameter e für Beendigung \n");

                while(while_schleife) // Schleifenbedinung ist true außer wenn wir ein e eingeben dann wird der Boolean auf false gesetzt
                {
                        try
                        {
                            if(counter ==0)
                            {
                                System.out.println(eingabeHilfe(wert));
                                counter= 1;
                            }
                                System.out.println("Ihr Wert ist  " + df.format(berechneter_wert)+" | e=ende c=clear |");
                                scanner = new Scanner(System.in); // Konsolen eingabe

                                wert = scanner.nextLine();
                                vorzeichen = wert.charAt(0); // char vorzeichen den 0ten Wert zuweisen. z.b + - * /

                                scanner2 = new Scanner(wert.substring(1)); // substring nach der Stelle 1 der rest in Typ Scanner verweisen

                                switch (vorzeichen)
                                {
                                        case 'e': // | "" fuer String |  '' für char | int, double andere werte ist zahl nötig
                                                while_schleife=false; // Schleife Beendigt !
                                        case 'c':
                                                berechneter_wert = 0.0;
                                                break; // break sonst Fehlermeldung wegen Methode vom Scanner !
                                        case '!':
                                                pruefung_Werte = ganzZahl(berechneter_wert);
                                                if(pruefung_Werte == 0)
                                                {
                                                    throw new NotNaturalNumberException();
                                                }
                                                else
                                                {
                                                berechneter_wert = fakultaet_berechnung(pruefung_Werte);
                                                }
                                                break;
                                        case '^':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = potenz(berechneter_wert ,wert_double);
                                                break;
                                        case '+':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert + wert_double;
                                                break;
                                        case '-':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert - wert_double;
                                                break;
                                        case '*':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert * wert_double;
                                                break;
                                        case '/':
                                                wert_double = scanner2.nextDouble();
                                                if(wert_double != 0) // Wenn nextDouble keine 0 vom Substring dann geht if sonst else -> Fehlermeldung
                                                {
                                                        berechneter_wert = berechneter_wert / wert_double;
                                                        break;
                                                }
                                                else
                                                {
                                                        throw new DivisionByZeroException();
                                                }
                                        default: // Wenn nichts eingeben wird, dann wird eine Fehlermeldung geworfen mit Verweis auf die Klasse Invalid...
                                                throw new InvalidOperatorException();
                                }
                        }
                        catch(DivisionByZeroException e)  // Auffangen (engl. catch) sonst Fehlermeldung nicht möglich
                        {
                                System.out.println("Fehler --- "+ e +": Division durch 0 \n");
                        }
                        catch(InvalidOperatorException e)
                        {
                                System.out.println("Fehler --- "+ e +": Unbekannter Operator \n");
                        }
                        catch(InputMismatchException e)
                        {
                             System.out.println("Fehler --- "+ e +": Falsches Eingeabeformat \n");
                        }
                        catch(NotNaturalNumberException e)
                        {
                            System.out.println("Fehler --- "+ e +": Fakultäten können nur mit natürlichen Zahlen gebildet werden \n");
                        }
                        catch(Exception e)
                        {
                                System.out.println("Fehler --- unbekannter Fehler \n");
                        }
                }
        }
        static String eingabeHilfe(String a) // EingabeHilfe -> nur 1 mal deshalb oben If Abfrage
        {
                a ="Bitte Operationen z.B +9 eingaben oder *8 \n";
                return a;
        }

        static int ganzZahl(double berechneter_wert) // Methode ganzZahl bekommt ein double und gibt ein Int zurück
        {
                double pruefung = berechneter_wert / (int)berechneter_wert;
                if(pruefung < (1.0 + Math.pow(10.0,-15.0))) // Pruefung der Bedingung -> Double / int = 1,0
                {
                    return (int)berechneter_wert;
                }
                else
                {
                    int hilfe = 0; // Eine Variable die für die If Abfrage im oberen segment wichtig ist bei !
                    return hilfe; // gibt hilfe back !
                }
        }

        static  int fakultaet_berechnung(int berechneter_wert)
        {
            int fakultaet = 1; // wie bei der Fakultaet -  muss 1 sein ! Sonst nicht Matherror bro how blow
            Boolean forschleife = false; // Abschluss der If Abfrage mit Integer.Max_Value -> sonst zu oft eingezeigt wenn mehr als overflow ist
            for(int i =1; i <= berechneter_wert && forschleife == false; i++) // Fakultaet Bedingung i <= eingabe; Bei 5 nur 5 durchläufe
            {
                try
                {
                    if((Integer.MAX_VALUE/i)<fakultaet) //Int Max Value = 2.147.483.647
                    {
                        forschleife = true;
                        throw new ResultErrorException(); // Wirft Overflow Exception
                    }
                    fakultaet = fakultaet * i;
                }
                catch (ResultErrorException e)
                {
                    System.out.println("Fehler --- "+ e +": Integer-Overflow \n");
                    fakultaet = berechneter_wert; // Wichtig damit wir den vorherigen Wert haben, sonst ist das der Overflow wert oder 1
                }
            }
            return fakultaet;
        }

        static double potenz(double a, double b) // Potenz methode bekommen 2 doubles und geben 1 double back
        {
            double potenz_rechnung = 0; // Initialisierung der Variable Potenz_Rechnung
            double pruefung = b / (int)b; // Feststellung ob Ganzzahl oder not
            try
            {
                if(pruefung == 1.0 && b > 0)
                {
                    potenz_rechnung = a;
                    for (double i = 1; i < b; i++)  // Schleife wird so lange ausgeführt bis i(Zähler) den Exponenten erreicht hat.
                    {
                        potenz_rechnung = potenz_rechnung * a;
                    }
                }
                else
                {
                    throw new InvalidExponentException();
                }
            }
            catch(InvalidExponentException e)
            {
                System.out.println("Fehler --- Nur ganzzahlige Exponenten verwenden und Exponent ueber >0 \n");
            }
            return potenz_rechnung;
        }
}
class DivisionByZeroException extends Exception // Etliche Klassen ... für die Exceptions
{
    private static final long serialVersionUID = 1L;
}

class ResultErrorException extends Exception
{
    private static final long serialVersionUID = 1L;
}

class InvalidOperatorException extends Exception
{
    private static final long serialVersionUID = 1L;
}

class InvalidExponentException extends Exception
{
    private static final long serialVersionUID = 1L;
}

class NotNaturalNumberException extends Exception
{
    private static final long serialVersionUID = 1L;
}