Main startet nicht bei vorgegebenen Code

Tasmani

Mitglied
Hey, ich soll ein TextAdventure programmieren bei vorgegebenen Interfaces und Abstrakten Klassen. Unabhängig vom vorgegeben Code habe ich selbst schon einmal einen Ansatz selbst erstellt den ich nun an den vorgegebenen Code anpassen will.

Jetzt wollte ich zum testen halt einfach mal die Main ausführen. Das funktioniert aber leider nicht. Die Fehlermeldung liegt im Anhang:
Allgemein haben wir ein src ordner gegeben im Zusammenhang mit gradle. Um den Code auszuführen brauch ich aber doch gar kein gradle oder doch? gradle dient doch lediglich dazu, zu schauen ob der Code am Ende bestimmte Ziele erfüllt (so wie ich es verstanden habe nennt man das ,,testen"). Wo liegt denn der Fehler? Im src Ordner befindet sich ein student Ordner mit der Main wo wir unseren Code implementieren sollen und ein ias Ordner, welcher die Interfaces und abstrakten Klassen beinhaltet.

Wir dürfen den Code im ias Ordner nicht ändern, sondern sollen ihn implementieren bei unseren Code!!
 

Anhänge

  • fehlermeldung.png
    fehlermeldung.png
    26,9 KB · Aufrufe: 12
K

kneitzel

Gast
Gradle dient nicht nur dem testen. Gradle ist ein Build Tool. Somit dient es auch dem bauen des Projektes. Und je nach build.gradle file kann es extrem viel machen, z.B. jar files bauen oder so.

gradlew tasks
Das gibt die die Liste der Tasks, die dein Gradle-Projekt kennt.

gradlew build
Das wäre das eigentliche Bauen des Projekts
Die classes finden sich dann in der Regel in build/classes/java/main

gradlew jar
Das sollte ein jar File zur Verfügung stellen.
Das jar findet sich dann in der Regel in build/libs/

Du kannst dann das Projekt ausführen mit:
java -cp build\classes\java\main my.package.MainClass
java -cp build\libs\my-cool-jar-file-1.0-snapshot.jar my.package.MainClass

Die Befehle sind natürlich alle im Projektverzeichnis, also da, wo auch die gradlew.bat und so liegt, auszuführen.
 

Tasmani

Mitglied
Ich habe mit git clone den master Ordner heruntergeladen, welcher als gradle Build vorliegt. Wenn ich nun bei eclipse ein Projekt importieren will, wähl ich ja in diesem Fall gradle aus, aber welches Verzeichnis muss ich auswählen? Den kompletten Master Ordner, welcher alle datein enthält ?
 

Tasmani

Mitglied
So sieht es jetzt bei mir aus. Mein Ziel ist es erst einmal den Code zum laufen zu kriegen um ihn dann zu bearbeiten ....
 

Anhänge

  • gradle.png
    gradle.png
    144,9 KB · Aufrufe: 28

Tasmani

Mitglied
hmm die catch Anweisung wird ja nur ausgeführt, wenn die try Anweisung ein Fehler hat. Aber wenn du sagst schau dir Zeile 18 an und da ist etwas falsch, dann müsste er doc automatisch die catch Anweisung ausführen und das Problem sollte gar nicht in Zeile 18 liegen ...^^

Um mein eigenes Adventure auszuführen, sollte es ja glaube ich einfach reichen in das Array erst einmal

Adventures.getmyGame() hinzufügen.

Wo ist denn der Fehler genau in Zeile 18 ?
 

mrBrown

Super-Moderator
Mitarbeiter
hmm die catch Anweisung wird ja nur ausgeführt, wenn die try Anweisung ein Fehler hat. Aber wenn du sagst schau dir Zeile 18 an und da ist etwas falsch, dann müsste er doc automatisch die catch Anweisung ausführen und das Problem sollte gar nicht in Zeile 18 liegen ...^^
Häh?

Das try-catch in der main fängt nur TextAdventureException, nicht die NullPointerException.

Und auch wenn die Exception gefangen wird, ändert sich nicht der Ort des Fehlers.

Wo ist denn der Fehler genau in Zeile 18 ?
Unten steht doch was in Knallrot: in der zweiten Zeile dort ist angegeben, dass der Fehler in Adventures.java in Zeile 18 fliegt.
 

Tasmani

Mitglied
Wir dürfen aber die Adventures.java weder ändern noch irgendwohin kopieren , sondern lediglich einbinden bzw. miteinbeziehen. Die Interfaces und Klassen im ias Ordner sind vorgegeben. So habe ich das gelesen. Ich möchte den Code lediglich zum laufen kriegen ..

Lg
 

Anhänge

  • zeile 18.png
    zeile 18.png
    177,6 KB · Aufrufe: 15
K

kneitzel

Gast
Ich hoffe dir ist bewusst, dass wir nur die paar Bildschirmfotos kennen .... wir kennen weder die Aufgabe noch den Code, der dir vorliegt.

NPE ist ein Zeichen dafür, dass etwas nicht initialisiert wurde. Also schau dir an, wo die NPE geschmissen wird und dann überlegt, was du ändern kannst.
 

Tasmani

Mitglied
Kurze Zusamenfassung: Wir sollen mithilfe vorgegeber Interfaces und Klassen ein Textadventure programmieren. Das Programmieren an sich mit einem vollkommen neuerzeugten Quellcode aus, da hab ich keine großen Probleme mit (so pi mal daumen ausgedrückt), aber das vorgegebene miteinzubeziehen und daraus etwas zu entwerfen, da hab ich Probleme mit, weil ich gerne es schaffen würde, dass das Programm einfach nur startet.

In der Aufgabenstellung steht:

,,
Das Interface TextAdventure bietet verschiedene Methoden, um ein neues Spiel
zu erzeugen. Uberlegen Sie sich fur jede Methode, in welchen Fällen ihre Ausführung
fehlschlagen kann.Werfen Sie in diesen Fällen eine TextAdventureException."

Kurz zu den Interfacemethoden:

Composition: Aus Zwei Items wird eins zb Wasser und Kohlensäure -> Sprudel
Decomposition: Analog wird dazu ein Item in seine zwei Bestandteile zerlegt
Transformation: z.b. habe ich einen leeren Eimer und füll ihn mit Wasser
Items: Items die ins Inventar aufgenommen werden können
SceneryType: Items die nicht ins Inventar aufgenommen werden können

Wann die Ausführung fehltschlägt sollte klar sein, z.b. wenn zwei Items nicht zu einaderpassen. Wir sollen das anschinend als Try Catch Methode realisieren. d.h. sowas in der Art wie

Try {

wenn ich Sprudel erstellen will brauche ich Wasser und Kohlensäure }

catch {

wird ausgeführt wenn mir eines der Items fehlt }

aber bevor ich das eiegntlich machen kann muss ich doch das Programm zum laufen kriegen z.b. einfach nur eine Ausgabe mit Spiel gestartet. Und da ist mein großes Problem vorhanden .. Es will irgendwie nicht starten.
 

mihe7

Top Contributor
Und da ist mein großes Problem vorhanden .. Es will irgendwie nicht starten.
Dein großes Problem ist, dass Du anscheinend weder Java noch den Leuten hier glauben willst :) Was Du implementieren sollst etc. spielt erstmal keine Rolle.

Wenn Dein Programm startet, gibt es eine NullPointerException und Java sagt Dir sogar genau, an welcher Stelle. Also schaust Du mal nach, was an dieser Stelle steht. In Adventures.java, Zeile 18, steht etwas wie:
Java:
textAdventure.addSceneryType("...", "...");
Das einzige, was dort null sein kann, ist textAdventure. Also, schaust Du nach, wie die Variable initialisiert wird, das findest Du eine Zeile darüber:
Java:
ias.TextAdventure textAdventure = Factory.getGame("Sample1", 2, 2);
Offensichtlich liefert also Factory.getGame("Sample1", 2, 2) einfach null. Warum? Wissen wir nicht, musst Du nachschauen (Strg+Klick auf getGame dürfte Dich zur betreffenden Methode leiten, wenn nicht, muss Du Factory.java halt selbst nach der Methode durchsuchen).

Glaskugel: "Sample1" ist der Name einer Resource, die nicht vorhanden ist. Kann aber natürlich auch was anderes sein.
 
Zuletzt bearbeitet von einem Moderator:

mrBrown

Super-Moderator
Mitarbeiter
Glaskugel: "Sample1" ist der Name einer Resource, die nicht vorhanden ist. Kann aber natürlich auch was anderes sein.

Ich würde drauf tippen, dass es von TextAdventure einfach noch keine Implementation gibt, und Factory deshalb mit Absicht null zurück gibt – liegt ja auch extra im Student-Package, wo die Dinge liegen, die angefasst werden müssen.
 

Tasmani

Mitglied
Also TextAdventure ist ja als Interface vorhanden.

public interface TextAdventure {

..

Um das zu implementieren müsste man ja die Main dann so abändern:

public class Main implements TextAdventure {

...

Allgemein werde von Interfaces keine Objekte erstellt oder? Man soll ja lediglich die Methoden ,,speziell implementieren".
Also es würde wenig Sinn ergeben

TextAdventure RPG = new TextAdventure();

zu konstuieren..
 

mrBrown

Super-Moderator
Mitarbeiter
Um das zu implementieren müsste man ja die Main dann so abändern:

public class Main implements TextAdventure {
Nein, die Main muss man nicht verändern.

Allgemein werde von Interfaces keine Objekte erstellt oder? Man soll ja lediglich die Methoden ,,speziell implementieren".
Also es würde wenig Sinn ergeben

TextAdventure RPG = new TextAdventure();

zu konstuieren..
Ich versteh nicht wirklich was du damit sagen will – also je, von Interfaces kann man nicht direkt Objekte erstellen, aber man kann das Interface natürlich implementieren und dann von der Klasse Instanzen erstellen.

Und genau das ist deine Aufgabe: das Interface TextAdventure implementieren (und diese Implementation dann wahrscheinlich in Factory nutzen).
 

Tasmani

Mitglied
Ich habe den factory Code mal im Anhang hochgeladen. Ich würde jetzt dort das Interface TextAdventure implementieren also mithilfe implements TextAdventure. Dann würde ich die Methoden aus TextAdventure im factoryCode aufrufen und anwenden. Also sowas wie Spielfeld größe etc
Danach würde ich eine Instanz von der Klasse factory in der main erstellen, also

new RPG = new factory();

Kann man das so machen ?
 

Anhänge

  • factory.png
    factory.png
    159,6 KB · Aufrufe: 12
K

kneitzel

Gast
Aber da sieht man doch direkt den Kommentar Placeholder mit dem return null;

Das sieht ja fast so aus, als ob man da etwas Code schreiben müsste ... Und eine NPE ist auch logisch, wenn bei der Factory nur null zurück kommt...
 

Tasmani

Mitglied
Vermutlich soll ich die Klasse TextAdventureException anwenden in der factory? Diese Exceptions machen es ja einem echt schwer :/ Wenn ich dieses exception problem lösen könnte wäre das schon genug.

Code:
package ias;

/**
* General Exception-type of the text adventure framework.
*/
public class TextAdventureException extends Exception {

    /**
     * Exception Prefix.
     */
    public static final String ERROR = "Error! ";

    /**
     * Creates a new TextAdventureException with the given message.
     * @param message The error-message
     */
    public TextAdventureException(String message) {
        super(ERROR + message);
    }
}
 

Tasmani

Mitglied
Die NullpointerException bedeutet doch das auf ein Objekt zugegriffen wird welches noch gar nicht instanziert wurden ist oder? In diesem Fall

Exception in thread "main" java.lang.NullPointerException
at ias.Adventures.getFiremanGame(Adventures.java:18)
at student.Main.main(Main.java:22)

wobei auf folgende Zeile verwiesen wird:

textAdventure.addSceneryType("BurningTree", "A blazing fire on an oak tree.");

In dieser Zeile wird die methode addSceneryType() auf das Objekt textAdventure angewendet. Dann vermute ich mal das textAdventure erst als Objekt vorliegen muss, also es wurde noch gar nicht erzeugt. Wenn das richtig ist, aus welche Klasse erzeuge ich dann textAdventure?

Ich denke mal nicht aus dem Interface TextAdventure.java, da dies ja lediglich nur ein Interface ist, welches noch implementiert werden muss in einer Klasse, um dann von dieser Klasse eine Instanz zu erzeugen.

Vielleicht muss ich auch selbst eine Klasse textAdventure schreiben in der ich das Interface TextAdventure.java implementiere. Das ist echt alles blöd ...

In der Aufgabenstellung steht:

Das Interface TextAdventure, dessen Methoden Sie implementieren mussen, ermoglicht
es ein Text-Adventure-Game anzulegen. Im Paket student finden Sie eine Klasse
Main, die das Interface TextAdventure nutzt, um verschiedene Spiele zu initialisieren.
Diese konnen Sie nach erfolgreicher Implementierung der Interfaces
durchspielen. Die Spielszenarien sollen Ihnen beim ausgiebigen Testen Ihres Codes
helfen. Fur die Interaktion mit dem Spiel stehen Ihnen alle Methoden des
Interface Player zur Verfugung. Schauen Sie sich hierzu auch die Klasse Game-
Starter an. In dieser ist die Interaktion mit dem Spieler implementiert. Unsere
automatisierten Tests benutzen ebenfalls das Interface TextAdventure um Test-
Spielszenarios zu erstellen.
Das Interface TextAdventure bietet verschiedene Methoden, um ein neues Spiel
zu erzeugen. Uberlegen Sie sich fur jede Methode, in welchen Fallen ihre Ausfuhrung
fehlschlagen kann.
Werfen Sie in diesen Fallen eine TextAdventureException.
Diese wird Ihnen ebenfalls im Paket ias zur Verfugung gestellt. Sobald der
gewunschte Ausgangszustand hergestellt ist, kann mit startGame ein Spiel gestartet
werden.

Das schwarzgedruckte ist klar, das kann man für jede methode mit einer try catch Befehl lösen. Aber dieses Nullpointerproblem bekomm ich einfach nicht hin.
 

Tasmani

Mitglied
okay, ich denke ich hab es jetzt verstanden. Es läuft glaube ich auf sowas hinaus

public class Spiel implements TextAdventure {

hier die methoden von TextAdventure implementieren; }

Am Ende ein Objekt hier von erzeugen
Spiel textAdventure = new Spiel();

Wieso der Name textAdventure? Weil in der vorgegebenen Klasse
adventures.java methoden auf das Objekt textAdventure angewendet werden.
Ziel ist es erst einmal das Objekt textAdventure somit zu erzeugen.

Die ähnlichen Namen textAdventure=Objekt das ich erzeugen muss aus einer von mir geschriebenen Klasse und TextAdventure=interface welches vorgegeben ist, die ich in der von mir geschriebenen Klasse implementiere (die methoden also innerhalb TextAdventure), sollen uns Studenten nur verwirren. Vermute ich mal.
 

Anhänge

  • adventures.png
    adventures.png
    179,1 KB · Aufrufe: 9
K

kneitzel

Gast
Also wir haben nur einen begrenzen Einblick, aber der Hinweis bezüglich Factory Klasse ist ja schon gekommen.... auch der dezente Hinweis, dass da ja ein Student Ordner ist ....

Und dein Ausschnitt hat gezeigt, dass da etwas gefüllt werden soll ....

Was hindert dich daran, da los zu legen?
 

mrBrown

Super-Moderator
Mitarbeiter
okay, ich denke ich hab es jetzt verstanden. Es läuft glaube ich auf sowas hinaus

public class Spiel implements TextAdventure {

hier die methoden von TextAdventure implementieren; }
Zumindest der Teil ist noch völlig korrekt.

Am Ende ein Objekt hier von erzeugen
Spiel textAdventure = new Spiel();

Wieso der Name textAdventure? Weil in der vorgegebenen Klasse
adventures.java methoden auf das Objekt textAdventure angewendet werden.
Ziel ist es erst einmal das Objekt textAdventure somit zu erzeugen.

Die ähnlichen Namen textAdventures=Objekt das ich erzeugen muss aus einer von mir geschriebenen Klasse und TextAdventure=interface welches vorgegeben ist sollen uns tudenten nur verwirren. Vermute ich mal.
Aber hier wird's dann völlig merkwürdig...

Der Code in dem Screenshot steht in einer Klasse, die du nicht anfassen sollst – der Name einer dort deklarieren lokalen Variable ist völlig irrelevant für alles außerhalb der jeweiligen Methode.

Außer der Implementierung von TextAdventure muss muss auch in Factory was angepasst werden – an der Stelle, wo extra Placeholder steht.
 

temi

Top Contributor
Um mal ein Beispiel zu machen:
Java:
// ein gegebenes Interface
interface Foo {
    void doSomething();
}

// eine gegebene Hauptklasse - soll nicht geändert werden!
class Main {
   
    public static void main(String[] args) {
        Foo foo = Factory.getFoo();
        foo.doSomething();
        // mehr code..
    }
}

// Factory-Klasse, die ein Foo erzeugen soll
class Factory {
    public static Foo getFoo() {
        return new MyFoo();
    }
}

// Klasse, die Foo implementiert
class MyFoo implements Foo {
   
    public void doSomething() {
        // code..
    }
}

In der Factory-Klasse wird festgelegt, welches konkrete Foo in der Main später verwendet wird. Solltest du also später einmal eine neue Klasse class MyNewSuperFoo implements Foo erstellen, dann kannst du die einfach in der Factory austauschen, die Main-Klasse wird davon nichts bemerken.
 
Zuletzt bearbeitet:

Tasmani

Mitglied
Hey, ich bekomme das einfach nicht hin. Das Progamm will einfach nicht starten. Ich habe jetzt mehrere Stunden probiert und überlegt. Andauenrd dieselbe fehlermeldung. Ich möchte zunächst lediglich erreichen dass das Programm startet.
 

Tasmani

Mitglied
Den Studet Ordner darf ich ändern

Code:
package student;

/**
 * Factory class with functions to generate a game and terminal.
 */
public final class Factory   {
    
    private Factory() { }
        
    /**
     * Creates a new game-instance with an empty board of the given size.
     * @param name The name of the game
     * @param boardWidth the width of the board
     * @param boardHeight the height of the board
     * @return a fresh game instance
     * @throws ias.TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    public static ias.TextAdventure getGame(String name, int boardWidth, int boardHeight)
            throws ias.TextAdventureException {
        //placeholder
        return null;
    }

    /**
     * Creates a new terminal-instance to read user input and prompt messages.
     * @return a terminal instance
     */
    public static ias.Terminal getTerminal() {
        //placeholder
        return null;
    }
}

Code:
package student;

import ias.Adventures;
import ias.TextAdventureException;
import ias.GameStarter;
import ias.TextAdventure;

/**
 * Main class, serves as an entry point to the program.
 */
public class Main  {

    /**
     * Main method which serves as an entry to the program.
     * @param args terminal parameters
     */
    public static void main(String[] args) {
        try {
            
            // Add additional games to the Array
            TextAdventure[] games = {
                    Adventures.getFiremanGame(), Adventures.getLumberjackGame(), Adventures.getPokemonGame()
            };
            GameStarter starter = new GameStarter(games);
            starter.startGame();
        } catch (TextAdventureException e) {
            e.printStackTrace();
        }

    }
}
 

Tasmani

Mitglied
Den IAS Ordner darf ich nicht ändern.

Code:
package ias;

import student.Factory;

/**
 * Class with text adventure scenarios to play.
 */
public class Adventures {

    /**
     * Initialize the fireman-game.
     *
     * @return the fireman-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getFiremanGame() throws TextAdventureException {
        ias.TextAdventure textAdventure = Factory.getGame("Sample1", 2, 2);
        textAdventure.addSceneryType("BurningTree", "A blazing fire on an oak tree.");
        textAdventure.addSceneryType("HalfBurningTree", "A little fire on an oak tree.");
        textAdventure.addItemType("Bucket", "An empty bucket.");
        textAdventure.addItemType("Water", "A bucket full of water.");
        textAdventure.addItemType("Head", "Kopf");
        textAdventure.addItemType("Headweh", "Jetzt brummt de kopf");
        textAdventure.addSceneryType("Lake", "A beautiful lake.");
        textAdventure.addSceneryType("CharredOak", "A poor, charred oak tree.");
        textAdventure.addTransformation("Bucket", "Lake", "Water", "Lake",
                "Now you got a bucket full of water.");
        textAdventure.addTransformation("Water", "BurningTree", "HalfBurningTree", "Bucket",
                "The water quenches the fire. But not completely.");
        textAdventure.addTransformation("Water", "HalfBurningTree", "CharredOak", "Bucket",
                "The water quenches the fire.");
        textAdventure.addComposition("Bucket", "Head", "Headweh", "Kopfwehh");
        textAdventure.placeItem("Lake", 0, 0);
        textAdventure.placeItem("Bucket", 1, 1);
        textAdventure.placeItem("Head", 1, 1);
        textAdventure.placeItem("BurningTree", 0, 0);
        return textAdventure;
    }

    /**
     * Initialize the lumberjack-game.
     *
     * @return The lumberjack-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getLumberjackGame() throws TextAdventureException {
        ias.TextAdventure textAdventure = Factory.getGame("Sample2", 1, 1);
        textAdventure.addSceneryType("Tree", "A lush green tree.");
        textAdventure.addItemType("Wood", "Some pieces of wood");
        textAdventure.addSceneryType("Roots", "The sad roots of a former tree.");
        textAdventure.addDecomposition("Tree", "Wood", "Roots", "You fell the tree and get some wood.");
        textAdventure.placeItem("Tree", 0, 0);
        return textAdventure;
    }


    /**
     * Initialize the pokemon-game.
     *
     * @return the pokemon-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getPokemonGame() throws TextAdventureException {
        TextAdventure textAdventure = Factory.getGame("Pokemon", 50, 50);

        textAdventure.addItemType("Coin", "One coin");
        textAdventure.addItemType("Money", "Many coins");
        textAdventure.addItemType("Bisasam", "Look, a wild Bisasam.");
        textAdventure.addItemType("Glumanda", "Look, a wild Glumanda.");
        textAdventure.addItemType("Schiggy", "Look, a wild Schiggy.");
        textAdventure.addItemType("Bisaknosp", "Bisaknosp eats plants.");
        textAdventure.addItemType("Glutexo", "Glutexo burns.");
        textAdventure.addItemType("Schillok", "Schillok swimming around.");
        textAdventure.addItemType("Bisaflor", "Bisaflor eats plants.");
        textAdventure.addItemType("Glurak", "Glurak burns.");
        textAdventure.addItemType("Turtok", "Turtok swimming around.");
        textAdventure.addItemType("Taubsi", "Taubsi flying around.");
        textAdventure.addItemType("Tauboga", "Tauboga flying around.");
        textAdventure.addItemType("Tauboss", "Tauboss flying around.");
        textAdventure.addItemType("Mewtu", "Mewtu sees dead people.");
        textAdventure.addItemType("Developmentstone",
                "The Developmentstone brings your Pokemon to the next Level.");
        textAdventure.addItemType("Attackstone",
                "The Attackstone is in combination with your Pokemon to attack other Pokemons.");
        textAdventure.addItemType("Pokeball",
                "Pokeball is there to catch other Pokemons.");
        textAdventure.addSceneryType("Wildtaubsi", "Look, a wild Taubsi.");
        textAdventure.addSceneryType("Deadtaubsi", "Look, a dead Taubsi.");
        textAdventure.addSceneryType("Silvertreasure", "Look, a Treasure.");
        textAdventure.addSceneryType("Goldtreasure", "Look, a Treasure.");
        textAdventure.placeItem("Coin", 0, 0);
        textAdventure.placeItem("Bisasam", 0, 0);
        textAdventure.placeItem("Glumanda", 0, 0);
        textAdventure.placeItem("Schiggy", 0, 0);
        textAdventure.placeItem("Developmentstone", 2, 4);
        textAdventure.placeItem("Developmentstone", 25, 31);
        textAdventure.placeItem("Developmentstone", 49, 11);
        textAdventure.placeItem("Developmentstone", 22, 22);
        textAdventure.placeItem("Developmentstone", 11, 44);
        textAdventure.placeItem("Developmentstone", 23, 43);
        textAdventure.placeItem("Developmentstone", 39, 1);
        textAdventure.placeItem("Developmentstone", 22, 21);
        textAdventure.placeItem("Developmentstone", 45, 30);
        textAdventure.placeItem("Developmentstone", 10, 12);
        textAdventure.placeItem("Developmentstone", 23, 1);
        textAdventure.placeItem("Developmentstone", 49, 49);
        textAdventure.placeItem("Developmentstone", 17, 15);
        textAdventure.placeItem("Attackstone", 1, 1);
        textAdventure.placeItem("Attackstone", 10, 10);
        textAdventure.placeItem("Attackstone", 20, 20);
        textAdventure.placeItem("Attackstone", 30, 30);
        textAdventure.placeItem("Attackstone", 4, 5);
        textAdventure.placeItem("Attackstone", 10, 2);
        textAdventure.placeItem("Attackstone", 23, 44);
        textAdventure.placeItem("Attackstone", 30, 35);
        textAdventure.placeItem("Pokeball", 1, 1);
        textAdventure.placeItem("Pokeball", 3, 22);
        textAdventure.placeItem("Pokeball", 17, 21);
        textAdventure.placeItem("Pokeball", 33, 13);
        textAdventure.placeItem("Pokeball", 45, 22);
        textAdventure.placeItem("Pokeball", 21, 13);
        textAdventure.placeItem("Pokeball", 19, 41);
        textAdventure.placeItem("Pokeball", 12, 32);
        textAdventure.placeItem("Wildtaubsi", 2, 2);
        textAdventure.placeItem("Wildtaubsi", 23, 24);
        textAdventure.placeItem("Wildtaubsi", 11, 7);
        textAdventure.placeItem("Wildtaubsi", 3, 9);
        textAdventure.placeItem("Wildtaubsi", 32, 45);
        textAdventure.placeItem("Wildtaubsi", 31, 29);
        textAdventure.placeItem("Wildtaubsi", 17, 31);
        textAdventure.placeItem("Wildtaubsi", 45, 45);
        textAdventure.placeItem("Wildtaubsi", 18, 32);
        textAdventure.placeItem("Wildtaubsi", 26, 42);
        textAdventure.placeItem("Wildtaubsi", 42, 26);
        textAdventure.placeItem("Wildtaubsi", 17, 49);
        textAdventure.placeItem("Wildtaubsi", 11, 22);
        textAdventure.placeItem("Wildtaubsi", 36, 39);
        textAdventure.placeItem("Wildtaubsi", 31, 24);
        textAdventure.placeItem("Silvertreasure", 2, 3);
        textAdventure.placeItem("Silvertreasure", 32, 33);
        textAdventure.placeItem("Silvertreasure", 14, 13);
        textAdventure.placeItem("Silvertreasure", 47, 11);
        textAdventure.placeItem("Silvertreasure", 12, 34);
        textAdventure.placeItem("Silvertreasure", 21, 33);
        textAdventure.placeItem("Silvertreasure", 43, 21);
        textAdventure.placeItem("Silvertreasure", 49, 3);
        textAdventure.placeItem("Silvertreasure", 12, 49);
        textAdventure.placeItem("Silvertreasure", 41, 34);
        textAdventure.placeItem("Silvertreasure", 12, 33);
        textAdventure.placeItem("Silvertreasure", 22, 34);
        textAdventure.placeItem("Silvertreasure", 1, 40);
        textAdventure.placeItem("Silvertreasure", 19, 28);
        textAdventure.placeItem("Silvertreasure", 45, 32);
        textAdventure.placeItem("Silvertreasure", 21, 23);
        textAdventure.placeItem("Goldtreasure", 33, 34);
        textAdventure.addComposition("Coin", "Coin", "Money", "You made money");
        textAdventure.addComposition("Bisasam", "Developmentstone", "Bisaknosp",
                "Look your Bisasam has developed to Bisaknosp.");
        textAdventure.addComposition("Glumanda", "Developmentstone", "Glutexo",
                "Look your Glumanda has developed to Glutexo.");
        textAdventure.addComposition("Schiggy", "Developmentstone", "Schillok",
                "Look your Schiggy has developed to Schillok.");
        textAdventure.addComposition("Taubsi", "Developmentstone", "Tauboga",
                "Look your Taubsi has developed to Tauboga");
        textAdventure.addComposition("Bisaknosp", "Developmentstone", "Bisaflor",
                "Look your Bisaknosp has developed to Bisaflor");
        textAdventure.addComposition("Glutexo", "Developmentstone", "Glurak",
                "Look your Glutexo has developed to Glurak");
        textAdventure.addComposition("Schillok", "Developmentstone", "Turtok",
                "Look your Schillok has developed to Turtok");
        textAdventure.addComposition("Tauboga", "Developmentstone", "Tauboss",
                "Look your Tauboga has developed to Tauboss");
        textAdventure.addComposition("Wildtaubsi", "Attackstone", "Deadtaubsi",
                "Your Pokemon attacks the wild Taubsi. Taubsi is dead.");
        textAdventure.addComposition("Wildtaubsi", "Pokeball", "Taubsi",
                "You have catch Taubsi. Congratulations, Taubsi is your new Pokemon.");
        textAdventure.addDecomposition("Silvertreasure", "Developmentstone",
                "Attackstone",
                "You open the treasure and you find an Attack- and Developmentstone.");
        textAdventure.addDecomposition("Goldtreasure", "Pokeball", "Mewtu",
                "See, you find the unique Mewtu.");
        textAdventure.addTransformation("Taubsi", "Attackstone", "Taubsi",
                "Developmentstone",
                "Look, your Taubsi transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Tauboga", "Attackstone", "Tauboga",
                "Developmentstone",
                "Look, your Tauboga transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Tauboss", "Attackstone", "Tauboss",
                "Developmentstone",
                "Look, your Tauboss transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Mewtu", "Developmentstone", "Mewtu",
                "Attackstone",
                "Look, your Mewtu transform the Developmentstone to a Attackstone.");
        textAdventure.addTransformation("Bisasam", "Attackstone", "Bisasam",
                "Pokeball",
                "Look, your Bisasam transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Bisaknosp", "Attackstone", "Bisaknosp",
                "Pokeball",
                "Look, your Bisaknosp transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Bisaflor", "Attackstone", "Bisaflor",
                "Pokeball",
                "Look, your Bisaflor transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Glumanda", "Pokeball", "Glumanda",
                "Developmentstone",
                "Look, your Glumanda transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Glutexo", "Pokeball", "Glutexo",
                "Developmentstone",
                "Look, your Glutexo transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Glurak", "Pokeball", "Glurak",
                "Developmentstone",
                "Look, your Glurak transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Schiggy", "Pokeball", "Schiggy",
                "Attackstone",
                "Look, your Schiggy transform the Pokeball to a Attackstone.");
        textAdventure.addTransformation("Schillok", "Pokeball", "Schillok",
                "Attackstone",
                "Look, your Schillok transform the Pokeball to a Attackstone.");
        textAdventure.addTransformation("Turtok", "Pokeball", "Turtok",
                "Attackstone",
                "Look, your Turtok transform the Pokeball to a Attackstone.");

        return textAdventure;
    }
}

Code:
package ias;

import student.Factory;

/**
 * Class integrates the implementation of the student package and allows to play the text adventure scenarios.
 */
public class GameStarter {

    private static final String PROMPT = "play>";
    private static Player player;
    private Terminal terminal;
    private TextAdventure[] games;

    /**
     * Constructor to create a GameStarter instance.
     * @param games array with text adventures games to play
     */
    public GameStarter(TextAdventure[] games) {
        terminal = Factory.getTerminal();
        this.games = games;
    }

    /**
     * Starts one of the given games.
     */
    public void startGame() {
        String[] input;
        String prompt = "Play (";
        for (TextAdventure game : this.games) {
            prompt += game.getName();
            prompt += "|";
        }
        prompt = prompt.substring(0, prompt.length() - 1) + ")";
        do {
            terminal.promptInput(prompt);
            input = terminal.readInput();
        } while (input[0].equals("") || input[0].equals(" "));


        String gameName = input[0];
        for (TextAdventure game : this.games) {
            if (game.getName().equals(gameName)) {
                startGame(game, 0, 0);
                return;
            }
        }
        System.out.println("Unknown game scenario");
        System.exit(1);


    }

    /**
     * Starts a given game and runs a simple input-loop that accepts game-commands.
     * @param textAdventure to play
     * @param x coordinate of the player
     * @param y coordinate of the player
     */
    public void startGame(TextAdventure textAdventure, int x, int y) {
        try {
            player = textAdventure.startGame(x, y);
        } catch (TextAdventureException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
        boolean run = true;
        while (run) {
            try {
                terminal.promptInput(PROMPT);
                String[] input = terminal.readInput();
                run = processInput(input);
            } catch (TextAdventureException e) {
                System.out.println(e.getMessage());
            }
        }
    }


    /**
     * Process the given command-line, translate it into player-actions if possible.
     * @param input the splitted user input
     * @return false if the user wants to quit, true otherwise
     * @throws TextAdventureException If an invalid command is entered
     */
    private static boolean processInput(String[] input) throws TextAdventureException {
        switch (input[0]) {
            case "go": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify a direction.");
                } else {
                    System.out.println(player.go(input[1]));
                }
                return true;
            }
            case "look": {
                String[] list = player.look();
                for (String line : list) {
                    System.out.println(line);
                }
                return true;
            }
            case "inventory": {
                String[] list = player.inventory();
                for (String line : list) {
                    System.out.println(line);
                }
                return true;
            }
            case "take": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.take(input[1]));
                }
                return true;
            }
            case "drop": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.drop(input[1]));
                }
                return true;
            }
            case "convert": {
                if (input.length < 3) {
                    System.out.println("Sorry, please specify the objects to compose.");
                } else {
                    System.out.println(player.convert(input[1], input[2]));
                }
                return true;
            }
            case "decompose": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.decompose(input[1]));
                }
                return true;
            }
            case "help": {
                System.out.println("Valid Commands are: go, look, inventory, take, drop, compose, decompose");
                return true;
            }
            case "exit": {
                System.out.println("Bye!");
                return false;
            }
            default: {
                throw new TextAdventureException("Unknown Command: " + input[0]);
            }
        }
    }
}

Code:
package ias;

/**
 * Models the interface of a text adventure player.
 */
public interface Player {

    /**
     * Move the player's token into direction.
     * @param direction One of eight valid directions "N", "NE", "E", "SE", "S", "SW", "W", "NW"
     * @return A ui-message for the user
     */
    String go(String direction);

    /**
     * Returns an array of objects on the current field.
     * @return An array of object-type and descriptions for the ui
     */
    String[] look();
    
    /**
     * Returns an array of objects in the inventory.
     * @return An array of object-type and descriptions for the ui
     */
    String[] inventory();

    /**
     * Removes an object of the given type from the current field and adds it to the inventory.
     * @param item An object-type
     * @return A ui-message for the user
     */
    String take(String item);
    
    /**
     * Removes an object of the given type from the inventory and adds it to the current field.
     * @param item An object-type
     * @return A ui-message for the user
     */
    String drop(String item);

    /**
     * Applies a transformation- or composition-rule to item1 and item2.
     * If possible, removes item1 and item2 from the current field or inventory
     * and adds the mutation-result to the current field or inventory,
     * depending on the object's base-type (scenery or item).
     * @param item1 An Object-Type
     * @param item2 An Object-Type
     * @return A ui-message for the user
     */
    String convert(String item1, String item2);
    
    /**
     * Applies a decomposition-rule to item.
     * If possible, removes item from the current field or inventory
     * and adds the mutation-result to the current field or inventory,
     * depending on the object's base-type (scenery or item).
     * @param item An Object-Type
     * @return A ui-message for the user
     */
    String decompose(String item);
}

Code:
package ias;

/**
 * Models the interface of terminal to interact with a player.
 */
public interface Terminal {

    /**
     * Prompts the user to enter a string as input. The string is printed to the standard output (terminal).
     *
     * @param input the message to display the player
     */
    public void promptInput(String input);

    /**
     * Reads the user input and returns splitted at spaces as string array.
     * @return splitted user input string
     */
    public String[] readInput();

}

Code:
package ias;

/**
 * Models the interface of a text adventure game-instance.
 */
public interface TextAdventure {

    /**
     * Declares a new portable object-type with given id and description.
     * @param id The id object-type, used in the ui to search for objects
     * @param description The description of the object-type
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addItemType(String id, String description) throws TextAdventureException;
    
    /**
     * Declares a new non-portable object-type with given id and description.
     * @param id The id object-type, used in the ui to search for objects
     * @param description The description of the object-type
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addSceneryType(String id, String description) throws TextAdventureException;

    /**
     * Adds a new object of the given type to the field at the specified position.
     * @param type The id of an object-type
     * @param x A field coordinate on the board
     * @param y A field coordinate on the board
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void placeItem(String type, int x, int y) throws TextAdventureException;

    /**
     * Adds a new composition-rule to the set of mutation-rules.
     * @param in1 Object-type id of the input-object
     * @param in2 Object-type id of the input-object
     * @param out Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addComposition(String in1, String in2, String out, String description) throws TextAdventureException;
    
    /**
     * Adds a new decomposition-rule to the set of mutation-rules.
     * @param in Object-type id of the input-object
     * @param out1 Object-type id of the output-object
     * @param out2 Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addDecomposition(String in, String out1, String out2, String description) throws TextAdventureException;
    
    /**
     * Adds a new transformation-rule to the set of mutation-rules.
     * @param in1 in1 Object-type id of the input-object
     * @param in2 in1 Object-type id of the input-object
     * @param out1 Object-type id of the output-object
     * @param out2 Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addTransformation(String in1, String in2, String out1, String out2, String description)
            throws TextAdventureException;

    /**
     * Initializes a new game instance and returns a player-instance for game-control.
     * The player's initial position is at the given coordinates
     * @param x A field coordinate on the board
     * @param y A field coordinate on the board
     * @return A player-instance for game-control
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    Player startGame(int x, int y) throws TextAdventureException;

    /**
     * Returns the name of the game instance.
     * @return the name of the game instance
     */
    String getName();
}

Code:
package ias;

/**
 * General Exception-type of the text adventure framework.
 */
public class TextAdventureException extends Exception {

    /**
     * Exception Prefix.
     */
    public static final String ERROR = "Error! ";

    /**
     * Creates a new TextAdventureException with the given message.
     * @param message The error-message
     */
    public TextAdventureException(String message) {
        super(ERROR + message);
    }
}
 

Tasmani

Mitglied
Seit 10 Stunden am probieren und überlegen. Ich würde lediglich es schaffen, dass dass Programm sartet ohne die Implementationen der ganzen Methode.
 

temi

Top Contributor
Und was sollte die Methode zurückgeben?
Hint: Steht sogar im Javadoc ;)
Java:
    /**
     * Creates a new game-instance with an empty board of the given size.
     * @param name The name of the game
     * @param boardWidth the width of the board
     * @param boardHeight the height of the board
     * @return a fresh game instance
     * @throws ias.TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
 

Tasmani

Mitglied
Ich glaube die Gamestarter.java Klasse und Adventures.java Klasse aus dem package ias sollen in der Klasse Factory.java aus dem package student integriert werden oder?
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
U Klassen IntelliJ14.1.1 Ultimate startet eine Main-Klasse NICHT MEHR Java Basics - Anfänger-Themen 0
P Main Methode scheint Constructor aufzurufen, ohne dass es so gecoded ist Java Basics - Anfänger-Themen 2
N Throw an Main Methode übergeben Java Basics - Anfänger-Themen 7
J Die statische Main-Methode ändert Instanzvariable? Java Basics - Anfänger-Themen 10
I Jetty starten von Programm (Main) Java Basics - Anfänger-Themen 27
Denix The public type Main must be defined in its own fileJava(16777541) Java Basics - Anfänger-Themen 13
D Array in Main Methode aus anderer Klasse aufrufen Java Basics - Anfänger-Themen 3
G jButton führt Main Methode nicht richtig aus Java Basics - Anfänger-Themen 3
G Main Methode wird beim ersten Aufruf nicht richtig ausgeführt Java Basics - Anfänger-Themen 1
C60 Methoden Main-Methode erkennt meine Arrays nicht. Java Basics - Anfänger-Themen 7
F Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11 at main.main(main.java:11) Java Basics - Anfänger-Themen 2
M Exception in thread "main" java.util.NoSuchElementException Java Basics - Anfänger-Themen 2
W Verschiedene Methoden in einer Klasse in der Main aufrufen? Java Basics - Anfänger-Themen 8
S Array über ein Ausgabemethode in main ausgeben Java Basics - Anfänger-Themen 31
C Kein Zugriff auf Klassenmethoden in Main Methode Java Basics - Anfänger-Themen 23
N Wozu nutzt man in der Main Methode das args Array? Java Basics - Anfänger-Themen 10
NaZuRe Geld(Wert) von der public static void main in die public static void Blackjack Java Basics - Anfänger-Themen 2
H Warum kann man keine Parameter in die main-Methode packen? Java Basics - Anfänger-Themen 4
J In main() Datei geöffnet, von anderer Funktion beschreiben Java Basics - Anfänger-Themen 3
O Exception in thread "main" java.lang.ArithmeticException: / by zero Java Basics - Anfänger-Themen 4
KogoroMori21 Methode in der main ausgeben Java Basics - Anfänger-Themen 2
s_1895 zu viele Zeilen in der Main Methode Java Basics - Anfänger-Themen 4
C Methodenrückgabe wird in der main nicht berücksichtigt Java Basics - Anfänger-Themen 2
B Wie kann ich etwas vor der Main-Methode ausführen? Java Basics - Anfänger-Themen 21
K Übergabe des Wertes einer Variable aus main() in eine Klassenmethode Java Basics - Anfänger-Themen 8
K Übergabe von Werten (zweidimensionales Array) aus einer Methode an zweidimensionales Array in main() Java Basics - Anfänger-Themen 3
G main Methode Java Basics - Anfänger-Themen 5
G Problem bei der Ausgabe einer Main Claase Java Basics - Anfänger-Themen 7
1 main-Methode erweitern, Nachfrage nach wiedeholung Java Basics - Anfänger-Themen 2
J main methode Java Basics - Anfänger-Themen 1
B No Main Classes Found Java Basics - Anfänger-Themen 7
R Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException Java Basics - Anfänger-Themen 5
S Compiler-Fehler Exception in thread "main" java.lang.Error: Unresolved compilation problem: Java Basics - Anfänger-Themen 6
E Was kommt in ein Objekt und was in die Main Methode? Java Basics - Anfänger-Themen 8
D java main methode kann nicht kompiliert werden (Erstellen eines Objekts) Java Basics - Anfänger-Themen 6
M String außerhalb der main-Methode Java Basics - Anfänger-Themen 4
scratchy1 ArrayOutOfBoundException in main-Methode Java Basics - Anfänger-Themen 17
B File öffnen in src/main/webapp Java Basics - Anfänger-Themen 4
P Parameterübergabe, von Methode zu Methode zu main Java Basics - Anfänger-Themen 4
J Kapselung Array in Set ändern und in Main ausgeben lassen Java Basics - Anfänger-Themen 4
I Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 Java Basics - Anfänger-Themen 3
V Collections Objekte einer ArrayList in der main() ausgeben Java Basics - Anfänger-Themen 9
D Compiler-Fehler Aufrufen einer Methode von Main Java Basics - Anfänger-Themen 4
G Was als main Method Java Basics - Anfänger-Themen 6
M Methode mit Array als Parameter an Main übergeben Java Basics - Anfänger-Themen 1
W Exception in Main abfangen oder in der Methode? Java Basics - Anfänger-Themen 10
J Timer bauen, Main Methode immer wieder neu starten Java Basics - Anfänger-Themen 13
J Compiler-Fehler Java findet main Klasse nicht Java Basics - Anfänger-Themen 16
B Parameterübergabe in main Java Basics - Anfänger-Themen 1
A Variablen Main Klasse soll auf eine andere Klasse zugreifen Java Basics - Anfänger-Themen 3
I java.lang.ArrayIndexOutOfBoundsException at lösung.main Java Basics - Anfänger-Themen 3
R Exception in thread "main" java.lang.NullPointerException Java Basics - Anfänger-Themen 10
J Frage zu: public static void main (String[]args) Java Basics - Anfänger-Themen 1
J Parameter in main verwenden Java Basics - Anfänger-Themen 3
M Methodenaufruf in der Main Datei funzt nicht Java Basics - Anfänger-Themen 13
M Maven Main-Methode Interface und Klasse Java Basics - Anfänger-Themen 2
C Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 Java Basics - Anfänger-Themen 3
G Instanzvariable in main-Methode verboten? Java Basics - Anfänger-Themen 3
M Objekt starten von der main-Methode Java Basics - Anfänger-Themen 1
S Fehler: Editor does not contain a main type Java Basics - Anfänger-Themen 3
G Programm wird nicht ausgeführt: Editor does not contain a main type Java Basics - Anfänger-Themen 10
A Methode aufrufen in main-Methode Java Basics - Anfänger-Themen 5
B Linux - Error: Could not find or load main class application.Main Java Basics - Anfänger-Themen 28
C Erste Schritte (Netbeans) no main classes found Java Basics - Anfänger-Themen 5
P Methoden private int[] in main Java Basics - Anfänger-Themen 16
W JLabel in Main aus Thread verändern. Java Basics - Anfänger-Themen 4
AssELAss Klassen Java Klasse in main-methode ausführen Java Basics - Anfänger-Themen 7
R Methoden Nicht statische Methode aus Main aufrufen Java Basics - Anfänger-Themen 2
P could not find main class obwohl da Java Basics - Anfänger-Themen 17
J Methode in main-Methode aufrufen Java Basics - Anfänger-Themen 5
B OOP Wie benutze ich die Main Funktion richtig? Java Basics - Anfänger-Themen 10
M Klassen Main Methode in einer anderen Klasse aufrufen Java Basics - Anfänger-Themen 13
TheMenox Methoden Auslagerung von Code aus der "main" Methode sinnvoll? Java Basics - Anfänger-Themen 70
quecksilver if-Abfrage in main ausführen Java Basics - Anfänger-Themen 4
J Exception in thread "main" Java Basics - Anfänger-Themen 1
S Methode auf Main zugreifen Java Basics - Anfänger-Themen 5
D String aus Main in Klasse übergeben Java Basics - Anfänger-Themen 4
S Methoden main-Methode integrieren Java Basics - Anfänger-Themen 2
K Methoden Programm ohne Main Methode starten Java Basics - Anfänger-Themen 2
I Fehlermeldung: Java does not contain a main type Java Basics - Anfänger-Themen 1
B ja ja schon wieder einer mit einer public static void main(string[] args) Frage... Java Basics - Anfänger-Themen 8
F Erste Schritte (Gelöst) Anfängerfrage Arraylist ausserhalb der Main Methode Java Basics - Anfänger-Themen 2
N Variablen Variable in Main deklarieren und in anderer Methode nutzen Java Basics - Anfänger-Themen 12
L Fehler: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException Java Basics - Anfänger-Themen 4
R window-Klasse, main-loop und unausschaltbares anti-aliasing Java Basics - Anfänger-Themen 0
T Mehrere Methoden in der main-Methode verknüpfen und aufeinander anwenden Java Basics - Anfänger-Themen 2
P Compiler-Fehler Could not load or find main class fehler Java Basics - Anfänger-Themen 15
S Selection does not contain a main type! Java Basics - Anfänger-Themen 5
A Methoden Zugriff auf eingelesene Variablen in der main Methode (ohne Änderung der Parameterliste) Java Basics - Anfänger-Themen 4
N Threads Exception in thread "main"... Feher bei dem Versuch ein Radius zu berechnen Java Basics - Anfänger-Themen 4
P Compiler-Fehler could not find or load main class Java Basics - Anfänger-Themen 5
A Code läuft nicht, Fehlermeldung Exception in thread "main" java.lang.Error: Unresolved compilation " Java Basics - Anfänger-Themen 11
U Umschreiben ohne main methode ;-) Java Basics - Anfänger-Themen 8
A Fehlermeldung beim aufruf der main Methode Java Basics - Anfänger-Themen 17
P Exception in thread "main" java.lang.NoClassDefFoundError: Java Basics - Anfänger-Themen 1
F Implementierung von Interfaces -> Problem mit main Java Basics - Anfänger-Themen 12
F Threads Variable aus einem Thread in main Methode? Java Basics - Anfänger-Themen 9
K Exception in thread "main" Java Basics - Anfänger-Themen 7
B Java Programm ohne statische Main Methode aufrufen Java Basics - Anfänger-Themen 5
B Klassen Eigene "non static" Klasse in Main verwenden! Java Basics - Anfänger-Themen 12

Ähnliche Java Themen

Neue Themen


Oben