Klassen Wie kann ich mein Java Textadventure verbessern, um ein Klassendiagramm zu erstellen?

dennis_lnz

Mitglied
Hallo,

Ich programmiere für die Schule ein kleines Textadventure mit Java. Dafür habe ich eine Klasse (Main) erstellt und mein Programm geschrieben. Nun sollen wir für unser Textadventure ein Klassendiagramm erstellen. Hierfür benötige ich ja mehrere Klassen. Meine Frage ist, wie ich mein Textadventure umbauen muss um mehrere Klassen zu erstellen, zum beispiel für den Held oder den Gegner, um ein übersichtliches Programm zu bekommen. Ebenfalls sind Anmerkungen zu meinem Programm gerne erwünscht, bin Absoluter Anfänger :)

Danke im Vorraus.

Hier mein Code, welchen ich mit Eclipse erstellt habe:
Java:
package adventuregame;

import java.util.Scanner;


public class Main {
   
    //Definieren von Variablen und einführen eines Scanners
    Scanner myScanner = new Scanner(System.in);
    Scanner enterScanner = new Scanner(System.in);
    int lebenspunkteHeld;
    String name;
    String waffe;
    int auswahl;
    int lebenspunkteGegner;
   
    int hebelErsteKreuzung;

    public static void main(String[] args) {
        Main game;
        game = new Main();

        game.startwerte();
        game.magischesTor();
    }

    //Spielstart und das Festlegen von Variablenwerten
    public void startwerte() {

        lebenspunkteHeld = 10;
        lebenspunkteGegner = 15;

        waffe = "Schwert";

        System.out.println("Deine Lebenspunkte: " + lebenspunkteHeld);
        System.out.println("Deine Waffe: " + waffe);

        System.out.println("Hier kannst du deinen Namen eingeben:");

        name = myScanner.nextLine();

        System.out.println("Hallo " + name + ", Lass uns Loslegen!");
    }
   
    //Interaktion mit dem alten Mann und betreten des Waldes  
    public void magischesTor() {

            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du befindest dich vor einem mystisch aussehenden Tor.");
            System.out.println("Ein alter Mann mit Gehstock steht vor dem Tor.");
            System.out.println("");
            System.out.println("Was möchtest du machen?");
            System.out.println("");
            System.out.println("1: Mit dem Mann reden");
            System.out.println("2: Den alten Mann angreifen");
            System.out.println("3: Durch das Tor gehen");
            System.out.println("\n------------------------------------------------------------------\n");

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                System.out.println("Alter Mann: Guten Tag, du musst " + name
                            + " sein\nHinter dem Tor liegt ein unheimlicher Wald, in dem es nur so von gefährlichen Kreaturen wimmelt.\nKomm herein und hilf mir sie zu beseitigen, du bist der Ausserwählte");
                    enterScanner.nextLine();
                    magischesTor();
                }

            else if(auswahl == 2) {
                lebenspunkteHeld = lebenspunkteHeld - 1;
                System.out.println(
                        "Alter Mann: Was soll das?\n\nDer alte Mann schlägt dich mit seinem Stock, du scheinst ihn nicht getroffen zu haben und hörst auf zu kämpfen.\n(Du erhälst einen Schadenspunkt)\n");
                System.out.println("Deine Lebenspunkte: " + lebenspunkteHeld);
                enterScanner.nextLine();
                magischesTor();
            } else if (auswahl == 3) {
                ersteKreuzung();
            } else {
                magischesTor();
            }  
                }

   
    //Wegkreuzung am Wald und Möglicher Durchgang zu der nächsten Kreuzung
    public void ersteKreuzung() {
        if (hebelErsteKreuzung == 1) {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Als du wieder an der Kreuzung ankommst, entdeckst du ein großes Loch in der Wand.\n\n");
            System.out.println("1: Durch das Loch gehen");
            System.out.println("2: bleiben");
            System.out.println("\n------------------------------------------------------------------\n");
           
            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                System.out.println("Die Mauer schließt sich wieder, du gehst einen Weg entlang..\n\n");
                zweiteKreuzung();
            } else if (auswahl == 2) {
                hebelErsteKreuzung = 2;
                System.out.println("Die Mauer schließt sich wieder, der Hebel muss erneut gezogen werden.\n\n");
                ersteKreuzung();
            } else {
                ersteKreuzung();
            }
           
           
        } else {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du bist and einer Kreuzung angekommen. Eine Mauer versperrt den Weg, es geht nach rechts oder links.\n\n");
            System.out.println("1: Gehe nach rechts");
            System.out.println("2: Gehe nach links");
            System.out.println("3: Zurück zum magischen Tor");
            System.out.println("\n------------------------------------------------------------------\n");

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                    rechts1();
            } else if (auswahl == 2) {
                    links1();
            } else if (auswahl == 3) {
                    magischesTor();
            } else {
                    ersteKreuzung();
            }
                }  
                    }
       
    //Möglichkeit rechts
    public void rechts1() {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du läufst an Bäumen vorbei zu einem mysteriösen Gelände auf dem ein eiserner Hebel steht. Du ziehst an dem Hebel.");
            System.out.println("1: Zurück zur Kreuzung");
            System.out.println("\n------------------------------------------------------------------\n");
            hebelErsteKreuzung = 1;

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                    ersteKreuzung();
            } else {
                    rechts1();
            }
                }

    //Möglichkeit links
    public void links1() {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du läufst die Mauer entlang und entdeckst eine tote Kreatur, in der ein ein goldener Dolch steckt. Du ziehst den Dolch aus ihr heraus");
            waffe = "Dolch";
            System.out.println("Deine neue Waffe: " + waffe);
            System.out.println("1: Zurück zur Kreuzung");
            System.out.println("\n------------------------------------------------------------------\n");

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                    ersteKreuzung();
            } else {
                    links1();
            }  
                }
                       
       
    //Zweite Kreuzung
    public void zweiteKreuzung() {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du läufst weiter, bis du zu einer Gabelung gelangst.\n\n");
            System.out.println("1: Geradeaus weitergehen");
            System.out.println("2: nach rechts gehen");
            System.out.println("3: nach links gehen");
            System.out.println("\n------------------------------------------------------------------\n");

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                //mehm();
            } else if (auswahl == 2) {
                  rechts2();
            } else if (auswahl == 3) {
                  links2();
            } else {
                zweiteKreuzung();
            }
                }
   
    //Möglichkeit links
    public void rechts2() {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du läufst zu einem kleinen Bach, in dem frisches klares Wasser fließt und trinkst einen Schluck.");
            System.out.println("Du heilst dich.");
            lebenspunkteHeld = lebenspunkteHeld + 1;
            System.out.println("Deine Lebenspunkte: " + lebenspunkteHeld);
            System.out.println("1: Zurück zur Kreuzung");
            System.out.println("\n------------------------------------------------------------------\n");

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                zweiteKreuzung();
            } else {
                rechts2();
            }
                }
   
    //Möglichkeit rechts
    public void links2() {
            System.out.println("\n------------------------------------------------------------------\n");
            System.out.println("Du Du läufst einen dunklen Pfad entlang bis du eienen Friedhof am Straßenende siehst. Du gehst Zielstrebig hin, als du ein rascheln hörst. Plötzlich steht ein Skelettartiges Wesen von dir");
            System.out.println("1: Greife das Wesen an");
            System.out.println("2: Renne so schnell wie du kannst");
            System.out.println("\n------------------------------------------------------------------\n");
            hebelErsteKreuzung = 1;

            auswahl = myScanner.nextInt();

            if (auswahl == 1) {
                    kämpfen();
            } else if (auswahl ==2 ) {
                    zweiteKreuzung();
            }
                }
   
    public void kämpfen() {
        System.out.println("\n------------------------------------------------------------------\n");
        System.out.println("Deine Lebenspunkte: " + lebenspunkteHeld);
        System.out.println("Lebenspunkte Gegner: " + lebenspunkteGegner);
        System.out.println("1: Angriff");
        System.out.println("2: Fliehen");
        System.out.println("\n------------------------------------------------------------------\n");

        auswahl = myScanner.nextInt();

        if (auswahl == 1) {
            angriff();
        } else if (auswahl == 2) {
            zweiteKreuzung();
        } else {
            kämpfen();
        }
    }
   
    public void angriff() {
        int schaden = 0;

        if (waffe.equals("Schwert")) {
            schaden = new java.util.Random().nextInt(5);
        } else if (waffe.equals("Dolch")) {
            schaden = new java.util.Random().nextInt(8);
        }

        System.out.println("Du greifst deinen Gegner an und machst " + schaden + " Schaden!");

        lebenspunkteGegner = lebenspunkteGegner - schaden;

        System.out.println("Lebenspunkte Gegner: " + lebenspunkteGegner);

        if (lebenspunkteGegner < 1) {
            sieg();
        } else if (lebenspunkteGegner > 0) {
            int monsterDamage = 0;

            monsterDamage = new java.util.Random().nextInt(4);

            System.out.println("Dein Gegner greift dich an und macht " + monsterDamage + " Schaden!");

            lebenspunkteHeld = lebenspunkteHeld - monsterDamage;

            System.out.println("Deine Lebenspunkte: " + lebenspunkteHeld);

            if (lebenspunkteHeld < 1) {
                tod();
            } else if (lebenspunkteHeld > 0) {
                kämpfen();
            }
        }

    }

    public void tod() {
        System.out.println("\n------------------------------------------------------------------\n");
        System.out.println("Du bist gestorben!!!");
        System.out.println("\n\nGAME OVER");
        System.out.println("\n------------------------------------------------------------------\n");
    }
   
    public void sieg() {
        System.out.println("\n------------------------------------------------------------------\n");
        System.out.println("Du hast deinen Gegner getötet!");
        System.out.println("1: Gehe zurück zur Kreuzung");
        System.out.println("\n------------------------------------------------------------------\n");
       
        auswahl = myScanner.nextInt();
        if (auswahl == 1) {
            zweiteKreuzung();
        } else {
            sieg();
        }

    }
        }
 
Zuletzt bearbeitet:

KonradN

Super-Moderator
Mitarbeiter
Der Ansatz ist schon falsch. Du solltest dir erst das Klassendiagramm überlegen: Was für Objekte gibt es, die miteinander agieren und so. Was für Daten werden verwaltet? Dann kann man das implementieren.

Da muss man dann auch abstrahieren. So hast Du z.B. eine Klasse Raum und davon hast du mehrere Instanzen. Du baust das also nicht fest in Methoden sondern Du hast es dann einmal und du füllst dann nur noch die Daten ei der Erstellung der Instanzen.
 

Blender3D

Top Contributor
Ich programmiere für die Schule ein kleines Textadventure mit Java. Dafür habe ich eine Klasse (Main) erstellt und mein Programm geschrieben. Nun sollen wir für unser Textadventure ein Klassendiagramm erstellen. Hierfür benötige ich ja mehrere Klassen. Meine Frage ist, wie ich mein Textadventure umbauen muss um mehrere Klassen zu erstellen, zum beispiel für den Held oder den Gegner, um ein übersichtliches Programm zu bekommen.
Ich habe vor einiger Zeit ein kleines TextAdventure angefangen. Es ist zwar nicht fertig, aber es lässt sich schon recht gut spielen.
Zum Testen lade dir die Datei "tinyAdventure.jar" herunter. Öffne die Konsole wechsle in das Verzeichnis dieser Datei.
Gib java -jar tinyAdventure.jar ein.
1666797415327.png
1666799078525.png
Der Code dazu:
Java:
import textadventure.ActionCmd.DIRECTION;

public class StartTinyAdventure {

    public static void main(String[] args) {
        CmdInterPreter.start(init());
    }

    private static Player init() {
        Room clearing = new Room();
        Room castle = new Room();
        Room wood = new Room();
        Room grotto = new Room();
        castle.setDescription("Burg!");
        castle.setFinalMessage("Bravo du bist endlich wieder zu Hause!");
        clearing.setDescription("Lichtung im Wald!");
        grotto.setDescription("Grotte!");
        wood.setDescription("Dunkler Wald!");
        Item[] items = createItems();
        clearing.addItem(items[ActionCmd.SHOVEL]);
        wood.addItem(items[ActionCmd.SPRING]);
        wood.addItem(items[ActionCmd.KEY]);
        Actor troll = new Actor(ActionCmd.items[ActionCmd.TROLL]);
        troll.setBlockedDir(DIRECTION.EAST, ActionCmd.items[ActionCmd.CUP_BARBITURATE]);
        troll.setMessage("Der Troll schlaeft jetzt!");
        wood.setActor(troll);
        items[ActionCmd.SPRING].setPortable(false);
        grotto.addItem(items[ActionCmd.CASTLE_KEY]);
        clearing.addItem(items[ActionCmd.CHEST]);
        items[ActionCmd.CHEST].addItem(items[ActionCmd.BARBITURATE]);
        items[ActionCmd.CHEST].addItem(items[ActionCmd.CUP]);
        items[ActionCmd.CHEST].setProperty("vergraben");
        items[ActionCmd.CHEST].setPropertyKey(ActionCmd.items[ActionCmd.SHOVEL]);
        items[ActionCmd.CHEST].setKey(items[ActionCmd.KEY]);
        items[ActionCmd.CHEST].setPropertyItem(true);
        items[ActionCmd.SPRING].setPortable(false);
        items[ActionCmd.CUP].setTransform(items[ActionCmd.CUP_WATER], items[ActionCmd.SPRING].name);
        items[ActionCmd.CUP_WATER].setTransform(items[ActionCmd.CUP_BARBITURATE], items[ActionCmd.BARBITURATE].name);
        clearing.setDoor(DIRECTION.WEST,
                new Door(ActionCmd.items[ActionCmd.CASTEL_GATE], castle, items[ActionCmd.CASTLE_KEY]));
        castle.setDoor(DIRECTION.EAST, new Door("Lichtung", clearing, null));
        clearing.setDoor(DIRECTION.NORTH, new Door("Wald", wood, null));
        wood.setDoor(DIRECTION.SOUTH, new Door("Lichtung", clearing, null));
        wood.setDoor(DIRECTION.EAST, new Door("Felsiges Gebiet", grotto, null));
        grotto.setDoor(DIRECTION.WEST, new Door("Wald", wood, null));
        return new Player(clearing);
    }

    public static Item[] createItems() {
        Item[] items = new Item[ActionCmd.items.length];
        for (int i = 0; i < items.length; i++)
            items[i] = new Item(ActionCmd.items[i], true);
        return items;
    }
}
Java:
public class ActionCmd {
    /**
     * COMMAND has to correlate to commands.
     *
     * @see ActionCmd#getCmd()
     * @see ActionCmd#getCmdStr()
     */
    public enum COMMAND {
        GO, TAKE, DROP, HELP, USE, OPEN, GIVE, LOOK, INVENTORY, END
    };

    // command's id positions in array commands
    private static final int CMD_GO_ID = 0;
    private static final int CMD_HELP_ID = 3;
    private static final String[] commands = { "gehe", "nimm", "verliere", "hilfe", "benutze", "oeffne", "gib", "schau",
            "Inventar", "Ende" };

    private static String directionName[] = { "Westen", "Norden", "Osten", "Sueden" };

    public enum DIRECTION {
        WEST, NORTH, EAST, SOUTH
    };

    public final static int BARBITURATE = 0;
    public final static int CHEST = 1;
    public final static int SHOVEL = 2;
    public final static int CUP = 3;
    public final static int SPRING = 4;
    public final static int CASTLE_KEY = 5;
    public final static int CUP_WATER = 6;
    public final static int CUP_BARBITURATE = 7;
    public final static int KEY = 8;
    public final static int CASTEL_GATE = 9;
    public final static int TROLL = 10;
    public static final String[] items = { "Schlafmittel", "Truhe", "Schaufel", "Becher", "Quelle", "Burgschluessel",
            "Trinkwasser", "Schlaftrunk", "Schluessel", "Burgtor", "Troll" };

    // conjunction's id positions in array conjunctions
    private static final int WIDTH = 0;
    private static final int FROM = 1;
    private static final int INTO = 2;
    private static final int TO = 3;
    public static final String[] conjunction = { "mit", "aus", "in", "an" };
    public static final String[] directions = { "Osten", "Sueden", "Norden", "Westen" };
    private DIRECTION direction = null;
    private static final int COMMAND_ID = 0; // command's id position in array wordID
    private static final int CONUJNCTION_ID = 2; // conjunction's id position in array wordID
    private int[] wordID = null;

    /**
     * Syntax command [item|direction] [conjunction&item],
     *
     * @param cmd
     *            String Users command line
     * @throws IllegalArgumentException
     */
    public ActionCmd(String cmd) throws IllegalArgumentException {
        if (cmd == null || cmd.length() == 0)
            throw new IllegalArgumentException("Bitte einen Text eingeben!");
        String[] words = cmd.split(" ");
        wordID = new int[words.length];
        if (solveDirectionCommand(words)) // go command
            return;
        if (!setWordID(words, commands, COMMAND_ID)) // get command otherwise
            throw new IllegalArgumentException("Befehl '" + words[COMMAND_ID] + "' unbekannt!");
        for (int i = 1; i < words.length; i++) { // get items and conjunctions
            if (i % 2 != 0) { // each 2nd word is an item
                if (!setWordID(words, items, i))
                    throw new IllegalArgumentException("'" + words[i] + "' unbekannt!");
            } else { // between items is a conjunction
                if (!setWordID(words, conjunction, i))
                    throw new IllegalArgumentException("Bindewort '" + words[i] + "' unbekannt!");

            }
        }
        checkConjunction();
    }

    private void checkConjunction() throws IllegalArgumentException {
        int numWords = wordID.length;
        if (numWords < 3)
            return;
        if (numWords == 3)
            conjunctionError();
        if (numWords == 4) {
            String word = getConjunction();
            switch (getCmd()) {
            case OPEN:
            case USE:
                if (word.equals(conjunction[WIDTH]))
                    return;
                break;
            case DROP:
                if (word.equals(conjunction[INTO]))
                    return;
                break;
            case TAKE:
                if (word.equals(conjunction[FROM]))
                    return;
            case GIVE:
                if (word.equals(conjunction[TO]))
                    return;
            default:
            }
            conjunctionError();
        }
    }

    public void conjunctionError() {
        throw new IllegalArgumentException("Falsch verwendetes Bindewort '" + getConjunction() + "'");
    }

    public static String directionIdToName(int id) {
        return directionName[id];
    }

    public static int find(String[] data, String match) {
        for (int i = 0; i < data.length; i++) {
            if (match.toLowerCase().equals(data[i].toLowerCase()))
                return i;
        }
        return -1;
    }

    public static int getId(DIRECTION dir) {
        return dir.ordinal();
    }

    public COMMAND getCmd() {
        return COMMAND.valueOf(COMMAND.values()[wordID[COMMAND_ID]].toString());
    }

    public String getCmdStr() {
        return commands[wordID[COMMAND_ID]];
    }

    public String getConjunction() {
        return conjunction[wordID[CONUJNCTION_ID]];
    }

    /**
     *
     * @return {@link Room}
     */
    public DIRECTION getDir() {
        return direction;
    }

    public static String getHelp() {
        StringBuffer tmp = new StringBuffer("Befehle: " + commands[0]);
        for (int i = 1; i < commands.length; i++) {
            tmp.append(", ");
            tmp.append(commands[i]);
        }
        tmp.append(".");
        tmp.append(System.lineSeparator());
        tmp.append("Bindeworte: " + conjunction[0]);
        for (int i = 1; i < conjunction.length; i++) {
            tmp.append(", ");
            tmp.append(conjunction[i]);
        }
        tmp.append(".");
        return tmp.toString();
    }

    public String getItem(int pos) {
        if (pos < 0 || pos >= getNumberItems())
            throw new IllegalArgumentException("Possible item position [0-" + (getNumberItems() - 1));
        return items[wordID[1 + pos * 2]];
    }

    public int getNumberItems() {
        return wordID.length / 2;
    }

    public boolean isActionCmd() {
        return !isDirectionCmd() && !isHelpCmd();
    }

    public boolean isDirectionCmd() {
        return direction != null;
    }

    public boolean isHelpCmd() {
        return commands[wordID[COMMAND_ID]].equals(commands[CMD_HELP_ID]);
    }

    /**
     * Checks if words[id] is in data[]. If successful wordID[id] will be set.
     *
     * @param words
     *            Data for comparison.
     * @param data
     *            Data for scan.
     *
     * @param id
     *            Defines string in words[] to be compared and set.
     * @return boolean
     */
    private boolean setWordID(String[] words, String[] data, int id) {
        int i = find(data, words[id]);
        if (i < 0)
            return false;
        wordID[id] = i;
        return true;
    }

    /**
     * Checks if command is go direction. If true, direction will be set.
     *
     * @see ActionCmd#getDir()
     *
     * @param words
     *            List of entered words.
     * @return True if it was a go command.
     */
    private boolean solveDirectionCommand(String[] words) {
        if (words[COMMAND_ID].equals(commands[CMD_GO_ID])) { // 'gehe osten, sueden norden westen
            if (words.length < 2)
                return false;
            int id = find(directions, words[1]);
            switch (id) {
            case 0:
                direction = DIRECTION.EAST;
                break;
            case 1:
                direction = DIRECTION.SOUTH;
                break;
            case 2:
                direction = DIRECTION.NORTH;
                break;
            case 3:
                direction = DIRECTION.WEST;
                break;
            default:
                throw new IllegalArgumentException("Unknow direction!");
            }
            return true;
        }
        return false;
    }
}
Java:
import textadventure.ActionCmd.DIRECTION;

public class Actor {
    private DIRECTION blockedDir = null;
    private String name;
    private String key;
    private String message;

    public Actor(String name) {
        this.name = name;
    }

    public boolean isDirBlocked(DIRECTION dir) {
        return blockedDir != null && blockedDir.equals(dir);
    }

    public DIRECTION getBlockedDir() {
        return blockedDir;
    }

    public String getName() {
        return name;
    }

    public void giveKey(String key) throws IllegalArgumentException {
        System.out.println(key + "\t" + this.key);
        if (this.key == null || !this.key.equals(key))
            throw new IllegalArgumentException("'" + name + "' kann '" + key + "' nicht gebrauchen!");
        blockedDir = null;
        if (message != null)
            System.out.println(message);
    }

    public void setBlockedDir(DIRECTION blockedDir, String key) {
        this.blockedDir = blockedDir;
        this.key = key;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name + (blockedDir != null ? " blockiert den Weg nach " + blockedDir : "");
    }

}
Java:
import java.util.Scanner;

public class CmdInterPreter {

    private static Player player = null;

    public static void start(Player player) {
        System.out.println("\tTiny text adventure\n\t (c) by Blender3D\n\nTip: Probiere den Befehl 'Hilfe' aus!");
        CmdInterPreter.player = player;
        Scanner scanner = new Scanner(System.in);
        ActionCmd cmd = null;
        boolean running = true;
        player.look();
        do {
            System.out.print(">");
            try {
                cmd = new ActionCmd(scanner.nextLine());
                running = execute(cmd);
                if (player.hasFinished()) {
                    System.out.println(player.getRoom().getFinalMessage());
                    running = false;
                }
            } catch (IllegalArgumentException e) {
                System.out.println(e.getMessage());
            }
        } while (running);
        scanner.close();
        System.out.println("ENDE");
    }

    private static boolean execute(ActionCmd cmd) throws IllegalArgumentException {
        switch (cmd.getCmd()) {
        case DROP:
            dropItem(cmd);
            break;
        case GO:
            player.go(cmd.getDir());
            break;
        case HELP:
            System.out.println(ActionCmd.getHelp());
            break;
        case OPEN:
            openItem(cmd);
            break;
        case TAKE:
            takeItem(cmd);
            break;
        case USE:
            useItem(cmd);
            break;
        case END:
            return false;
        case GIVE:
            giveItem(cmd);
            break;
        case LOOK:
            player.look();
            break;
        case INVENTORY:
            player.showInventory();
        }
        return true;
    }

    public static void dropItem(ActionCmd cmd) throws IllegalArgumentException {
        int numItems = cmd.getNumberItems();
        if (numItems == 0)
            throw new IllegalArgumentException("Was soll ich verlieren?");
        String item = cmd.getItem(0);
        if (numItems == 1)
            player.dropItem(item);
        if (numItems == 2)
            player.dropItem(item, cmd.getItem(1));
    }

    private static void giveItem(ActionCmd cmd) throws IllegalArgumentException {
        int numItems = cmd.getNumberItems(); // TODO
        if (numItems == 0)
            throw new IllegalArgumentException("Was soll ich geben?");
        String item = cmd.getItem(0);
        if (!player.has(item))
            throw new IllegalArgumentException("Du hast '" + item + "' nicht!");
        if (numItems == 1)
            throw new IllegalArgumentException("Wem soll ich'" + item + "' geben?");
        if (numItems == 2)
            player.giveItem(item);
    }

    public static void openItem(ActionCmd cmd) throws IllegalArgumentException {
        int numItems = cmd.getNumberItems();
        if (numItems == 0)
            throw new IllegalArgumentException("Was soll ich oeffen?");
        String container = cmd.getItem(0);
        if (numItems == 1)
            throw new IllegalArgumentException("Mit was soll ich '" + container + "' oeffen?");
        player.open(container, cmd.getItem(1));
    }

    public static void takeItem(ActionCmd cmd) throws IllegalArgumentException {
        int numItems = cmd.getNumberItems();
        if (numItems == 0)
            throw new IllegalArgumentException("Was soll ich nehmen?");
        if (numItems == 1)
            player.takeItem(cmd.getItem(0));
        else
            player.takeItem(cmd.getItem(0), cmd.getItem(1));
    }

    private static void useItem(ActionCmd cmd) throws IllegalArgumentException {
        int numItems = cmd.getNumberItems();
        if (numItems == 0)
            throw new IllegalArgumentException("Was soll ich benutzen?");
        String item = cmd.getItem(0);
        if (!player.has(item))
            throw new IllegalArgumentException("Du hast '" + item + "' nicht!");
        if (numItems == 1)
            throw new IllegalArgumentException("Mit was soll ich'" + item + "' benutzen?");
        if (numItems == 2) {
            player.useItem(cmd.getItem(1), item);
        }
    }
}
Java:
public class Door {
    private int directionId = 0;
    private String name;

    private Room exit;
    private Item key;

    public final static String separator = ":";

    public Door(String name, Room exit, Item key) {
        this.exit = exit;
        this.name = name;
        this.key = key;
    }

    public Door(String data) {

    }

    public String toDataString() {
        StringBuffer tmp = new StringBuffer(directionId + separator);
        tmp.append(name + separator);
        tmp.append(exit.toDataString());
        tmp.append(key.toDataString());
        return tmp.toString();
    }

    public Room getExit() throws IllegalArgumentException {
        if (!isOpen())
            throw new IllegalArgumentException("Die Tuer ist verschlossen!");
        return exit;
    }

    public String getName() {
        return name;
    }

    public boolean isOpen() {
        return key == null;
    }

    public void setDirectionId(int id) {
        directionId = id;
    }

    public void useKey(String key) throws IllegalArgumentException {
        if (this.key == null)
            throw new IllegalArgumentException("Die Tuer ist bereits offen!");
        if (!this.key.name.equals(key))
            throw new IllegalArgumentException("Mit '"+ key+"' kannst Du '"+ name +"' nicht oeffnen!");
        this.key = null;     
    }

    @Override
    public String toString() {
        return name + (key != null ? " verschlossen" : "") + "[>" + ActionCmd.directionIdToName(directionId) + "]";
    }

}
Java:
import java.util.Iterator;
import java.util.Vector;

public class Inventory {
    private Vector<Item> liste = new Vector<Item>();
    public final static String separator = "|";

    public Inventory() {

    }

    public Inventory(String data) {
        String[] obj = data.split(separator);
        for (int i = 0; i < obj.length; i++)
            liste.add(new Item(obj[i]));
    }

    public void add(Item o) {
        liste.add(o);
    }

    public boolean contains(String s) {
        return find(s) != null;
    }

    public Item find(String s) {
        for (Item o : liste) {
            if (o.name.equals(s))
                return o;
        }
        return null;
    }

    public Item get(String name) {
        return find(name);
    }

    public Item remove(String s) {
        Item o = find(s);
        if (o == null)
            return null;
        liste.remove(o);
        return o;
    }

    public int size() {
        return liste.size();
    }

    public String toDataString() {
        StringBuffer tmp = new StringBuffer();
        Iterator<Item> it = liste.iterator();
        while (it.hasNext()) {
            tmp.append(it.next().toDataString());
            if (it.hasNext())
                tmp.append(separator);
        }
        return tmp.toString();
    }

    @Override
    public String toString() {
        StringBuffer tmp = new StringBuffer();
        int len = liste.size();
        for (int i = 0; i < len; i++)
            tmp.append(liste.get(i) + (i < len - 1 ? ", " : ""));

        return tmp.toString();
    }

}
Java:
public class Item {
    public final String name;
    private boolean isPortable = true;
    private boolean propertyItem = false;
    private String key = NO_KEY;
    private String propertyKey = NO_KEY;
    private String transformKey = NO_KEY;
    private Inventory inventory = null;
    public static final String separator = ";";
    private final static String NO_KEY = "-";
    private String property = NO_KEY;
    private Item transform = null;

    public Item(String data) {
        String[] obj = data.split(separator);
        name = obj[0];
        isPortable = Integer.parseInt(obj[1]) == 1;
        key = obj[2];
        if (obj.length > 3)
            inventory = new Inventory(obj[3]);
        System.exit(1);
    }

    public Item(String name, boolean isPortable) {
        this.name = name;
        this.isPortable = isPortable;     
    }

    public void addItem(Item item) {
        if (inventory == null)
            inventory = new Inventory();
        inventory.add(item);
    }

    public void checkProperty() {
        if (!property.equals(NO_KEY))
            throw new IllegalArgumentException("'" + name + "' ist " + property + "!");
    }

    public boolean checkTransformKey(String key) {
        return transformKey == null || transformKey.equalsIgnoreCase(key);
    }

    public boolean containsItems() {
        return inventory != null && inventory.size() > 0;
    }

    private String getName() {
        return "'" + getProperty() + name + "'";
    }

    public String getProperty() {
        return property.equals(NO_KEY) ? "" : "(" + property + ")";
    }

    public Item getTransform() {
        return transform;
    }

    public boolean isProbertyItem() {
        return propertyItem;
    }

    public boolean isPortable() {
        return isPortable;
    }

    public boolean isOpen() {
        return inventory != null && key.equals(NO_KEY);
    }

    public boolean isTransformer() {
        return transform != null;
    }

    public void setPropertyItem(boolean actionItem) {
        this.propertyItem = actionItem;
    }

    /**
     * If item is a container u can set an item as key to open it. Set key
     * {@link #NO_KEY} to open it.
     *
     * @param key
     */
    public void setKey(Item key) {
        this.key = key.name;
    }

    public void setPortable(boolean isPortable) {
        this.isPortable = isPortable;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public void setPropertyKey(String propertyKey) {
        this.propertyKey = propertyKey;     
    }

    public void setTransform(Item transform, String key) {
        this.transform = transform;
        transformKey = key;
    }

    public Item takeItem(String item) {
        if (inventory == null)
            throw new IllegalArgumentException(getName() + " ist kein Behaelter!");
        if (key != NO_KEY)
            throw new IllegalArgumentException("Du benoetigst einen Schluessel, um " + getName() + " zu oeffnen!");
        if (inventory.size() == 0)
            throw new IllegalArgumentException(getName() + " ist leer!");
        Item obj = inventory.find(item);
        if (obj == null)
            throw new IllegalArgumentException("In " + getName() + " befindet sich '" + item + "' nicht!");
        return inventory.remove(obj.name);
    }

    public String toDataString() {
        StringBuffer tmp = new StringBuffer(name + separator);
        tmp.append(isPortable ? "1" : "0" + separator);
        tmp.append(key);
        if (inventory != null)
            tmp.append(separator + inventory.toDataString());
        return tmp.toString();
    }

    @Override
    public String toString() {
        return name + (isOpen() ? " <" + inventory.toString() + ">" : "") + getProperty();
    }

    public void useKey(String key) throws IllegalArgumentException {
        if (inventory == null)
            throw new IllegalArgumentException(getName() + " ist kein Behaelter!");
        if (this.key.equals(NO_KEY))
            throw new IllegalArgumentException(getName() + " ist bereits offen!");
        if (!this.key.equals(key))
            throw new IllegalArgumentException("'" + key + "' kann " + getName() + " nicht oeffnen!");
        this.key = NO_KEY;
        System.out.println("'" + name + "' ist offen!");
    }

    public void usePropertyKey(String key) throws IllegalArgumentException {
        if (this.propertyKey.equals(NO_KEY))
            throw new IllegalArgumentException("Das hat keinen Effekt!");
        if (!this.propertyKey.equals(key))
            throw new IllegalArgumentException("'" + key + "' funktioniert mit '" + toString() + "' nicht!");
        System.out.println(getName() + " ist jetzt '" + name + "'!");
        propertyKey = NO_KEY;
        property = NO_KEY;

    }
}
Java:
import textadventure.ActionCmd.DIRECTION;

public class Player {
    private Inventory inventory = new Inventory();
    public final String separator = "+";
    private Room room;

    public Player(Room room) {
        this.room = room;
    }

    public Player(String data) {
        String[] obj = data.split(separator);
        room = new Room(obj[0]);
        inventory = new Inventory(obj[1]);
    }

    public String toDatastring() {
        StringBuffer tmp = new StringBuffer(room.toDataString() + separator);
        tmp.append(inventory.toDataString());
        return tmp.toString();
    }

    public Room getRoom() {
        return room;
    }

    private Item getActionItem(String name) throws IllegalArgumentException {
        Item src = room.getItem(name);
        if (src == null)
            src = inventory.find(name);
        if (src == null)
            throw new IllegalArgumentException("'" + name + "' gibt es hier nicht!");
        return src;
    }

    public void takeItem(String name, String container) throws IllegalArgumentException {
        Item item = getActionItem(container);
        inventory.add(item.takeItem(name));
        System.out.println("'" + name + "' genommen!");
    }

    public void takeItem(String name) throws IllegalArgumentException {
        inventory.add(room.takeItem(name));
        System.out.println("'" + name + "' genommen!");
    }

    public void showInventory() {
        System.out.println("Du hast > " + inventory);

    }

    public void look() {
        System.out.println(room);
    }

    public void go(DIRECTION dir) throws IllegalArgumentException {
        room = room.getExit(dir);
        look();
    }

    public void dropItem(String name) {
        room.addItem(inventory.remove(name));
        System.out.println("'" + name + "' abgelegt!");

    }

    public void dropItem(String name, String destination) {
        Item item = getActionItem(destination);
        item.addItem(inventory.remove(name));
        System.out.println("'" + name + "' in '" + destination + "' abgelegt!");
    }

    public void open(String name, String key) throws IllegalArgumentException {
        Door door = room.findDoor(name);
        if (door != null) {
            door.useKey(key);
            System.out.println("'" + name + "' geoeffnet!");
        } else {
            Item item = getActionItem(name);
            item.checkProperty();
            item.useKey(key);
        }
    }

    public void giveItem(String item) throws IllegalArgumentException { // TODO
        room.giveItemToActor(item);
    }

    public void useItem(String name, String key) throws IllegalArgumentException {
        Item item = getActionItem(name);
        if (doTransformation(item, key))
            return;
        if (!item.isProbertyItem()) {
            item = getActionItem(key);
            key = name;
            if (doTransformation(item, key))
                return;
            throw new IllegalArgumentException("Das hat keine Wirkung!");
        }         
        item.usePropertyKey(key);
    }
Java:
import java.util.StringTokenizer;

import textadventure.ActionCmd.DIRECTION;

public class Room {
    private String description = "";
    private Door[] doors = new Door[4];
    private Inventory inventory = new Inventory();
    public static final String separator = ".";
    private final static String NO_DOOR = "-";
    private Actor actor = null;
    private String finalMessage = null;

    public Room() {
    }

    /**
     *
     * @param room
     */
    public Room(String data) {
        StringTokenizer tok = new StringTokenizer(data, separator);
        String tmp = null;
        for (int i = 0; i < doors.length; i++) {
            tmp = tok.nextToken();
            if (!tmp.equals(NO_DOOR))
                doors[i] = new Door(tmp);
        }
        if (tok.hasMoreTokens()) {
            description = tok.nextToken();
            if (tok.hasMoreTokens())
                inventory = new Inventory(tok.nextToken());
        }
    }

    public void addItem(Item item) {
        inventory.add(item);
    }

    public boolean canGoTo(ActionCmd.DIRECTION go) {
        int id = directionToId(go);
        return doors[id] != null && doors[id].isOpen();
    }

    public boolean contains(String item) {
        return inventory.contains(item);
    }

    private static int directionToId(DIRECTION go) { // TODO ??
        DIRECTION[] test = DIRECTION.values();
        int iD = 0;
        for (iD = 0; iD < test.length; iD++) {
            if (test[iD].toString().equals(go.toString()))
                break;
        }
        return iD;
    }

    public String getFinalMessage() {
        return finalMessage;
    }

    public Room getExit(DIRECTION dir) throws IllegalArgumentException { // TODO
        int id = ActionCmd.getId(dir);
        if (doors[id] == null)
            throw new IllegalArgumentException("Dort ist kein Ausgang!");
        if (!doors[id].isOpen())
            throw new IllegalArgumentException("Der Ausgang ist verschlossen!");
        if (actor != null && actor.isDirBlocked(dir))
            throw new IllegalArgumentException(actor.getName() + " verperrt den Weg!");
        return doors[id].getExit();
    }

    private String getExitStr() {
        String tmp = "";
        for (int i = 0; i < doors.length; i++) {
            if (doors[i] != null)
                tmp += " -" + doors[i];
        }
        return tmp;
    }

    public Item getItem(String name) {
        return inventory.find(name);
    }

    public boolean isFinalRoom() {
        return finalMessage != null;
    }

    public void removeItem(String item) {
        inventory.remove(item);
    }

    public void setActor(Actor actor) {
        this.actor = actor;
    }

    public void setDoor(ActionCmd.DIRECTION go, Door door) {
        int id = directionToId(go);
        doors[id] = door;
        doors[id].setDirectionId(id);
    }

    public void setDescription(String beschreibe) {
        this.description = beschreibe;
    }

    public void setFinalMessage(String finalMessage) {
        this.finalMessage = finalMessage;
    }

    public Item takeItem(String name) throws IllegalArgumentException {
        Item item = inventory.find(name);
        if (item == null)
            throw new IllegalArgumentException("'" + name + "' gibt es hier nicht!");
        if (!item.isPortable())
            throw new IllegalArgumentException("'" + name + "' kann man nicht nehmen!");
        item.checkProperty();
        inventory.remove(name);
        return item;
    }

    public String toDataString() {
        StringBuffer tmp = new StringBuffer();
        for (int i = 0; i < doors.length; i++) {
            if (doors[i] == null)
                tmp.append(NO_DOOR);
            else
                tmp.append(doors[i].toDataString());
            tmp.append(separator);
        }
        tmp.append(description + separator);
        tmp.append(inventory.toDataString());
        return tmp.toString();
    }

    @Override
    public String toString() {
        String items = inventory.size() > 0 ? "\nDu siehst: " + inventory : "";
        return getSeperator() + description + "\n" + getExitStr() + items;
    }

    private String getSeperator() {
        return "------------------------------------------------------------\n";
    }

    public Door findDoor(String name) {
        for (int i = 0; i < doors.length; i++) {
            if (doors[i] != null && doors[i].getName().equalsIgnoreCase(name))
                return doors[i];
        }
        return null;
    }

    public void giveItemToActor(String key) {
        this.actor.giveKey(key);
    }

}
 

Anhänge

  • tinyAdventure.jar
    22,4 KB · Aufrufe: 0
Zuletzt bearbeitet:

dennis_lnz

Mitglied
Der Ansatz ist schon falsch. Du solltest dir erst das Klassendiagramm überlegen: Was für Objekte gibt es, die miteinander agieren und so. Was für Daten werden verwaltet? Dann kann man das implementieren.

Da muss man dann auch abstrahieren. So hast Du z.B. eine Klasse Raum und davon hast du mehrere Instanzen. Du baust das also nicht fest in Methoden sondern Du hast es dann einmal und du füllst dann nur noch die Daten ei der Erstellung der Instanzen.
Ist mir bewusst, dass ich das Klassendiagramm vorher hätte machen sollen. Denkst du es gibt jetzt noch die Möglichkeit mithilfe meines Programms Klassen zu erstellen, oder war mein Aufwand unnötig?
 

KonradN

Super-Moderator
Mitarbeiter
Ist mir bewusst, dass ich das Klassendiagramm vorher hätte machen sollen. Denkst du es gibt jetzt noch die Möglichkeit mithilfe meines Programms Klassen zu erstellen, oder war mein Aufwand unnötig?
Du kannst die Erfahrungen aus Deinem Ansatz nutzen, um dann Teile vom Code ggf. weiter zu verwenden.

Mann kann ggf. auch anfangen, mit ein paar Refactorings paar Dinge anzupassen um etwas mehr in die Richtung zu kommen, aber das dürfte unter dem Strich mehr Aufwand bedeuten als neu zu starten.

Was evtl. gehen würde: Einfach einmal den Code durchgehen und dann schauen, was man so an Objekten identifizieren kann.

Was man erst einmal hat, ist das Spiel. Das ist sozusagen erst einmal der Rahmen.
Du hast paar Instanzvariablen - 2 Scanner? Einer sollte eigentlich reichen. Das wäre dann eine Klasse UI oder so. Game hat eine Klasse UI.

Dann gibt es den Held, der hat eine Eigenschaft Lebenspunkte, Name, ...
Im Spiel ist ein Held.

UI hat dann eine Methode, den Held auszugeben. Das ist dann dieses "Deine Lebenspunkte: ..." und so.

Dann hast Du in Methoden Räume abgebildet (Klasse: Raum und die Klasse Spiel verwaltet alle Räume z.B. in einer Map). So auf den ersten Blick haben die immer:
  • eine Beschreibung.
  • Handlungsoptionen
  • Zur Identifizierung eine id oder Name.

Die Handlungsoptionen haben immer
  • eine Beschreibung ("Mit dem Mann reden")
  • eine Aktion. Die Aktion ist abstrakt. Die Aktion muss an Parametern bekommen, was benötigt wird. Das merkst Du bei der Implementation. Oder Du arbeitest da immer mit der Instanz des Spiels.

Dann kannst Du konkrete Handlungen erstellen. So kann es eine Handlung WechselRaumHandlung geben. Die hat dann neben der Beschreibung von der Handlunfsoption Klasse noch einen Zielraum.
==> Damit haben wir im Helden noch ein weiteres Attribut: Den Raum, in dem der Held ist.

Eine andere Möglichkeit wäre ohne Vererbung - dann hat man eine Klasse Handlungsoption und der Konstruktor nimmt dann die Beschreibung und die Aktion. Das wäre dann ein funktionales Interface. Das geht etwas Richtung Strategy Pattern. Aber wenn Du damit noch nichts gemacht hast, dann ist das mit der Vererbung ggf. einfacher für Dich.

An der Stelle breche ich mal ab - das wären so ein paar erste Schritte, um z.B. einen ersten Stand zu haben mit einem Spiel, das mehrere Räume hat und der Spieler kann erst einmal zwischen den Räumen wechseln.

Das kann man dann erweitern:
In Räumen können dann noch Gegenstände sein. Ein Raum listet auch die Gegenstände auf und führt auch Aktionen der Gegenstände auf.
Dann kannst Du z.B. Gegenstände aufheben oder eine Tür öffnen oder so. Die Gegenstände können einen Status haben: So hat geöffnete Tür eine andere Beschreibung und eine andere Handlung als eine geschlossene Tür.

Gegner können dann auch als Gegenstand daher kommen. Beschreibung und Aktionen .... Dann kann man einen Gegner angreifen oder so ...

Das wäre also auch ein mögliches Vorgehen....

Ach ja - ggf. noch etwas zu dem Spiel, das ich skizziert habe:
  • Da ist ja ein Held
  • Da sind alle Räume mit allen Aktionen drin.
==> Das muss also alles initialisiert werden.

Dann hast Du da eine Gameloop:
So lange das Spiel nicht beendet ist, wird
  • der Raum, in dem der Held ist, ausgegeben und es wird eine Eingabe abgefragt.
  • dann wird die Aktion durchgeführt incl. Ausgabe des Ergebnisses.

Hat diese Sichtweise ggf. etwas geholfen? Wäre das ein Vorgehen, das für dich praktikabel ist?
 

Blender3D

Top Contributor
Die Klasse Player scheint unvollständig zu sein. Die Methode doTransformation(..) fehlt unter anderem. Kannst Du mal nachschauen und ggf. nachreichen? Bitte😏
Sorry war ein Copy Paste Fehler.
Hier noch einmal die komplette Klasse Player.
Java:
import textadventure.ActionCmd.DIRECTION;

public class Player {
    private Inventory inventory = new Inventory();
    public final String separator = "+";
    private Room room;

    public Player(Room room) {
        this.room = room;
    }

    public Player(String data) {
        String[] obj = data.split(separator);
        room = new Room(obj[0]);
        inventory = new Inventory(obj[1]);
    }

    public String toDatastring() {
        StringBuffer tmp = new StringBuffer(room.toDataString() + separator);
        tmp.append(inventory.toDataString());
        return tmp.toString();
    }

    public Room getRoom() {
        return room;
    }

    private Item getActionItem(String name) throws IllegalArgumentException {
        Item src = room.getItem(name);
        if (src == null)
            src = inventory.find(name);
        if (src == null)
            throw new IllegalArgumentException("'" + name + "' gibt es hier nicht!");
        return src;
    }

    public void takeItem(String name, String container) throws IllegalArgumentException {
        Item item = getActionItem(container);
        inventory.add(item.takeItem(name));
        System.out.println("'" + name + "' genommen!");
    }

    public void takeItem(String name) throws IllegalArgumentException {
        inventory.add(room.takeItem(name));
        System.out.println("'" + name + "' genommen!");
    }

    public void showInventory() {
        System.out.println("Du hast > " + inventory);

    }

    public void look() {
        System.out.println(room);
    }

    public void go(DIRECTION dir) throws IllegalArgumentException {
        room = room.getExit(dir);
        look();
    }

    public void dropItem(String name) {
        room.addItem(inventory.remove(name));
        System.out.println("'" + name + "' abgelegt!");

    }

    public void dropItem(String name, String destination) {
        Item item = getActionItem(destination);
        item.addItem(inventory.remove(name));
        System.out.println("'" + name + "' in '" + destination + "' abgelegt!");
    }

    public void open(String name, String key) throws IllegalArgumentException {
        Door door = room.findDoor(name);
        if (door != null) {
            door.useKey(key);
            System.out.println("'" + name + "' geoeffnet!");
        } else {
            Item item = getActionItem(name);
            item.checkProperty();
            item.useKey(key);
        }
    }

    public void giveItem(String item) throws IllegalArgumentException { // TODO
        room.giveItemToActor(item);
    }

    public void useItem(String name, String key) throws IllegalArgumentException {
        Item item = getActionItem(name);
        if (doTransformation(item, key))
            return;
        if (!item.isProbertyItem()) {
            item = getActionItem(key);
            key = name;
            if (doTransformation(item, key))
                return;
            throw new IllegalArgumentException("Das hat keine Wirkung!");
        }           
        item.usePropertyKey(key);
    }

    public boolean doTransformation(Item item, String key) {
        if (item.isTransformer()) {
            if (!item.checkTransformKey(key))
                throw new IllegalArgumentException("Das hat keine Wirkung!");
            String original = item.name;
            Item replacement = item.getTransform();
            if (inventory.find(original) != null) {
                inventory.add(replacement);
                inventory.remove(original);
            } else if (room.contains(item.name)) {
                room.addItem(replacement);
                room.removeItem(original);
            }
            System.out.println("Aus '" + original + "' wurde '" + replacement + "'!");
            return true;
        }
        return false;
    }

    public boolean has(String item) {
        return inventory.find(item) != null;
    }

    public boolean hasFinished() {
        return room.isFinalRoom();
    }
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
J Mein Java Programm lässt sich nicht mehr bearbeiten Java Basics - Anfänger-Themen 2
A Java die richtige Programmiersprache für mein Projekt? Java Basics - Anfänger-Themen 1
S Brauche hilfe in Java [Fehler in mein Code]? Java Basics - Anfänger-Themen 2
G Mein Java Projekt funktioniert nicht Java Basics - Anfänger-Themen 5
M Mein erstes Java Programm Java Basics - Anfänger-Themen 5
C Mein Video zu Java Grundlagen Java Basics - Anfänger-Themen 8
T mein erstes Java projekt Java Basics - Anfänger-Themen 8
T OOP Mein erstes Java-Spiel - Schiffe versenken! Java Basics - Anfänger-Themen 2
E Mein erstes Java Projekt - Sauberer code? Java Basics - Anfänger-Themen 28
H Ich kann mein Java Programm Test.class nicht ausführen Java Basics - Anfänger-Themen 6
M Kann mein Java Programm nicht starten Java Basics - Anfänger-Themen 6
S GaussJordan in Java, wo liegt mein Fehler? Java Basics - Anfänger-Themen 4
S Mein Computer kennt "javac" und "java" nicht mehr! Java Basics - Anfänger-Themen 6
JeromeM90 Mein Java Applet zeitverzögern ? Java Basics - Anfänger-Themen 2
F.S.WhiTeY Java RegEx Will nicht so wie ich will. Wo ist mein fehler ? Java Basics - Anfänger-Themen 3
ChackZz Java-Rätsel: Mein erster Versuch Java Basics - Anfänger-Themen 19
F Wie benutze ich mein java programm ohne editor? Java Basics - Anfänger-Themen 2
B Ich kann mein Java Programm net Kompilieren? Java Basics - Anfänger-Themen 8
B Java in VBA konvertieren? RETTET MEIN LEBEN Java Basics - Anfänger-Themen 14
A Warum wird mein jdk nicht gefunden? Java Basics - Anfänger-Themen 3
J Layout Manager, welcher ist der Richtige für mein Program? Java Basics - Anfänger-Themen 1
J Größter gemeinsamer Teiler: mein Code Java Basics - Anfänger-Themen 6
J Mein Programm läuft bei der ersten Eingabe nicht mehr weiter, woran liegt das? Java Basics - Anfänger-Themen 6
I Methoden Wieso wird mein Array "a" verändert und meine Variable "a" nicht? Java Basics - Anfänger-Themen 4
Alen123 Warum funktioniert mein Code nicht? Java Basics - Anfänger-Themen 64
sserio Wieso funktioniert mein Programm nicht Java Basics - Anfänger-Themen 2
sserio Wieso funktioniert mein TableView nicht /JavaFX. Java Basics - Anfänger-Themen 4
M Mein quellcode wird nicht in der Konsole ausgegeben Java Basics - Anfänger-Themen 3
J Nach dem Exportieren funktioniert mein Programm nicht mehr Java Basics - Anfänger-Themen 8
P Mein Programm wird zwar erfolgreich Compiliert, öffnet sich aber nicht Java Basics - Anfänger-Themen 6
W Wie ziehe ich von einer bestimmten Zahl, Zahlen ab, bis mein Ergebnis null beträgt? Java Basics - Anfänger-Themen 10
J Kann ich mein Programm so schreiben? Java Basics - Anfänger-Themen 4
S Mein erstes eigenes Projekt - Aufbau und Strukturierung Java Basics - Anfänger-Themen 6
T Mein Programm hat Fehler Java Basics - Anfänger-Themen 4
S Wie ende ich mein Pogrammierung? [Hilfe] Java Basics - Anfänger-Themen 1
R Mein Plugin funktioniert nicht? Java Basics - Anfänger-Themen 10
J Mein Programm beendet sich ohne mein Zutun Java Basics - Anfänger-Themen 9
A Eine Krone in der Textausgabe - Mein Code Java Basics - Anfänger-Themen 11
M Warum berechnet mein Primzahlenprog zu hohe Zahlen nicht? Java Basics - Anfänger-Themen 20
M OOP Mein erstes Textadventure... Java Basics - Anfänger-Themen 3
W Wieso funktioniert mein Switch Case nicht ?! Java Basics - Anfänger-Themen 9
L Mein Taschenrechner lässt sich plötzlich nicht mehr öffnen Java Basics - Anfänger-Themen 5
x-tshainge Mein Programm lässt sich nicht Starten Java Basics - Anfänger-Themen 8
W Warum läuft mein Programm nicht? Java Basics - Anfänger-Themen 14
W Warum funktioniert mein Programm nicht ? Java Basics - Anfänger-Themen 12
W Warum funktioniert mein Programm nicht ? Java Basics - Anfänger-Themen 6
W Ist mein Struktogram richtig erstellt worden? Java Basics - Anfänger-Themen 4
W Erste Schritte Warum funktioniert mein Programm nicht ? ~if Anweisung~ Java Basics - Anfänger-Themen 4
A Erste Schritte Mein Programm erkennt die variable EinAus.readInt nicht Java Basics - Anfänger-Themen 15
N Warum terminiert mein Programm nicht? Java Basics - Anfänger-Themen 13
G Wie kann ich mein Quellcode als Programm vom desktop starten? Java Basics - Anfänger-Themen 1
P Wie kann ich mein Programm zu einer App umwandeln? Java Basics - Anfänger-Themen 4
M Mein erstes Programm Java Basics - Anfänger-Themen 3
A Mein 1x1 Programm funktioniert nicht? Java Basics - Anfänger-Themen 2
G Input/Output Wo liegt mein Fehler? Java Basics - Anfänger-Themen 4
G Variablen Was ist mein Fehler? Java Basics - Anfänger-Themen 2
C Warum funktioniert mein If Statement nicht richtig? Java Basics - Anfänger-Themen 18
B Drucken: Default Paper von Drucker? Mein Drucker druckt falsch Java Basics - Anfänger-Themen 3
W Compiler-Fehler Fehler - <identifier> expected, wo liegt mein Fehler? Java Basics - Anfänger-Themen 4
stylegangsta Input/Output Hat eclipse eine Macke oder mein Code Array Datei einlesen Java Basics - Anfänger-Themen 5
S Wieso wird mein JFrame transparent dargestellt? Java Basics - Anfänger-Themen 5
N mein RegEx Java Basics - Anfänger-Themen 2
N Mein Bubblesort sortiert mein Array nicht Java Basics - Anfänger-Themen 2
W Wie hat mein Lehrer das gemacht. Java Basics - Anfänger-Themen 2
Z Klassen Warum wird mein Objekt nicht erkannt? Java Basics - Anfänger-Themen 2
J Erste Schritte Zweithöchster Wert eines Arrays herausfinden - warum klappt mein Code nicht? Java Basics - Anfänger-Themen 3
A Wie kann ich mein Programm noch effizienter machen? Java Basics - Anfänger-Themen 1
T Eclipse kennt mein Button nicht... Java Basics - Anfänger-Themen 5
J Wo liegt nur an dieser einfachen Bedingung mein Fehler? Java Basics - Anfänger-Themen 8
E Mein eigener Listener (Hilfe gesucht) Java Basics - Anfänger-Themen 2
D Brauche Hilfe für mein übungsprogramm Java Basics - Anfänger-Themen 16
T Mein String in ein JLabel stecken Java Basics - Anfänger-Themen 2
H Kann ich mein Programm vereinfachen? Java Basics - Anfänger-Themen 3
J Methoden Wo ist mein Fehler ?! Java Basics - Anfänger-Themen 9
1 Mein erstes Programm, HELP!! Java Basics - Anfänger-Themen 2
R .txt in mein Javaprogramm hineinschmelzen Java Basics - Anfänger-Themen 6
S Mein Code is unübersichtlich - besseren Stil Java Basics - Anfänger-Themen 6
D Mein erstes Programm flackert Java Basics - Anfänger-Themen 5
H Probleme mein Ausführen der .class (Ubuntu JDK6) Java Basics - Anfänger-Themen 2
M Mein TableEvent problem Java Basics - Anfänger-Themen 3
C Boolsche Ausdrücke - Wo ist mein Fehler? Java Basics - Anfänger-Themen 14
propra Wie mache ich einem JPanel mein bereits instanziertes Model bekannt Java Basics - Anfänger-Themen 9
M Warum wird mein Icon bei den JTree Nodes nicht angezeigt? Java Basics - Anfänger-Themen 7
K Mein Programm... Heute: Settings-Datei in .jar speichern und auslesen Java Basics - Anfänger-Themen 9
V Mein erster Konstruktor Java Basics - Anfänger-Themen 3
B Methoden Mein erstes Programm - und gleich Probleme Java Basics - Anfänger-Themen 6
O Warum terminiert mein Programm nicht!? Java Basics - Anfänger-Themen 15
U2nt Mein Chat Java Basics - Anfänger-Themen 10
S Wo ist mein Fehler? Java Basics - Anfänger-Themen 2
M Sammlung von Anfängerfragen für mein erstes Programm Java Basics - Anfänger-Themen 15
I OOP This-Referenzs > wo liegt mein Denkfehler? Java Basics - Anfänger-Themen 24
L Hashtable nicht wirklich geeignet für mein Vorhaben? Java Basics - Anfänger-Themen 3
W ArrayListe , Wo ist mein Fehler? Java Basics - Anfänger-Themen 6
H wie bekomm ich ein Foto in mein Programm rein? Java Basics - Anfänger-Themen 8
M Mein Externes Programm startet nicht Java Basics - Anfänger-Themen 13
M Timer unterbrechen? Wo ist mein Thread? Java Basics - Anfänger-Themen 2
S wieso ist mein Code falsch? Java Basics - Anfänger-Themen 2
B XML? Für Uhrzeit und Datum für mein HP? Java Basics - Anfänger-Themen 6
Developer_X Mein erster Internet Explorer Java Basics - Anfänger-Themen 14
B könnte nochmal jemand über mein Projekt schauen? Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben