Instance of a Method in a Separate Class/Method?

Question

I am creating a small game of Final Fantasy characters, in which I input the name of who I would like to "fight" I have each character (only 5 of them) as a subclass to a superclass called Stats in which the variables (non static) and getters/setters are defined.

The code all works as I would like, but I don't like it all being in One huge class.

The Main method is here;

package com.George.revision;

import java.util.Random;

import com.George.characters.Cloud;
import com.George.characters.Squall;
import com.George.characters.Stats;
import com.George.characters.TheEnemy;
import com.George.characters.ThePlayer;
import com.George.characters.Tidus;
import com.George.characters.Yuna;
import com.George.characters.Zidane;
import com.George.input.GetInput;
import com.George.input.ListNames;



public class Main {


    public static void main(String[] args) {

        ListNames.listNames();


        Stats clo = new Cloud();
        Stats squ = new Squall();
        Stats zid = new Zidane();
        Stats tid = new Tidus();
        Stats yun = new Yuna();

        String versus = GetInput.getInput("\nWhich of these Characters would you like to go up against?");

        Stats ene1 = new TheEnemy();


        switch (versus) {
        case "Cloud":
            ene1.setName(Names.CLOUD);
            ene1.setHairColor(Stats.BLONDE);
            ene1.setWep(Weapons.BUSTER_SWORD);
            ene1.setSkill(clo.skill);
            ene1.setAp(clo.ap);
            ene1.setStr(clo.str);
            ene1.setMag(clo.mag);
            break;
        case "Squall":
            ene1.setName(Names.SQUALL);
            ene1.setHairColor(Stats.BLACK);
            ene1.setWep(Weapons.LIONHEART);
            ene1.setSkill(squ.skill);
            ene1.setAp(squ.ap);
            ene1.setStr(squ.str);
            ene1.setMag(squ.mag);
            break;
        case "Zidane":
            ene1.setName(Names.ZIDANE);
            ene1.setHairColor(Stats.LIGHTBROWN);
            ene1.setWep(Weapons.THIEF_DAGGER);
            ene1.setSkill(zid.skill);
            ene1.setAp(zid.ap);
            ene1.setStr(zid.str);
            ene1.setMag(zid.mag);
            break;
        case "Tidus":           
            ene1.setName(Names.TIDUS);
            ene1.setHairColor(Stats.BLONDE);
            ene1.setWep(Weapons.CALADBOLG);
            ene1.setSkill(tid.skill);
            ene1.setAp(tid.ap);
            ene1.setStr(tid.str);
            ene1.setMag(tid.mag);
            break;
        case "Yuna":
            ene1.setName(Names.YUNA);
            ene1.setHairColor(Stats.DARKBROWN);
            ene1.setWep(Weapons.NIRVANA);
            ene1.setSkill(yun.skill);
            ene1.setAp(yun.ap);
            ene1.setStr(yun.str);
            ene1.setMag(yun.mag);
            break;
        default:
            System.out.println("You did not enter a valid character name");
            break;


        } 
        System.out.println("You have chosen to face " + ene1.name);
        System.out.println("Enemy Skill = " + ene1.skill + " Enemy Weapon = " + ene1.wep);



        System.out.println("Enemy Skill = " + ene1.skill + " Enemy Weapon = " + ene1.wep);

        int eneTotal = ene1.skill + ene1.ap + ene1.str + ene1.mag;

        Stats player = new ThePlayer();

        String plN = GetInput.getInput("What is your name?");
        player.playerName = plN;        
        System.out.println("So Your name is " + player.playerName);

        String plWep = GetInput.getInput("What is your Weapon's name?");
        player.playerWep = plWep;
        System.out.println("So your Weapon is " + player.playerWep);

        Random generator = new Random();
        int plSkill = generator.nextInt(10);
        player.skill = plSkill;
        System.out.println("Your skill level is " + player.skill);

        Random gn = new Random();
        int plAp = gn.nextInt(10 - 5) + 5;
        System.out.println("So your Attack Power is " + plAp);
        player.ap =  plAp;

        Random gns = new Random();
        int plStr = gns.nextInt(10);
        System.out.println("So your Strength is " + plStr);
        plStr = player.str;

        Random gnm = new Random();
        int plMag = gnm.nextInt(10 - 5) + 5;
        player.mag = plMag;
        System.out.println("So your Magic is " + player.mag);


        int plHax = 15;
        double doubleResult = plHax;


        double ene1Hax = 3.99;
        int intResult = (int)ene1Hax;


        double doubleValue = 6.99;
        Double doubleObj = new Double(doubleValue);
        int intR = doubleObj.intValue();

        System.out.println(intR);

        int plyrTotal = player.skill + player.ap + player.str + player.mag;

        if (plyrTotal > eneTotal) {
            System.out.println("Congratulations you beat " + ene1.name + " Please Play Again!" );

        } else if (plyrTotal == eneTotal) {
            System.out.println("You drew with " + ene1.name + " Play again and Win!");
        }
        else
        {
            System.out.println("You were not succesful this time " + ene1.name + " Defeated you by " + (eneTotal - plyrTotal) + " Please Try Again");

        }


    }

}

Now after this I have a whole lot more code generating random numbers for the players "stats", and the character, and then matching the total values of their stats to determine "a winner" which I would like to put in a separate class. My issue is,

how do I get ene1 in a separate class with the values that are input in the switch statement in the Main class.

Updated to full main method just for clarity

Answer 1

One of the issues you have is that you are assigning Enemy as a subclass of Stats, but with no relation to your characters. So while the enemy has the same attributes of a character, it has no relationship in which to speak to the character. Instead of copying all of these values like name and color, instead make Enemy it's own entity that holds a Stats value, that shares an interface with stats. The enemy can then use that interface to call various methods in the Stats class.

public class Static implements Actions{
    // ...
}

public class Enemy implements Actions{
   private Static characterType;
}

Also for future reference, could you please design your questions to be more generic? It not only helps those who don't understand the references, but also makes it easier for people who have similar problems to find this.

Answer 2

You can just pass it into a method (or constructor) of that class as you would any other variable or text. I.e.

 clo.setOpponent(ene1);

Then have the implementation of setOpponent be like this

 class Stats
 {
      private Stats opponent;
      //ALL OF YOUR OTHER CODE AND METHODS GO HERE

      public void setOpponent(Stats enemy)
      {
          opponent = enemy;
      }
 }

This doesn't take into account the poor OO design of your application, it only answers your question. Better design comes with more practice and some studying (look up IS-A and HAS-A relationships to help with basic OO design)

Answer 3

In your particular example I would suggest to have Enumerations for the enemies, instead of using class hierarchy, as you have got the same fields for all enemy entities and you're not using any external storage here (like DB, file or whatever).

Class hierarchies are more suitable for situations, when you have several entities which have got both similarities and distinguishes. For example, you can have one class for regular enemies, and one class for 'enforced' enemies with some superskills, so the second class will inherit the first one and will have 1 additional field. This allows you to reduce the code duplicates and provides enough flexibility. Also, class hierarchy gives you some more benefits when you want to save this entities in some storage, for example, DB.

But in you case, it is more logical to use a single Enum to have some set of enemies, which is 'hardcoded' to the application. I would suggest the next solution:

public enum Enemy {
    CLOUD("Cloud", "Red", "Sword", 10),
    SQUALL("Cloud", "Black", "Minigun", 999)
    // and so on
    ;

    public String name;
    public String hairColor;
    public String wep;
    public int skill;

    Enemy(String name, String hairColor, String wep, int skill /* and so on */) {
        this.name = name;
        this.hairColor = hairColor;
        this.wep = wep;
        this.skill = skill;
    }

    public static Enemy getByName(String name) {
        for (Enemy enemy : Enemy.values()) {
            if (enemy.name.equalsIgnoreCase(name)) {
                return enemy;
            }
        }
        throw new IllegalArgumentException("Enemy with the name `" + name + "` doesn't exist.");
    }
}

And then it is possible to initialize an enemy in the main class by its key name:

String versus = GetInput.getInput("\nWhich of these Characters would you like to go up against?");
try {
    Enemy enemy = Enemy.getByName(versus);
} catch (IllegalArgumentException e) {  // processing incorrect input
    System.out.println(e.getMessage());
}

Then you can pass this constant to any other class to process it and calculate whatever you want:

public class FightCalculator {
    public int calculateScore(Enemy enemy) {
         // Some calculations here...
    }
}

Answer 4

It might help to create separate Hero and Enemy classes. Or if your characters aren't "good" or "bad" guys, perhaps just a Character class. For the following discussion, I will simply use Character, but you can replace this with Hero or Enemy and it should still make sense.

First of all, what is the relationship between a Character and a Stats. I think a Characater has a Stats. This means that Character should have a member variable of type Stats:

class Character {
    private Stats stats = new Stats();
}

Now you can add a constructor that a new Stats object for a Character. This means that the Character needs to take several parameters for each of the values stored in a Stats. One advantage of this approach is that you write the code to set up a Stats object just once and then each case statement has just 1 line:

ene1 = new Character(/* all the stats values go here */);

The moral of the story here is that when you find yourself repeating code, you should consider writing a method which encapsulates that repetition.