card cannot be resolved to a variable - java

I'm working on a personal project. It will be a card game that you might for instance compare to pokemon. unfortunately, I'm running into an error and I can't figure out what causes it. I'd appreciate any help!
okay, so I've got the card class (I've left out unnessesary attributes) with a constructor
public class Card
{
String name;
String cardID;
int strFire;
int strEarth;
public Card(String n, String id, int fire, int earth)
{
name = n;
cardID = id;
strFire = fire;
strEarth = earth;
}
}
then I've got the Deck class, which should create the instances of all cards.
public class Deck
{
static void createDeck()
{
Card hoax06 = new Card("Nirwadas the Traveler", "hoax06", 3, 2);
System.out.println(hoax06.name); // this works
}
}
and finally, I've got the Game class which holds main.
public class Game
{
public static void main(String[] args)
{
Deck.createDeck();
System.out.println(hoax06.name); // hoax06 cannot be resolved to a variable
}
}
I know the answer is probably quite simple but java's accessing system still confuses me. I've also browsed the forum for similar errors but have been unable to apply them to my case. how should I refer to a card from within main?


The card instance is created in the Deck class, so the Game class has no direct knowledge of it. Also, as soon as the createDeck() method ends you lose your reference to the card and the instance is gone.
Here's a simple example:
public class Deck
{
public Card hoax06;
static Deck createDeck()
{
Deck deck = new Deck();
deck.hoax06 = new Card("Nirwadas the Traveler", "hoax06", 3, 2);
return deck;
}
}
public class Game
{
public static void main(String[] args)
{
Deck deck = Deck.createDeck();
System.out.println(deck.hoax06.name); // this is where the error occurs
}
}


You never made hoax06. That is why the error is occurring.
Deck.createDeck();
System.out.println(hoax06.name);
Here are some options:
Make createDeck() return the card
Make a static Card in Deck, so you could use Deck.hoax06.name


try this:
public class Deck
{
static Card createDeck()
{
Card hoax06 = new Card("Nirwadas the Traveler", "hoax06", 3, 2);
System.out.println(hoax06.name); // this works
return hoax06; //return the object
}
}
public class Game
{
public static void main(String[] args)
{
Card c=Deck.createDeck(); //get the object
System.out.println(c.name); // use it here
}
}


You could create an enum (perhaps called Cards), listing all your cards, then access them from inside your Game class (or anywhere else) by using Cards.HOAX06.name
For example something like this:
enum Cards {
HOAX06("Nirwadas the Traveler", 3, 2),
HOAX07("Something else", 5, 2)
//list all your cards here in the same way
;
String name;
int strFire;
int strEarth;
Cards(String name, int fire, int earth){
this.name = name;
this.strFire = fire;
this.strEarth = earth;
}
}
Then to call it from another class:
public static void main(String[] args) {
System.out.println(Cards.HOAX06.name);
System.out.println(Cards.HOAX07.strEarth);
System.out.println(Cards.HOAX06.strFire);
}
All Enums are static and final by default you couldn't change the values once they were created, but then I'm guessing that for a deck of cards you probably won't want to..

Related

Cannot call a method?

I have a Game class and a TestGame class, I'm trying to call a method from Game to TestGame.
TestGame.java
public class TestGame {
Players ceri = new Players("Ceri", 1);
Players harry = new Players("Harry", 1);
Players lewis = new Players("Lewis", 1);
Players kwok = new Players("Kwok", 1);
Players james = new Players("James", 1);
Players matthew = new Players("Matthew", 1);
Game league = new Game("League Table");
league.addplayer(ceri);
public static void main(String[] args) {
}
}
and Game.java
public class Game {
private String name;
public Game(String name){
this.name = name;
}
public void addPlayer(Players obj){
}
}
I get red lines underneath league.addPlayer for some reason.

league.addplayer(ceri); is code, not initializer.
You need to put it inside a method or inside an initalizer block.
In this case put it inside your main method.

You'd have to move all of these lines to the main() method:
Players ceri = new Players("Ceri", 1);
Game league = new Game("League Table");
league.addplayer(ceri);
If you move only the last one, the league and ceri variables won't be accessible, as the main method is a static method and these variables would be instance variables.

All of your Players (and Game) are declared inside the class body. This makes them global variables with default level access. Something to note in addition to Tim B's answer.

You should put your code inside the main block.
public static void main(String[] args)
{
league.addplayer(ceri);
}

Adding new objects to an ArrayList in constructor

I am trying to add newly created objects to an ArrayList in the constructor of a class. The new objects are being created in another class in the main method.
Main method:
public static void main(String[] args) {
// TODO code application logic here
Player p1 = new Player("Peter");
}
My Player class:
public class Player {
protected static int age;
protected static String name;
protected static ArrayList players = new ArrayList();
Player(String aName) {
name = aName;
age = 15;
players.add(new Player()); // i know this doesn't work but trying along these lines
}
}

You have to edit the line
players.add(new Player());
to
players.add(this);
Also, there is no need to make the age and name static
I suggest you should have the following code instead
import java.util.ArrayList;
public class Player {
protected int age; //static is removed
protected String name; // static is removed
protected static ArrayList<Player> players = new ArrayList<Player>(); //this is not a best practice to have a list of player inside player.
Player(String aName) {
name = aName;
age = 15;
players.add(this); // i know this doesn't work but trying along these lines
}
public static void main(String[] args) {
// TODO code application logic here
Player p1 = new Player("Peter");
}
}

It sounds like you're actually asking how to refer to the instance you're constructing.
That's what the this keyword does.

This post is old, but for someone with similiar needs I suggest doing it like this:
Main class:
public static void main(String[] args) {
//TODO code application logic here
java.util.List<Player> players = new java.util.ArrayList<>(); //list to hold all players
Player p1 = new Player("Peter"); //test player
players.add(p1); //adding test player to the list
players.add(new Player("Peter")); //also possible in this case to add test player without creating variable for it.
}
Player class:
public class Player {
private final int age = 15; //if you always going to use 15 as a age like in your case it could be final. if not then pass it to constructor and initialize the same way as the name.
private String name;
Player(String name) { //variable name can be the same as one in class, just add this prefix to indicated you are talking about the one which is global class variable.
this.name = name;
}
}
Generally you should avoid using static keyword on variables which supposed to be different in each instance of that class. Avoid having object of itself inside.

How do you pass in an array from the main method to another method in java?

I have an array of Person in my main method, and I have to pass in that array to PlayGame() method in the class Game. How do you do that?
public class RollOff {
public static void main(String[] args) throws IOException{
int numPeople;
int a;
System.out.println("How many people will play the game?");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
numPeople = Integer.parseInt(s);
if ((numPeople >= 2) && (numPeople <= 10)) {
Person[] p = new Person[numPeople];
for (a = 0; a < numPeople; a++) {
p[0] = new Person(a);
}
}
}
}
public class Game extends RollOff{
int numPeople;
int a;
void PlayGame() {
}
}

You need to use parameters to do that:
void playGame(Person[] p){
...
}
Now simply call
public static void main(String[] args){
...
game.playGame(p);
}
Because playGame is not a static method, you'll either need to make it static and call Game.playGame(p) or you'll need to create an instance of Game: Game game = new Game() followed by a call of game, as shown in the example above.

public void play(Person[] person) {
// code
}
// The call
play(person);

You can simply add a Person array parameter to the PlayGame
void playGame(Person[] personArray){//logic of the method}
Then all you have to do is call the playGame method from the main method by creating a new instance of the class Game
Game game = new Game();
game.PlayGame(p);
here "p" is your persons array.

The main class should create an instance of Game, and pass the array of players to the constructor:
Game game = new Game(p);
game.playGame();
The Game class should thus have the following field and constructor:
private Person[] players;
public Game(Person[] players) {
this.players = players;
}
Note that methods should start with a lower-case letter to follow Java naming conventions, and that your loop has a bug: it always sets the first element of the array instead of initializing every element.
Finally, give meaningful names to variables: players is much more readable than p.

how to stop getting the same number when generating 2 numbers from a different class

When I run this code i get 2 numbers (which is good) but the numbers generated are the same (which is bad) and I dont want the numbers to be the same. I've done this as an experiment for a rpg I was going to make so I thought it would be beter if each weapon had a different class.
The main class:
package battlesimMK2;
public class Main {
public static void main(String Arg[]) {
String WeponEquiped = "BasicAxe";
System.out.print(BasicAxe.Str);
System.out.print(BasicAxe.Str);
}
}
The basic axe class:
package battlesimMK2;
import java.util.Random;
public class BasicAxe {
static Random rnd = new Random();
static int Str = rnd.nextInt(4)+5;
}

This line:
static int Str = rnd.nextInt(4)+5;
declares a static variable and initializes it once. If you want the code to run each to you access Str, you should make it a method:
public static int getStrength() {
return rnd.nextInt(4)+5;
}
Then call it with this code in Main.main:
System.out.print(BasicAxe.getStrength());
System.out.print(BasicAxe.getStrength());
An alternative which would probably be more object-oriented would be to make the strength an instance field, so that each axe created had a possibly-different (but persistent) strength:
public class BasicAxe {
private static final Random rnd = new Random();
private final int strength;
public BasicAxe() {
strength = rnd.nextInt(4)+5;
}
public int getStrength() {
return strength;
}
}
Then in Main.main:
BasicAxe axe1 = new BasicAxe();
BasicAxe axe2 = new BasicAxe();
System.out.println(axe1.getStrength());
System.out.println(axe2.getStrength());
System.out.println(axe1.getStrength());
Here, the first and third lines of output will be the same - but the second will (probably) be different.

You're generating a single random number and printing it twice. Try something like this instead:
package battlesimMK2;
public class Main {
public static void main(String Arg[]) {
String WeponEquiped = "BasicAxe";
System.out.print(BasicAxe.Str());
System.out.print(BasicAxe.Str());
}
}
package battlesimMK2;
import java.util.Random;
public class BasicAxe {
static Random rnd = new Random();
static int Str() { return rnd.nextInt(4)+5; }
}

This because this line
static int Str = rnd.nextInt(4)+5;
runs just one time in whole the lifecycle of your application. It's static value, you should use static method instead.

Because you define the Str variable as static, only a single copy of that variable is shared between all your BasicAxe classes.
The way to get a different answer each time you ask for the int value is, to use the example posted by the previous poster,
String WeponEquiped = "BasicAxe";
System.out.print(BasicAxe.getStrength());
System.out.print(BasicAxe.getStrength());
But, if you want to create an actual instance of the class BasicAxe, which keeps it's value so that each time you ask for the strength you get the same value, you'll need something different.

How can I access an an arraylist from a different class in Java?

import java.util.ArrayList;
import java.util.Collections;
public class Cards
{
public static enum cards
{
D_A, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9, D_10, D_J, D_Q, D_K,
H_A, H_2, H_3, H_4, H_5, H_6, H_7, H_8, H_9, H_10, H_J, H_Q, H_K,
C_A, C_2, C_3, C_4, C_5, C_6, C_7, C_8, C_9, C_10, C_J, C_Q, C_K,
S_A, S_2, S_3, S_4, S_5, S_6, S_7, S_8, S_9, S_10, S_J, S_Q, S_K,
}
public Cards()
{
ArrayList<cards> deck;
deck = new ArrayList<cards>(51);
for (cards card : cards.values())
{
deck.add(card);
}
Collections.shuffle(deck);
String img = deck.get(2).toString()+".gif";
System.out.println(img);
}
public static void main(String[] args)
{
Cards CardDeck = new Cards();
}
}
I want to access the arraylist in a different class. How can I do this?

Use Cards.cards.D_A or whichever you want. Don't forget to import the class if they are not in the same package...

Since it's static, Cards.cards ought to work.

To access the ArrayList you need to have the list as a member of the class.
Then you need to either establish an accessor method, or make that member variable public (not recommended).
The first solution is provided here:
public class Cards
{
private ArrayList<cards> deck;
public static enum cards
{
D_A, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9, D_10, D_J, D_Q, D_K,
H_A, H_2, H_3, H_4, H_5, H_6, H_7, H_8, H_9, H_10, H_J, H_Q, H_K,
C_A, C_2, C_3, C_4, C_5, C_6, C_7, C_8, C_9, C_10, C_J, C_Q, C_K,
S_A, S_2, S_3, S_4, S_5, S_6, S_7, S_8, S_9, S_10, S_J, S_Q, S_K,
}
public Cards()
{
deck = new ArrayList<cards>(51);
for (cards card : cards.values())
{
deck.add(card);
}
Collections.shuffle(deck);
String img = deck.get(2).toString()+".gif";
System.out.println(img);
}
public ArrayList <cards> getDeck() {
return deck;
}
public static void main(String[] args)
{
Cards CardDeck = new Cards();
}
}

Categories