Kaffemaschine Programmierung Probleme

Schlotti

Neues Mitglied
Hallo Leute,
ich hab einen kleinen Hänger und komm nicht mehr weiter. Wenn ich folgenden Code laufen lasse bekomm ich das Problem, dass es trotz Abbrechen weiter Geld annimmt. Ich hatte das Programm schonmal am laufen muss es aber umändern, da es zu lang war.
Ich sehe für mich das Problem besonders in der Steuereinheit und meiner Abbruch Taste. Ich möchte nach den cases die Möglichkeit geben abzubrechen.
Wie schaffe ich es das mein Programm wieder zum Anfang springt und nicht das komplette Programm abbricht sonder neu die Tastatur ausgibt?
Vielen Dank schon mal im vor raus :)
Ich hoffe durch meine Versuche ist es nicht ganz außer rand und band geraten :-D


Java:
public class Steuereinheit2
{
    private static int preisKaffeeSchwarz = 100;
    private static int preisKaffeeMilch = 150;
    private static int preisKaffeeZucker = 150;
    private static int preisKaffeeMilchZucker = 200;
    private static int a;
    static Muenzwerk2 m = new Muenzwerk2();

    public static void main(String[] args)
    {
        Tastatur2 t = new Tastatur2();//Objekte erzeugen
        Display2 d = new Display2();

        Depot2 d1 = new Depot2(5,5,5,2,2);

        do{
            m.anzahlPruefen();//Münzprüfung
            d.textAnzeigen();
            switch(t.tasteAbfragen())//Beginn Kaffeeabfrage
            {

            default:
                IO.writeln("Fehler!");
                break;
            case 1:
                m.setKaffeepreis(preisKaffeeSchwarz);
                a = m.getKaffeepreis();                        //Preis wird festgelegt
                if(d1.wasserPruefen() == true && d1.becherPruefen() == true && d1.kaffeePruefen() == true)  //Depotprüfung
                {
                    IO.writeln("Sie haben gewählt: Kaffee schwarz \n"+ "Der Kaffee kostet " + preisKaffeeSchwarz + " Cent"); //Anzeige Auswahl
                }
                else
                {
                    IO.writeln("Bitte Fehler beheben!");
                }
                break;

            case 2:
                m.setKaffeepreis(preisKaffeeMilch);
                if(d1.wasserPruefen() == true && d1.becherPruefen() == true && d1.kaffeePruefen() == true && d1.milchPruefen() == true) /*Kaffee schwarz*/
                {
                    IO.writeln("Sie haben gewählt: Kaffee mit Milch\n"+ "Der Kaffee kostet " + preisKaffeeMilch + " Cent");
                }
                else
                {
                    IO.writeln("Bitte Fehler beheben!");
                }
                break;

            case 3:
                m.setKaffeepreis(preisKaffeeZucker);
                if(d1.wasserPruefen() == true && d1.becherPruefen() == true && d1.kaffeePruefen() == true && d1.zuckerPruefen() == true)    /*Kaffee schwarz*/
                {
                    IO.writeln("Sie haben gew�hlt: Kaffee mit Zucker\n"+ "Der Kaffee kostet " + preisKaffeeZucker + " Cent");
                }
                else
                {
                    IO.writeln("Bitte Fehler beheben!");
                }
                break;

            case 4:
                m.setKaffeepreis(preisKaffeeMilchZucker);
                if(d1.wasserPruefen() == true && d1.becherPruefen() == true && d1.kaffeePruefen() == true && d1.milchPruefen() == true) /*Kaffee schwarz*/
                {
                    IO.writeln("Sie haben gew�hlt: Kaffee mit Milch und Zucker\n"+ "Der Kaffee kostet " + preisKaffeeMilchZucker + " Cent");
                }
                else
                {
                    IO.writeln("Bitte Fehler beheben!");
                }

                break;

            case 6:    //Service cases
                d1.allesAuffuellenaufMAX();
                IO.writeln("Depots wurden aufgef�llt");
                break;

            case 7:
                m.muenzenAuffuellenMAX();
                IO.writeln("M�nzen wurden aufgef�llt");
                break;
            case 8:
                m.muenzenAuffuellenMAX();
                d1.allesAuffuellenaufMAX();
                IO.writeln("M�nzen und Depots wurden aufgef�llt");
                break;
            }

            d.textAbbrechen();
            t.tasteAbbruch();
            if (t.tasteAbbruch() == false)
            {
                break;
            }
            else
            {
  

            do
            {
                berechneRestbetrag(m.getKaffeepreis(), m.muenzenEinzahlen(IO.promptAndReadInt("Bitte Münze einwerfen: ")));  //Münzen einwerfen
                if (a == 0) //Passend gezahlt
                {
                    IO.writeln("Vielen Dank!\nBitte Kaffee entnehmen!");
                }

                else if (a < 0)     // Rückgeld
                {
                    do
                    {
                        m.setKaffeepreis(a *(-1));

                        if(a >= 100 && m.getAnzahl100ct()>0)    ////Test ob wir R�ckgeld ausgeben k�nnen!
                        {
                            m.setKaffeepreis(a-100);
                        }
                        else if (a >= 50 && m.getAnzahl50ct()>0)
                        {
                            m.setKaffeepreis(a-50);
                        }
                        else if (a >= 20 && m.getAnzahl20ct()>0)
                        {
                            m.setKaffeepreis(a-20);
                        }
                        else if (a >= 10 && m.getAnzahl10ct()>0)
                        {
                            m.setKaffeepreis(a-10);
                        }
                        else if (a>= 10 && m.getAnzahl10ct() == 0)
                        {
                            int b = m.getKaffeepreis() - a*(-1);

                            if(b >= 100 && m.getAnzahl100ct()>0)        //Zuerst "gro�e" M�nzen
                            {
                                m.muenzenAuszahlen(100);
                                m.setKaffeepreis(b-100);
                                IO.writeln("100 Cent");
                            }
                            else if (b >= 50 && m.getAnzahl50ct()>0)
                            {
                                m.muenzenAuszahlen(50);
                                m.setKaffeepreis(b-50);
                                IO.writeln("50 Cent");
                            }
                            else if (b >= 20 && m.getAnzahl20ct()>0)
                            {
                                m.muenzenAuszahlen(20);
                                m.setKaffeepreis(b-20);
                                IO.writeln("20 Cent");
                            }
                            else if (b >= 10 && m.getAnzahl10ct()>0)
                            {
                                m.muenzenAuszahlen(10);
                                m.setKaffeepreis(b-10);
                                IO.writeln("10 Cent");
                            }

                            a = 0;
                        }
                    } while (a > 0);


                    do
                    {
                        m.setKaffeepreis(a *(-1));

                        if(a >= 100 && m.getAnzahl100ct()>0)    ////Zuerst "große" Münzen
                        {
                            m.muenzenAuszahlen(100);
                            m.setKaffeepreis(a-100);
                            IO.writeln("100 Cent");
                        }
                        else if (a >= 50 && m.getAnzahl50ct()>0)
                        {
                            m.muenzenAuszahlen(50);
                            m.setKaffeepreis(a-50);
                            IO.writeln("50 Cent");
                        }
                        else if (a >= 20 && m.getAnzahl20ct()>0)
                        {
                            m.muenzenAuszahlen(20);
                            m.setKaffeepreis(a-20);
                            IO.writeln("20 Cent");
                        }
                        else if (a >= 10 && m.getAnzahl10ct()>0)
                        {
                            m.muenzenAuszahlen(10);
                            m.setKaffeepreis(a-10);
                            IO.writeln("10 Cent");
                        }
                    } while (a > 0);

                  
                    IO.writeln("Vielen Dank!\nBitte Kaffee entnehmen!");

                }

                else
                {
                    d.textAbbrechen();
                }
                if (t.tasteAbbruch()==false)        //Geldausgabe bei Abbruch
                {
                    int b = m.getKaffeepreis() - a;

                        if(b >= 100 && m.getAnzahl100ct()>0)        //Zuerst "gro�e" M�nzen
                        {
                            m.muenzenAuszahlen(100);
                            m.setKaffeepreis(b-100);
                            IO.writeln("100 Cent");
                        }
                        else if (b >= 50 && m.getAnzahl50ct()>0)
                        {
                            m.muenzenAuszahlen(50);
                            m.setKaffeepreis(b-50);
                            IO.writeln("50 Cent");
                        }
                        else if (b >= 20 && m.getAnzahl20ct()>0)
                        {
                            m.muenzenAuszahlen(20);
                            m.setKaffeepreis(b-20);
                            IO.writeln("20 Cent");
                        }
                        else if (b >= 10 && m.getAnzahl10ct()>0)
                        {
                            m.muenzenAuszahlen(10);
                            m.setKaffeepreis(b-10);
                            IO.writeln("10 Cent");
                        }

                        break;

                }
            }
               while (a > 0 );  
                                   //Ende Geldeingabe TODO test ob geklappt
            d.textAbbrechen();

            }
        }while(t.tasteAbbruch());

  
  
    }


    public static int berechneRestbetrag(int preis, int muenze)
    {
            m.setKaffeepreis(preis);

           if (muenze == 10 || muenze == 20 || muenze == 50 || muenze == 100 || muenze == 200)
            {   a = a - muenze;
                if (a > 0)
                {
                    IO.writeln("Restbetrag: " + a);
                }
                else
                {
                    IO.writeln("R�ckgeld: " + a *(-1));
                }
            }

            else
            {
                IO.writeln("M�nze gibt es nicht!");
            }

            return a;
    }
}

Code:
public class Tastatur2
{
    public int tasteAbfragen()                            //Abfrage der Taste
    {
        int x = IO.promptAndReadInt("");                //Text daf�r steht nachher in Class Display, nicht in Class Tastatur!
        return x;
    }

    public boolean tasteAbbruch()                        // Abbrechen
    {
        boolean b;
        String x = IO.promptAndReadString("");            //Text daf�r steht nachher in Class Display, nicht in Class Tastatur! "F�r abbrechen 'j' eingeben!"
        if (x.equals("j"))
        {
            b = false;
            return b;
        }
        else
        {
            b = true;
            return b;
        }
    }

    public Tastatur2()
    {

    }
}
Code:
public class Display2
{
    public void textAnzeigen()
    {
        IO.writeln("Dr�cken Sie 1 f�r einen Kaffee!");            // Option 1
        IO.writeln("Dr�cken Sie 2 f�r einen Kaffee mit Milch!");        // Option 2
        IO.writeln("Dr�cken Sie 3 f�r einen Kaffee mit Zucker!");                // Option 3
        IO.writeln("Dr�cken Sie 4 f�r einen Kaffee mit Milch und Zucker!");                // Option 4
    }

    public void textAbbrechen()
    {
        IO.writeln("F�r abbrechen 'j' eingeben!");
    }

    public Display2()
    {

    }
}

Code:
public class Depot2 {

    //Attribut
    private int
    becherEinheiten = 0,    //Anzahl der im Depot befindlichen Becher
    kaffeeEinheiten = 0,    //Menge des im Depot befindlichen Kaffees
    wasserEinheiten = 0,    //Menge des im Depot befindlichen Wassers
    zuckerEinheiten = 0,    //Menge des im Depot befindlichen Zuckers
    milchEinheiten = 0;     //Menge der im Depot befindlichen Milch

    //Maximale Mengen
    final int MAX_BECHER = 21;
    final int MAX_KAFFEE = 19;
    final int MAX_WASSER = 11;
    final int MAX_ZUCKER =  5;
    final int MAX_MILCH  =  3;

    public String toString()
    {
        return    "Becher: " + becherEinheiten + "\n" +
                "Kaffee: " + kaffeeEinheiten + "\n" +
                "Wasser: " + wasserEinheiten + "\n" +
                "Zucker: " + zuckerEinheiten + "\n" +
                "Milch: "  + milchEinheiten;
    }

    // Methode zur Entnahme
  
 
    public boolean entnahmeKaffeschwarz ()
    {
        if(becherEinheiten > 0 && wasserEinheiten > 0 && kaffeeEinheiten > 0)
        {
            becherEinheiten = becherEinheiten - 1;
            wasserEinheiten = wasserEinheiten - 1;
            kaffeeEinheiten = kaffeeEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, nicht genügend Zutaten vorhanden. Bitte auff�llen!");
            return false;
        }
      
    }
  
    public boolean entnahmeKaffeeMitZucker ()
    {
        if(becherEinheiten > 0 && wasserEinheiten > 0 && kaffeeEinheiten > 0 && zuckerEinheiten > 0)
        {
            becherEinheiten = becherEinheiten - 1;
            wasserEinheiten = wasserEinheiten - 1;
            kaffeeEinheiten = kaffeeEinheiten - 1;
            zuckerEinheiten = zuckerEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, nicht genügend Zutaten vorhanden. Bitte auff�llen!");
            return false;
        }
    }
  
    public boolean entnahmeKaffeeMitMilch ()
    {
        if(becherEinheiten > 0 && wasserEinheiten > 0 && kaffeeEinheiten > 0 && milchEinheiten > 0)
        {
            becherEinheiten = becherEinheiten - 1;
            wasserEinheiten = wasserEinheiten - 1;
            kaffeeEinheiten = kaffeeEinheiten - 1;
            milchEinheiten = milchEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, nicht genügend Zutaten vorhanden. Bitte auff�llen!");
            return false;
        }
      
    }
    public boolean entnahmeKaffeeMitMilchUndZucker ()
    {
        if(becherEinheiten > 0 && wasserEinheiten > 0 && kaffeeEinheiten > 0 && milchEinheiten > 0 && zuckerEinheiten > 0)
        {
            becherEinheiten = becherEinheiten - 1;
            wasserEinheiten = wasserEinheiten - 1;
            kaffeeEinheiten = kaffeeEinheiten - 1;
            milchEinheiten = milchEinheiten - 1;
            zuckerEinheiten = zuckerEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, nicht genügend Zutaten vorhanden. Bitte auff�llen!");
            return false;
        }
      
    }

  /*
    public boolean entnehmeBecher ()
    {
        if(becherEinheiten > 0)
        {
            becherEinheiten = becherEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, Becher sind leer. Bitte auff�llen!");
            return false;
        }
    }


    public boolean entnehmeKaffee (int anzahl)
    {
        if(kaffeeEinheiten >= anzahl)
        {
            kaffeeEinheiten = kaffeeEinheiten - anzahl;
            return true;
        }
        else
        {
            System.out.println("Fehler, Kaffee ist leer. Bitte auff�llen!");
            return false;
        }
    }

    public boolean entnehmeWasser ()
    {
        if(wasserEinheiten > 0)
        {
            wasserEinheiten = wasserEinheiten - 1;
            return true;
        }
        else
        {
            System.out.println("Fehler, Wasser ist leer. Bitte auff�llen!");

            return false;
        }
    }

    public boolean entnehmeZucker (int anzahl)
    {
        if(zuckerEinheiten >= anzahl)
        {
            zuckerEinheiten = zuckerEinheiten - anzahl;
            return true;
        }
        else
        {
            System.out.println("Fehler, Zucker ist leer. Bitte auff�llen!");
            return false;
        }
    }

    public boolean entnehmeMilch (int anzahl)
    {
        if(milchEinheiten >= anzahl)
        {
            milchEinheiten = milchEinheiten - anzahl;
            return true;
        }
        else
        {
            System.out.println("Fehler, Milch ist leer. Bitte auff�llen!");
            return false;
        }
    }
*/
    //Methode zum Auff�llen
    public void becherAuffuellenaufMAX ()
    {
        becherEinheiten = MAX_BECHER;
    }

    public void kaffeeAuffuellenaufMAX ()
    {
        kaffeeEinheiten = MAX_KAFFEE;
    }

    public void wasserAuffuellenaufMAX ()
    {
        wasserEinheiten = MAX_WASSER;
    }

    public void zuckerAuffuellenaufMAX ()
    {
        zuckerEinheiten = MAX_ZUCKER;
    }

    public void milchAuffuellenaufMAX ()
    {
        milchEinheiten = MAX_MILCH;
    }

    public void allesAuffuellenaufMAX ()        //Alles auff�llen
    {
        becherAuffuellenaufMAX ();
        kaffeeAuffuellenaufMAX ();
        wasserAuffuellenaufMAX ();
        zuckerAuffuellenaufMAX ();
        milchAuffuellenaufMAX ();
    }

    //Getters
    int getBecher()
    {
         return becherEinheiten;
    }

    int getKaffee()
    {
         return kaffeeEinheiten;
    }

    int getWasser()
    {
         return wasserEinheiten;
    }

    int getZucker()
    {
         return zuckerEinheiten;
    }

    int getMilch()
    {
         return milchEinheiten;
    }

    // Methoden zum Pr�fen
    public boolean wasserPruefen()
    {
        if (wasserEinheiten == 0)
        {
            IO.writeln("Wasserdepot leer, bitte auff�llen!");
            return false;
        }
        else
        {
            return true;
        }
    }

    public boolean becherPruefen()
    {
        if (becherEinheiten == 0)
        {
            IO.writeln("Becherdepot leer, bitte auff�llen!");
            return false;
        }
        else
        {
            return true;
        }
    }

    public boolean kaffeePruefen()
    {
        if (kaffeeEinheiten == 0)
        {
            IO.writeln("Kaffeedepot leer, bitte auff�llen!");
            return false;
        }
        else
        {
            return true;
        }
    }

    public boolean zuckerPruefen()
    {
        if (zuckerEinheiten == 0)
        {
            IO.writeln("Zuckerdepot leer, bitte auff�llen!");
            return false;
        }
        else
        {
            return true;
        }
    }

    public boolean milchPruefen()
    {
        if (milchEinheiten == 0)
        {
            IO.writeln("Milchdepot leer, bitte auff�llen!");
            return false;
        }
        else
        {
            return true;
        }
    }

    public Depot2(int w, int k, int b, int z, int m)
    {
        wasserEinheiten=w;
        kaffeeEinheiten=k;
        becherEinheiten=b;
        zuckerEinheiten=z;
        milchEinheiten=m;
    }
}
Code:
public class Muenzwerk2 {

    //Klassen-Variablen Initialisierung

    public static int eingezahlteMuenzen;


    //Instanz-Variablen Initialisierung
    private int anzahl10ct = 5;
    private int anzahl20ct = 5;
    private int anzahl50ct = 5;
    private int anzahl100ct = 5;
    private int anzahl200ct;
    private int kaffeepreis;
    private int muenze;
    private int eingewMuenzen;

    public int getEingewMuenzen() {
        return eingewMuenzen;
    }


    public void setEingewMuenzen(int eingewMuenzen) {
        this.eingewMuenzen = eingewMuenzen;
    }


    //Konstruktor
    public Muenzwerk2()
    {

    }


    //getter
    public int getAnzahl10ct()
    {
        return anzahl10ct;
    }
    public int getAnzahl20ct()
    {
        return anzahl20ct;
    }
    public int getAnzahl50ct()
    {
        return anzahl50ct;
    }
    public int getAnzahl100ct()
    {
        return anzahl100ct;
    }
    public int getAnzahl200ct()
    {
        return anzahl200ct;
    }


    //Methoden
    // TODO KEIN WIRKLICHER TEST
    public boolean anzahlPruefen(){
        if (anzahl10ct>=1 && anzahl20ct>=1 && anzahl50ct>=1 && anzahl100ct>=1)
        { return true;}
        else
        {
            IO.writeln("Bitte passend Zahlen. Kein Rückgeld möglich");
            return false;
        }
    }

    public int muenzenEinzahlen(int muenzart)
    {
        if(muenzenPruefen() == false)
        {
            muenzart = 999;
        }

        switch(muenzart)
        {


        case 10:
            if(muenzart == 10)
            {
                anzahl10ct ++;
                eingezahlteMuenzen ++;
                eingewMuenzen=eingewMuenzen+10;
                break;
            }
        case 20:

            if(muenzart == 20)
            {
                anzahl20ct ++;
                eingezahlteMuenzen ++;
                eingewMuenzen=eingewMuenzen+20;
                break;

            }
        case 50:
            if(muenzart == 50)
            {
                anzahl50ct ++;
                eingezahlteMuenzen ++;
                eingewMuenzen=eingewMuenzen+50;
                break;
            }
        case 100:
            if(muenzart == 100)
            {
                anzahl100ct ++;
                eingezahlteMuenzen ++;
                eingewMuenzen=eingewMuenzen+100;
                break;
            }
        case 200:
            if(muenzart == 200)
            {
                anzahl200ct ++;
                eingezahlteMuenzen ++;
                eingewMuenzen=eingewMuenzen+200;
                break;
            }
        default:
            {
                System.out.println("Es werden nur 10 Cent, 20 Cent, 50 Cent, 1 Euro oder 2Euro Stücke angenommen!");

            }
        }
        muenze = muenzart;
        return muenze;
    }


    public void muenzenAuszahlen(int muenzart)
    {
        switch(muenzart){

            case 10:
                if(muenzart == 10)
                {
                    if(anzahl10ct > 0)
                    {
                        anzahl10ct --;
                    }
                    else
                    {
                        IO.writeln("Münzen auffüllen!");
                    }
                    break;
                }
            case 20:
                if(muenzart == 20)
                {
                    if(anzahl20ct > 0)
                    {
                        anzahl20ct --;
                    }
                    else
                    {
                        IO.writeln("Münzen auffüllen!");
                    }
                    break;
                }
            case 50:
                if(muenzart == 50)
                {
                    if(anzahl50ct > 0)
                    {
                        anzahl20ct --;
                    }
                    else
                    {
                        IO.writeln("Münzen auffüllen!");
                    }
                    break;
                }
            case 100:
                if(muenzart == 100)
                {
                    if(anzahl100ct > 0)
                    {
                        anzahl100ct --;
                    }
                    else
                    {
                        IO.writeln("Münzen auffüllen!");
                    }
                break;

                }
            case 200:
                if(muenzart == 200)
                {
                    if(anzahl200ct > 0)
                    {
                        anzahl200ct --;
                    }
                    else
                    {
                        IO.writeln("Münzen auffüllen!");
                    }
                    break;

                }
            default:
            {
                System.out.println("Es werden nur 10 Cent, 20 Cent, 50 Cent, 1 Euro oder 2Euro Stücke angenommen!");

            }
        }
    }

    public void muenzenAuffuellenMAX()
    {
        anzahl10ct = 7;
        anzahl20ct = 7;
        anzahl50ct = 7;
        anzahl100ct = 7;
    }

    public boolean muenzenPruefen()
    {
        if(eingezahlteMuenzen == 10)
        {
            System.out.println("Münze nicht erkannt");
            eingezahlteMuenzen=0;
            return false;
        }
        else
        {
            return true;
        }
    }

    public int getKaffeepreis() {
        return kaffeepreis;
    }

    public void setKaffeepreis(int kaffeepreis) {
        this.kaffeepreis = kaffeepreis;
    }

}
 
Zuletzt bearbeitet:

Schlotti

Neues Mitglied
Leider kann ich meinen Post nicht löschen. Hab das Problem lokalisiert und so einigermaßen gelöst.
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
H Java Rechner Programmierung der Mathematik Allgemeine Java-Themen 33
districon Rekursion und Dynamische Programmierung Allgemeine Java-Themen 2
D Vigenere Chiffre Programmierung Allgemeine Java-Themen 5
G Thread-Programmierung Allgemeine Java-Themen 5
R Input/Output Programmierung mithilfe der Robot Bibliothek Allgemeine Java-Themen 15
MiMa Programmierung von Bibliotheksklassen Allgemeine Java-Themen 3
zhermann Grundsatzfrage zur strukturierter Programmierung Allgemeine Java-Themen 5
P jCheckBox auf der zusammengeknüpften Programmierung anzeigen lassen Allgemeine Java-Themen 3
K Test-Frist Programmierung - wie vorgehen Allgemeine Java-Themen 5
C Programmierung von Fotoeffekten mit Java möglich? Allgemeine Java-Themen 3
J Rekursive Programmierung-Zählen von Ziffern Allgemeine Java-Themen 5
L Designfrage: Dispatcher-Programmierung - redundante Auslegung Allgemeine Java-Themen 1
E Sonderzeichen nicht setzbar: Großes Problem bei Programmierung unter Linux Mint mit Virtual Box Allgemeine Java-Themen 5
C BlackBox-Framework - Plugin Programmierung Allgemeine Java-Themen 4
S Objekt orientierte Programmierung Allgemeine Java-Themen 7
E Socket Client-Server-Programmierung Allgemeine Java-Themen 44
M Parallele Programmierung: volatile Variable nimmt ungewöhnlichen Wert an Allgemeine Java-Themen 3
C Open Soure Projekte für parallele Programmierung Allgemeine Java-Themen 6
E Thread Programmierung Allgemeine Java-Themen 2
K Multithread Programmierung...ExecutionCompletionService Allgemeine Java-Themen 7
E objektorientierte Programmierung Allgemeine Java-Themen 3
C Hilfe bei Adressbuch-Programmierung, wie am Besten mit JList implementieren Allgemeine Java-Themen 2
J Problem mit der Thread Programmierung Allgemeine Java-Themen 2
T Fehler bei der Programmierung eines Universaldienstbrowsers Allgemeine Java-Themen 3
J 3d-Programmierung Allgemeine Java-Themen 7
S BlueJ BlueJ - Geldautomat-Programmierung Allgemeine Java-Themen 2
G Funktionale Programmierung, OO- Programmierung, ... Allgemeine Java-Themen 9
J Hardware Programmierung Allgemeine Java-Themen 3
Kr0e Atomic / Lockfree Programmierung Allgemeine Java-Themen 11
6 Java - Threads - parallele Programmierung - Tutorial Allgemeine Java-Themen 6
I parallele Programmierung mit Java Allgemeine Java-Themen 3
X Error bei der Programmierung eines Sortieralgorithmus Allgemeine Java-Themen 2
J Modul/Komponenten/Addon-Programmierung Allgemeine Java-Themen 3
ModellbahnerTT Dynamische Programmierung, komme nicht weiter.... Allgemeine Java-Themen 15
S Applet Programmierung in Eclipse Allgemeine Java-Themen 12
B Observer vs Listener (GUI-Programmierung) Allgemeine Java-Themen 5
Developer_X Batch Programmierung Allgemeine Java-Themen 4
Developer_X Datei Programmierung Allgemeine Java-Themen 18
hdi Suche nach Begriff aus der Programmierung Allgemeine Java-Themen 11
K Programmierung einer Hilfe Allgemeine Java-Themen 6
G Threads programmierung Allgemeine Java-Themen 7
F Frage zu JSP / Java Programmierung Allgemeine Java-Themen 2
L Brauche Hilfe bei Memory Programmierung Allgemeine Java-Themen 2
G Framework für Multi-Prozessor-Programmierung? Allgemeine Java-Themen 4
tomtailor Mobiltelefon - Programmierung Allgemeine Java-Themen 8
O Oberfläche und "richtige" Programmierung Allgemeine Java-Themen 8
ven000m Constraint Programmierung Allgemeine Java-Themen 6
X Langsames Java im Bereich der GUI-Programmierung Allgemeine Java-Themen 8
F Klausuraufgaben Java-Programmierung Allgemeine Java-Themen 10
D Elegante Programmierung. Allgemeine Java-Themen 7
G Software für Java programmierung Allgemeine Java-Themen 5
J Frage zu Objektorientierter Programmierung Allgemeine Java-Themen 9
K Bubblesort Programmierung, finde Fehler nicht . Allgemeine Java-Themen 25
bernd Hardwarenahe Programmierung Allgemeine Java-Themen 14
S Taschenrechner und Programmierung Allgemeine Java-Themen 4
D Fraen zur Programmierung einer Volltextsuche Allgemeine Java-Themen 8
C Probleme beim Erstellen eines runnable-jar files Allgemeine Java-Themen 1
S Umstellung von File auf Path - Probleme mit Stream Allgemeine Java-Themen 5
C Probleme mit javax.mail.Session Allgemeine Java-Themen 8
M tomcat probleme Allgemeine Java-Themen 1
N Division macht Probleme Allgemeine Java-Themen 14
B Java Reflection Probleme beim wehcselseitigen Referenzieren zweier Klassen/Objekte Allgemeine Java-Themen 14
MarvinsDepression Probleme mit relativem Dateipfad Allgemeine Java-Themen 1
G Geotools Probleme nach PC-Wechsel Allgemeine Java-Themen 6
nibe1501 GUI Probleme Allgemeine Java-Themen 16
C Probleme mit dem WindowBuilder Allgemeine Java-Themen 3
P Selenium . Probleme ein Iron Icon Element anzusprechen Allgemeine Java-Themen 2
B Compiler-Fehler Probleme beim Kompilieren mit Jsoup Allgemeine Java-Themen 8
K VisualVM Profiling Remote Probleme Allgemeine Java-Themen 1
O Leerzeichen und Umlaute im Pfad einer Java Applikation machen Probleme Allgemeine Java-Themen 13
M Probleme bei Eclipse wenn ich entpacke Allgemeine Java-Themen 15
D Regex Probleme Allgemeine Java-Themen 2
M Probleme jar datei. Allgemeine Java-Themen 2
L Vererbung Verständnis Probleme Vererbung Allgemeine Java-Themen 2
Dann07 Probleme mit OpenAL Allgemeine Java-Themen 0
V Threads Probleme beim Aufrufen von Methoden einer anderen Klasse (Threads) Allgemeine Java-Themen 14
V Compiler-Fehler Online Compiler Probleme Allgemeine Java-Themen 4
M Probleme mit Negamax-Algorithmus Allgemeine Java-Themen 29
M Probleme mit BigDecimal Allgemeine Java-Themen 1
T Probleme mit NumberFormat Allgemeine Java-Themen 5
J Probleme exe-Start mit Task Scheduler Allgemeine Java-Themen 1
B Input/Output Probleme beim Ausführen von Shell-Befehlen mit Java Allgemeine Java-Themen 28
J Probleme beim einbinden von Zip4j library Allgemeine Java-Themen 6
F Variablen Palindromzahl (Probleme mit Methode) Allgemeine Java-Themen 9
K Data Konverter - Probleme mit Byte[] Kodierung Allgemeine Java-Themen 3
T Probleme mit dem Pfad zum Propertie file Allgemeine Java-Themen 7
H Swing HashMap zu Tabelle macht mir Probleme Allgemeine Java-Themen 4
Neoline Interpreter-Fehler Probleme mit Arrays.toString Allgemeine Java-Themen 7
F SQLite mit Java / Probleme beim INSERT Befehl Allgemeine Java-Themen 4
J Erste Schritte Probleme mit der Hauptklasse Allgemeine Java-Themen 14
J Tetris Probleme bei Klassen Allgemeine Java-Themen 14
J MinMax VierGewinnt Probleme Allgemeine Java-Themen 22
J Probleme mit CodeCoverage und Lombok Equals Allgemeine Java-Themen 1
S Eclipse Probleme beim Implementieren / Ausführen von jUnit 5-Test Suites Allgemeine Java-Themen 14
R Snake Probleme Allgemeine Java-Themen 2
A Probleme beim Verstehen einer Aufgabenstellung Allgemeine Java-Themen 11
RalleYTN 3D Objekt Translation basierend auf Rotation (Probleme mit Z Rotation) Allgemeine Java-Themen 0
Bluedaishi Druck Probleme mit PDF dateien Allgemeine Java-Themen 4
G Ant Probleme bei einer Installation die Apache ant+ivy verwendet Allgemeine Java-Themen 14
E TableView Probleme Allgemeine Java-Themen 7

Ähnliche Java Themen

Neue Themen


Oben