Code optimieren

Leon_2001

Aktives Mitglied
Hallo :)

ich habe mir den Rat aus dem anderen Thread zu herzen genommen und zu Beginn ein TicTacToe erstellt für zweiSpieler(Computer folgt)... das hat auch super geklappt, dennoch beschäftigt mich vor allem die Frage als Anfänger "Ist das auch eine empfohlene Lösung" (z.B. kann man mit einer Tabelle in HTML ein Layout machen, gut ist das allerdings nicht) oder auch "Geht das nicht einfacher/schneller/effizienter/übersichtlicher usw"?

Aus diesem Grund stelle ich meinen Code hier rein und würde mich über Kommentare dazu freuen. Egal ob "Ich würde es genauso machen", "Folgendes ist eine bessere Variante", "Nicht besser, aber eine interessante Alternativlösung" oder aber auch "Du solltest folgendes wegen gängiger Konventionen ändenr (z.B. variablennamen klein)"...
Ich denke das würde mir sehr helfen, da ich das Gefühl habe, dass es besser geht :)

Grüße Leon

Java:
import java.util.ArrayList;
public class TicTacToe
{
    String turn;
    char Spielfeld[][] = { {'|', ' ','|',' ','|',' ','|'}, {'|', ' ', '|', ' ', '|', ' ','|'}, {'|', ' ', '|', ' ', '|', ' ', '|'} };
    ArrayList <Integer> nummer = new ArrayList<>();
    boolean berechtigung = true;
    public TicTacToe(){
        zeigeSpielfeld();
        turn = "Spieler1";
    }

    private void zeigeSpielfeld(){
        for (int i = 0 ; i < 3; i++){
            for(int j = 0 ; j < 7; j++){
                System.out.print(Spielfeld[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }

    public void setzeMarkierung(int stelle){
        if(berechtigung) {
            if(!nummer.contains(stelle)){
                nummer.add(stelle);
                if(turn.equals("Spieler1")){
                    switch(stelle){
                        case 1: Spielfeld[0][1] = 'X'; turn = "Spieler2"; break;
                        case 2: Spielfeld[0][3] = 'X'; turn = "Spieler2"; break;
                        case 3: Spielfeld[0][5] = 'X'; turn = "Spieler2"; break;
                        case 4: Spielfeld[1][1] = 'X'; turn = "Spieler2"; break;
                        case 5: Spielfeld[1][3] = 'X'; turn = "Spieler2"; break;
                        case 6: Spielfeld[1][5] = 'X'; turn = "Spieler2"; break;
                        case 7: Spielfeld[2][1] = 'X'; turn = "Spieler2"; break;
                        case 8: Spielfeld[2][3] = 'X'; turn = "Spieler2"; break;
                        case 9: Spielfeld[2][5] = 'X'; turn = "Spieler2"; break;
                        default: System.out.println("Nicht im Spielfeld");
                    }
                    zeigeSpielfeld();
                    prüfeGewinn('X');
                    prüfeUnentschieden();
                }
                else {
                    switch(stelle){
                        case 1: Spielfeld[0][1] = 'O'; turn = "Spieler1"; break;
                        case 2: Spielfeld[0][3] = 'O'; turn = "Spieler1"; break;
                        case 3: Spielfeld[0][5] = 'O'; turn = "Spieler1"; break;
                        case 4: Spielfeld[1][1] = 'O'; turn = "Spieler1"; break;
                        case 5: Spielfeld[1][3] = 'O'; turn = "Spieler1"; break;
                        case 6: Spielfeld[1][5] = 'O'; turn = "Spieler1"; break;
                        case 7: Spielfeld[2][1] = 'O'; turn = "Spieler1"; break;
                        case 8: Spielfeld[2][3] = 'O'; turn = "Spieler1"; break;
                        case 9: Spielfeld[2][5] = 'O'; turn = "Spieler1"; break;
                        default: System.out.println("Nicht im Spielfeld");
                    }
                    zeigeSpielfeld();
                    prüfeGewinn('O');
                    prüfeUnentschieden();
                }
            }
        }
    }

    private void prüfeGewinn(char zeichen){
        if((zeichen == Spielfeld[0][1] && zeichen == Spielfeld[0][3] && zeichen == Spielfeld[0][5])||
        (zeichen == Spielfeld[1][1] && zeichen == Spielfeld[1][3] && zeichen == Spielfeld[1][5])||
        (zeichen == Spielfeld[2][1] && zeichen == Spielfeld[2][3] && zeichen == Spielfeld[2][5])||
        (zeichen == Spielfeld[0][1] && zeichen == Spielfeld[1][1] && zeichen == Spielfeld[2][1])||
        (zeichen == Spielfeld[0][3] && zeichen == Spielfeld[1][3] && zeichen == Spielfeld[2][3])||
        (zeichen == Spielfeld[0][5] && zeichen == Spielfeld[1][5] && zeichen == Spielfeld[2][5])||
        (zeichen == Spielfeld[0][1] && zeichen == Spielfeld[1][3] && zeichen == Spielfeld[2][5])||
        (zeichen == Spielfeld[2][1] && zeichen == Spielfeld[1][3] && zeichen == Spielfeld[0][5])){
            System.out.println("Du hast gewonnen");
            berechtigung = false;
        }
    }

    private void prüfeUnentschieden() {
        if(nummer.size() == 9){ System.out.println("Ein Unentschieden!"); }
    }
}
 

Thallius

Top Contributor
Also nur mal eben auf die schnelle.

SpielFeld ist eine Variable. Also bitte wie die anderen Variblen auch im Camelcase schreiben.
Bitte entscheide dich für eine Sprache. Wenn es eben geht programmiere in englisch. Auch wenn dein Englisch vielleicht noch nicht das beste ist, so schult das und im richtigen Job später wirst du eh in englisch programmieren müssen.

Nicht hat ganz einfach aber viellecht interessant dich da einzuarbeiten:

Du kannst eine HashMap<Integer><Integer[]> erstellen in der du als key deine Feldnummer 1-9 einträgst und als value dann ein Array mit den beiden x und y Werten. Dann kannst du dir die ganzen Switch case ersparen und einfach mit spielFeld[map.get(feldnummer)[0]] [ map.get(feldnummer)[1] ] = "O" die Werte setzen.

Gruß

Claus
 

stg

Top Contributor
Der gröbste Schnitzer in meinen Augen: Du vermischt Darstellung mit der Spiellogik. Das Spielfeld sollte z.B. einfach ein 3x3-Array sein, die Indices 3 und 5 sind nicht sonderlich intuitiv und erschweren nur die Prüfung des Spielstands. Besser wäre hier z.B. eine print-Methode in einer separaten GUI-Klasse. Damit solltest du auch erst mal beschäftigt sein...
 

Leon_2001

Aktives Mitglied
Der gröbste Schnitzer in meinen Augen: Du vermischt Darstellung mit der Spiellogik. Das Spielfeld sollte z.B. einfach ein 3x3-Array sein, die Indices 3 und 5 sind nicht sonderlich intuitiv und erschweren nur die Prüfung des Spielstands. Besser wäre hier z.B. eine print-Methode in einer separaten GUI-Klasse. Damit solltest du auch erst mal beschäftigt sein...

könntest du das ganze noch etwas genauer beschreiben? wie genau sollte das Spielfeld sein? ein zweidimensionales Array [3][3] in dem nur ' ' vorkommen(also ein einzelnes Leerzeichen an jedem Index)?
Wie kann ich mir eine solche print Methode vorstellen?
 

Leon_2001

Aktives Mitglied
Also nur mal eben auf die schnelle.

SpielFeld ist eine Variable. Also bitte wie die anderen Variblen auch im Camelcase schreiben.
Bitte entscheide dich für eine Sprache. Wenn es eben geht programmiere in englisch. Auch wenn dein Englisch vielleicht noch nicht das beste ist, so schult das und im richtigen Job später wirst du eh in englisch programmieren müssen.

Nicht hat ganz einfach aber viellecht interessant dich da einzuarbeiten:

Du kannst eine HashMap<Integer><Integer[]> erstellen in der du als key deine Feldnummer 1-9 einträgst und als value dann ein Array mit den beiden x und y Werten. Dann kannst du dir die ganzen Switch case ersparen und einfach mit spielFeld[map.get(feldnummer)[0]] [ map.get(feldnummer)[1] ] = "O" die Werte setzen.

Gruß

Claus

Erst einmal vielen dank für den Hinweis mit dem Array... beschäftigt mich schon die ganze Zeit,ob man diese klein schreibt (wobei es eig klar ist, da es eine Variable ist). Englisch ist in der Tat nicht meine Stärke (Das Programm habe ich freiwillig in meine Informatik Hausaufgabe eingebaut (mit noch weiteren Sachen), um ehrlich zu sein, wollte ich einfach auf spöttische Kommentare seitens bestimmter Klassenkameraden verzichten, die sich ganz besonders krass in Englisch fühlen...).
HashMap klingt sehr interessant (kenne ich sogar, auch wenn ich aktuell keine Ahnung mehr davon habe).Ich denke, die würde mir sehr helfen, auch beim einbauen des Computers... dabei war ich doch so stolz auf mein Switch case, sonst hatte ich sowas immer mit 10 if else Bedingungen gemacht ;)
Aber daran sieht man, besser geht immer ^^

Besonders interessieren würde mich eine Vereinfachung der prüfeGewinn Methode. Erscheint mir irgendwie anfängerhaft, dass so zu lösen.
 

Robat

Top Contributor
Besonders interessieren würde mich eine Vereinfachung der prüfeGewinn Methode. Erscheint mir irgendwie anfängerhaft, dass so zu lösen.
In der Tat kann man die vereinfachen. Nimm' dir mal Stift und Papier zur Hand und mal dir auf (mit Indizes) wann man gewonnen hat. Dann sollte dir eventuell auffallen, dass man es mit einer for-Schleife deutlich verkürzen kann :)
 

Leon_2001

Aktives Mitglied
Ein kurzer Zwischenstand:

versucht umzusetzen:
-Hashmap
- Trennung Layout und Logik/print Methode

als nächstes bevorstehend:
-Gewinn Methode optimieren
- Computer Gegner
- englische begriffe verwenden

Tipps usw. würde mich freuen :)

Schönes Wochenende, Leon

Java:
import java.util.*;
public class TicTacToe2
{
    int[][] test = {{1,2},{3,1}};
    HashMap<Integer, Character> spielfeld = new HashMap<>();
    ArrayList<Integer> used = new ArrayList<>();

    boolean berechtigung;
    int turn;

    public TicTacToe2(int firstMove){
        berechtigung = true;
        turn = firstMove;
        Create();
        Show();
    }

    public void Create(){
        for(int i = 1; i <= 9; i++){
            spielfeld.put(i, ' ');
        }
    }

    public void Show(){
        int count = 0;
        for( char s: spielfeld.values()){
            System.out.print("|" + s);
            count++;
            if(count%3 == 0){
                System.out.print("|\n");
            }
        }
        System.out.println();
    }

    public void set(int stelle){
        if(berechtigung){
            if(!used.contains(stelle)){
                used.add(stelle);
                if(turn == 1){
                    spielfeld.put(stelle, 'X');
                    prüfeGewinn('X');
                    turn = 2;
                }
                else {
                    spielfeld.put(stelle, 'O');
                    prüfeGewinn('O');
                    turn = 1;
                }
            }
            else{
                System.out.println("bereits gesetzt");
            }
            prüfeUnentschieden();
            Show();
        }
    }
   
    public void prüfeGewinn(char zeichen){
       
    }
   
    private void prüfeUnentschieden(){
        if(used.size() == 9){
            System.out.println("Ein Unentschieden!");
            berechtigung = false;
        }
    }
}
 

Leon_2001

Aktives Mitglied
Ich benötige nochmal Hilfestellung bei der prüfeGewinn() Methode... ich dachte ich hätte es gut gelöst, indem ich die benutzen werte (stellen wo schon ein X bzw. O gesetzt wurden) in zwei verschieden Arrays speichere und dann einfach abfrage, ob in diesem Array die Stellenkombinationen für einen Sieg enthalten sind...

Problem 1: Wirklich vereinfacht ist es dadurch auch nicht, der von Robat erwähnte Algorithmus ist mir auch beim aufzeichnen auf ein Blatt noch nicht aufgefallen :(

Problem 2: contain() kann nur ein Parameter entgegennehmen und dann ist es genauso komplex wie mit einer if-bedingung

Kann mir jemand helfen bei dem Algorithmus?

Java:
import java.util.*;
public class TicTacToe2
{
    int[][] test = {{1,2},{3,1}};
    HashMap<Integer, Character> spielfeld = new HashMap<>();
    ArrayList<Integer> used1 = new ArrayList<>();
    ArrayList<Integer> used2 = new ArrayList<>();

    boolean berechtigung;
    int turn;

    public TicTacToe2(int firstMove){
        berechtigung = true;
        turn = firstMove;
        Create();
        Show();
    }

    public void Create(){
        for(int i = 1; i <= 9; i++){
            spielfeld.put(i, ' ');
        }
    }

    public void Show(){
        int count = 0;
        for( char s: spielfeld.values()){
            System.out.print("|" + s);
            count++;
            if(count%3 == 0){
                System.out.print("|\n");
            }
        }
        System.out.println();
    }

    public void set(int stelle){
        if(berechtigung){
            if(!used1.contains(stelle)|| !used2.contains(stelle)){
                if(turn == 1){
                    used1.add(stelle);
                    spielfeld.put(stelle, 'X');
                    prüfeGewinn(used1);
                    turn = 2;
                }
                else {
                    used2.add(stelle);
                    spielfeld.put(stelle, 'O');
                    prüfeGewinn(used2);
                    turn = 1;
                }
            }
            else{
                System.out.println("bereits gesetzt");
            }
            prüfeUnentschieden();
            Show();
        }
    }

    public void prüfeGewinn(ArrayList<Integer> list){
        if(list.contains(1&&2&&3 || 4&&5&&6 || 7&&8&&9 || 1&&4&&7 || 2&&5&&8 || 3&&6&&9 || 1&&5&&9 || 3&&5&&7)){
            System.out.println("Du hast gewonnen");
        }
    }

    private void prüfeUnentschieden(){
        if(used1.size() + used2.size() == 9){
            System.out.println("Ein Unentschieden!");
            berechtigung = false;
        }
    }
}
 

Leon_2001

Aktives Mitglied
In der Tat kann man die vereinfachen. Nimm' dir mal Stift und Papier zur Hand und mal dir auf (mit Indizes) wann man gewonnen hat. Dann sollte dir eventuell auffallen, dass man es mit einer for-Schleife deutlich verkürzen kann :)

Hab es nochmal probiert mit einer for-schleife... 3 Fälle abgedeckt und schon jetzt total kompliziert:(
Ich glaube du meintest eine bessere Möglichkeit.

Java:
for(int j = 1; j < 8 ; j+= 3){
            for(int i = j; i < j+3; i++){
                if ( zeichen != matchfield.get(i)){
                    break;
                }
                if( i == j+2){
                    System.out.println("Du hast gewonnen");
                }
            }
        }
 

Robat

Top Contributor
Ich glaube du meintest eine bessere Möglichkeit.
Ich habe das mit dem Hintergedanken geschrieben dass du bei deinem 2D-Array bleibst. Ich persönlich würde auch nicht mit einer HashMap arbeiten, ist aber Ansichtssache.
Die eigentliche Idee mit dem aufmalen war, dass du dann siehst das du immer wieder das selbe Muster beim prüfen hast (die Diagonalen sind eine Sache für sich).

Hier mal ein kleines Beispiel die dir die Idee zeigt:

Java:
private boolean hasWon(String[][] board)
{
    for(int i = 0; i < board.length; i++)
    {
        if(board[i][0].equals(zeichen) && board[i][1].equals(zeichen) && board[i][2].equals(zeichen) ||
          board[0][i].equals(zeichen) && board[1][i].equals(zeichen) && board[2][i].equals(zeichen))
            return true;
    }
   
    if(board[0][0].equals(zeichen) && board[1][1].equals(zeichen) && board[2][2].equals(zeichen) ||
      board[0][2].equals(zeichen) && board[1][1].equals(zeichen) && board[2][0].equals(zeichen))
        return true;
   
    return false;   
}

Gruß
 

Leon_2001

Aktives Mitglied
Habe jetzt deine Idee dahinter verstanden, denke aber, dass ist vermutlich genauso unschön, wie ein if-abfrage, deswegen habe ich jetzt mal die if-Bedingung drin gelassen.

Mein TicTacToe besitzt nun einen Computer, der zufällig ein freies Feld auswählt und mit 'O' besetzt. Die Möglichkeit, dass der Computer beginnt, habe ich noch nicht implementiert (ist denke ich auch nicht so sinnvoll wegen meines nächsten Vorhabens).

Der Computer spiel logischerweise recht schlecht und das würde ich durch Ki natürlich gerne beheben wollen.
Die Idee, die mir in den Sinn kam (und die ich für möglich halte) ist folgende:

1.Nach dem Spiel bewertet der Computer die Stellung mit +1,0,-1
2.Diese speichert er in einer HashMap als Value und mit dem Spielverlauf als Key
3. Beim nächsten Spiel vergleicht der Computer den Spielverlauf mit schon ihm bekannten Spielverläufen und wählt ein Zug vor einer Stellung mit Bewertung den selben Zug aus, wenn er die Stellung als +1 bewertet hatte oder einen anderen Zug, falls die Bewertung 0 oder -1 ist
4. Sobald keine unbekannten Züge mehr vorhanden sind, die er ausprobieren kann, bewertet er seinen Zug davor mit dem für ihn schlechtesten daraus resultierendem Ergebnis

Davon ausgehend, dass x gut spielt:

|O|O|X|
| |X|O| speichert -1
|X| |X|

|O|O|X|
| |X|X| speichert -1
|O| |X|

Alle anderen Möglichkeiten auch als -1

Dadurch weiß der Computer, dass bereits

| |O| |
| |X| |
| | |X|

O auf 1 = -1 ist und probiert wieder etwas anderes aus

... irgendwann sollte er dann zu dem Ergebnis kommen, dass
| |O| |
| |X| |
| | | |

sein erster Zug auf 2 bereits verliert und probiert, was anders aus.

+ -
Ich glaube es funktioniert Die Umsetzung von 3. und 4. erscheint mir schwer
Der Computer lernt extrem langsam

Ich habe bereits einen ersten versuch von Schritt 1 und Schritt 2 unternommen:

Java:
private void bewerteStellung(char winner){ 
        HashMap<ArrayList<Integer>, Integer> games = new HashMap<>();
        int rating;
        if(winner == 'O'){
           games.put(1, used);
        }
        else if(winner == 'x'){
           games.put(-1, used);
        }
        else{
          games.put(0, used);
        }
    }

Die Methode bekommt das char des Gewinners übergeben, daher 'X' = Spieler 'O'= Computer ' '= Unentschieden. Anschließend wird es wie oben beschrieben in der HashMap gespeichert.

Denkt ihr das funktioniert:confused: Oder habt ihr bessere Ideen?
 

Robat

Top Contributor
Wenn du gleich eine KI bauen willst die verschiedene Grade beinhaltet (leicht, Mittel, schwer,..) solltest du dich bspw. mal mit Algorithmen wie den minimax Algo beschäftigen. Gibt im Netz genügend Seiten die es u.a. auch an Tic Tac Toe erklären. Dort kannst du über die depth bestimmen wie gut / schlecht die KI sein soll.

Gruß Robert
 

Leon_2001

Aktives Mitglied
Super danke :)

Vermutlich macht es vorher Sinn, wenn ich mein Programm mal Eclipse tauglich mache und eine main methode + scanner implementiere. Sonst ist es irgendwann zu viel Arbeit, wenn ich noch den minimax Algortihmus mit Alphabeta suche und was weiß ich nicht alles implementiere:confused:

Gibt es eig neben diesem noch eine Alternative?
 

Robat

Top Contributor
Seh ich auch so. So ein Projekt solltest du immer noch den Prinzip Teile und Herrsche angehen. Lieber mehrere kleine Probleme / Aufgaben als ein großes.

Naja mir würde spontan noch der negamax einfallen welcher aber auch nur eine Abwandlung des minmax ist. Du kannst die natürlich auch deinen eigenen implementieren :)

PS: Alpha Beta Prunning ist nicht zwingend notwendig , würde den Algo nur verbessern
 

Leon_2001

Aktives Mitglied
Hallo :)

Ich habe mich nochmal an mein TicTacToe gesetzt und festgestellt, dass alles in eine Klasse packen Vlt nicht die beste Lösung ist^^
Hab demnach mal einen Versuch gestartet mit mehren Klassen und will diesen nochmal überarbeiten (nicht ganz zufrieden).

Es fällt mir jedoch schwer die richtigen Beziehungen zwischen den Klassen zu finden.

Folgende Klassen finde ich sinnvoll:
-Spielfeld
-Kästchen(vom Spielfeld)
-Spieler (bei einem Modus mit Computer Vlt noch 2 Klassen die davon erben --> menschlicherSpieler, Computer)

Eine Schwierigkeit ist vermutlich, dass ich keine Ahnung habe von wem das Spiel aus starten soll.
Also rein logisch betrachtet, kann man ja eher den Spielern das Spielbrett zuordnen...

Die Klasse Spielfeld hat einen Konstruktor, der ein Zweidimensionales Array erzeugt, welches Felder enhält (von Klasse Feld). Außerdem hat es eine Methode, um das Spielfeld auszugeben, auf einen Sieg oder ein Unentschieden zu prüfen und eine Methode, die über die Klasse Felder einen Stein setzt ('X' oder 'O').

Klasse Feld hat als Attribut ein Char, wo eben 'X', 'O' oder ' ' gespeichert wird, sowie eine setter und getter.

Klasse Spieler hat als Attribut Name + Zeichen, sowie eine Methode macheZug über eben die Klasse Spielfeld.

Welches Objekt sollte in der Main erzeugt werden und von welcher Klasse aus startet das Spiel? Oder fehlen noch Klassen?

ist Vlt noch eine Klasse Spielanleiter sinnvoll, der in der Main erzeugt wird und die Eingaben des Benutzers verarbeitet und dem entsprechend, eben das Spielfeld Objekt erzeugt und die Spieler oder Computer Objekte?

Vielen Dank für die Hilfe! Wichtig ist mir vor allem, dass es im Sinne der Objektorientierung ist und nicht nur das es funktioniert (tut es ja auch mit einer Klasse), sondern das es optimal von den Klassenbeziehungen ist, damit ich das richtig lerne :)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Lukasbsc Wie kann ich meinen Code optimieren? Java Basics - Anfänger-Themen 4
J Code in Hinsicht auf Lesbarkeit optimieren Java Basics - Anfänger-Themen 12
T Kann mir jemand wörtlich erklären, was in dem Code genau passiert? Java Basics - Anfänger-Themen 1
Ü Dead Code im Programm? Java Basics - Anfänger-Themen 13
I QR code in Java selber generieren Java Basics - Anfänger-Themen 5
terashy VS Code Project run error Java Basics - Anfänger-Themen 10
JaZuDemNo Code Erklärung Java Basics - Anfänger-Themen 3
M Connect-4-Code analysieren Java Basics - Anfänger-Themen 2
N BMI Rechner Was haltet ihr von dem Code habt ihr Verbesserungsvorschläge weil design teschnisch ist das nicht das geilste würde das gerne überarbeiten Java Basics - Anfänger-Themen 12
W In alten Code zurück- und dort wieder zurechtfinden? Java Basics - Anfänger-Themen 17
T code so schreiben das er von sich selber anpasst (code soll die anzahl aller bustaben bestimmen) Java Basics - Anfänger-Themen 16
J Frage zu einem "Taschenrechner" code Java Basics - Anfänger-Themen 9
T Fehlercode bei code der das Alter ausrechnet Java Basics - Anfänger-Themen 2
T Text einlesen code was kommt dahin? Java Basics - Anfänger-Themen 1
jhfjeh Strukturgramm in code Java Basics - Anfänger-Themen 11
D Tipps zum Code Java Basics - Anfänger-Themen 24
W Java-Code mit Array Java Basics - Anfänger-Themen 14
W Java-Code Java Basics - Anfänger-Themen 2
W Java code- TicTac toe Java Basics - Anfänger-Themen 51
W Java-code Java Basics - Anfänger-Themen 8
W Java-code Java Basics - Anfänger-Themen 9
W Java-Code erklären Java Basics - Anfänger-Themen 6
ohneInformatik; For Schleife. Was macht dieser Code?? Java Basics - Anfänger-Themen 5
Say Fehlenden Code finden in einer while-Schleife? Java Basics - Anfänger-Themen 11
Say 2-DIM Array Code lesen und verstehen Java Basics - Anfänger-Themen 5
Say Stelle in Code herausfinden, wie geht man vor? Java Basics - Anfänger-Themen 12
Say do-While Code Ausführung Java Basics - Anfänger-Themen 3
W Rückfrage zur Programmgestaltung (clean code) Java Basics - Anfänger-Themen 12
M intelliJ auf neuem PC, plötzlich kein Code Java Basics - Anfänger-Themen 3
Pinhg Sound in Greenfoot Code einbinden Java Basics - Anfänger-Themen 2
C Java boolean Code läuft nicht Java Basics - Anfänger-Themen 5
I Code für Bezahlsystem (auch bei Offline Aktivität) Java Basics - Anfänger-Themen 7
J Größter gemeinsamer Teiler: mein Code Java Basics - Anfänger-Themen 6
B Den Dateipfad einer Java Datei durch Code in Selbiger finden? Java Basics - Anfänger-Themen 10
A Wie könnte man diesen Code kürzer machen ? Java Basics - Anfänger-Themen 7
J Frage zu meinem Code (OOP) Java Basics - Anfänger-Themen 4
Alen123 Warum funktioniert mein Code nicht? Java Basics - Anfänger-Themen 64
Max246Sch Frage zu Währungsrechner Code Java Basics - Anfänger-Themen 2
S Hilfe bei Umänderung von Java Code Java Basics - Anfänger-Themen 16
I Code wird nicht ausgeführt Java Basics - Anfänger-Themen 2
K Wie kann man diesen Code schnell und effizient interpretieren (Man hat nur 4 Minuten) Java Basics - Anfänger-Themen 3
R ISBN-10-Code überprüfen Java Basics - Anfänger-Themen 7
I Bitte um Hilfe zu unterstehenden Code Java Basics - Anfänger-Themen 6
I Interface von einer EJB Klasse, um Code zu reduzieren Java Basics - Anfänger-Themen 1
I HTML Code säubern Java Basics - Anfänger-Themen 4
B Brauche Hilfe zu einem Code Java Basics - Anfänger-Themen 5
Temsky34 Problem mit dem Code Java Basics - Anfänger-Themen 17
N Fehler im Code (Aufgabe für Anfänger) Java Basics - Anfänger-Themen 11
N Java-Code abwärtskompatibel machen Java Basics - Anfänger-Themen 4
J Erste Schritte Was mache ich in meinem Code falsch. Java Basics - Anfänger-Themen 3
Ameise04 Variablen Inhalt einer Variable im Code verwenden? Java Basics - Anfänger-Themen 9
S Compiler-Fehler Nicht adressierbarer Code ( Non-addressable code ) Java Basics - Anfänger-Themen 5
Aemulit Java Schaltjahr berechnen Code Java Basics - Anfänger-Themen 7
A Code Problem Java Basics - Anfänger-Themen 6
C Fehler im Code Java Basics - Anfänger-Themen 10
A Zu einem bestimmten Ort im Code springen Java Basics - Anfänger-Themen 11
L Ist der Code richtig Java Basics - Anfänger-Themen 3
josfe1234 code vereinfachen Java Basics - Anfänger-Themen 15
nonickatall Ausführbarkeit von Code testen bzw. Remote Debugging Java Basics - Anfänger-Themen 4
F Frage betreff Programm mit dem man C++-Code in JAVA-Code übersetzen lassen kann Java Basics - Anfänger-Themen 2
S Fehler bei Code mit SubStrings für mich nicht auffindbar. Java Basics - Anfänger-Themen 4
G Programm Code Java Basics - Anfänger-Themen 5
C Code zusammenfassen Java Basics - Anfänger-Themen 5
I Erklärung zum Java Code Java Basics - Anfänger-Themen 2
T Programmablaufsplaninterpretation in Code umformen Java Basics - Anfänger-Themen 1
dieter000 Kurze Frage kann mir ejmand kurz diesen Code erklären, bzw wie man die zeilen erklärt und so Java Basics - Anfänger-Themen 1
AlexVo String zu Java Anweisung getString("*** java code ***") Java Basics - Anfänger-Themen 19
M ISBN-Code Java Basics - Anfänger-Themen 26
B Zeitgleiches Arbeiten am Code mit mehreren Personen? Java Basics - Anfänger-Themen 7
S Wie kann ich bei diesem Code erreichen, das als Ergebnis hier 15 herauskommt? Java Basics - Anfänger-Themen 23
N Kann man den Code vereinfachen? Java Basics - Anfänger-Themen 25
marcooooo Code erklären Java Basics - Anfänger-Themen 28
marcooooo Code erklären Java Basics - Anfänger-Themen 4
S Advent of Code Day4 Java Basics - Anfänger-Themen 4
B Nach eingefügtem Code erkennt Compiler keine Instanzvar und meldet SyntaxError Java Basics - Anfänger-Themen 2
Gaudimagspam Caesars Code entziffern in Java Java Basics - Anfänger-Themen 8
NeoLexx equals()-Methode Verständnis Frage anhand Code Beispiel Java Basics - Anfänger-Themen 22
I Input/Output Code wird doppelt ausgeführt Java Basics - Anfänger-Themen 3
T Main startet nicht bei vorgegebenen Code Java Basics - Anfänger-Themen 41
B Frage zum Code verständnis im Resultat Java Basics - Anfänger-Themen 10
J Fehler im Code, aber ich weiß nicht wieso! Java Basics - Anfänger-Themen 6
S Mehrere Probleme im Code Java Basics - Anfänger-Themen 7
M Code nur für Cracks? Crack the Passwort Übung Java Basics - Anfänger-Themen 7
parrot Code entferneJedeZweiteZiffer Java Basics - Anfänger-Themen 6
G Code kürzen Java Basics - Anfänger-Themen 5
Bluedaishi Source Code Signieren Java Basics - Anfänger-Themen 22
L Best Practice Code Refactoring für Methoden mit fast gleicher Aufbau Java Basics - Anfänger-Themen 6
L Best Practice Code refactern Java Basics - Anfänger-Themen 30
G code kürzen Java Basics - Anfänger-Themen 16
A Code umschreiben Java Basics - Anfänger-Themen 6
Torsten.E JavaFX mit Visual Studio Code verwenden Java Basics - Anfänger-Themen 1
C Beispiel-Code mit Pair wird nicht compiliert. Java Basics - Anfänger-Themen 8
X Reverse algorithm engineering (Java code) Java Basics - Anfänger-Themen 6
T Bufferedwriter code Nullpointerexception Java Basics - Anfänger-Themen 4
V Switch Methode macht Code kaputt Java Basics - Anfänger-Themen 18
R Was muss ich an meinem Code ändern? Java Basics - Anfänger-Themen 2
S Bewertet meinen Code - Part 1 Java Basics - Anfänger-Themen 8
M Java Code Verständnis Java Basics - Anfänger-Themen 4
M Java Code Verständnis Java Basics - Anfänger-Themen 2
J Ich brauche Hilfe bei einem Code (Variablen speichern) Java Basics - Anfänger-Themen 29

Ähnliche Java Themen

Neue Themen


Oben