You're probably just wanting something like this:

player.java:
public class Player 
{
    public static void main(String[] args) {
        Player player = new Player();
        Monster monster = new Monster();
        monster.attackPlayer(player);
    }
    public int getLocation()
    {
         return 2;
    }
}

monster.java:
public class Monster
{
    public void attackPlayer(Player player)
    {
        player.getLocation();
    }
}

Hope that helps/makes sense!

Well, one thing is you can't run some arbitrary line of code (System.out.println) in a class definition, so your example is invalid.

obj is an "instance variable" in Class1 — Class 2 would need to have a reference to an object of Class1 in order to access the "obj" member of that instance.

// in Classx.java
public class Classx {
}

// in Class1.java
public class Class1 {
    Classx obj = new Classx();
}

// in Class2.java
public class Class2 {
    Class1 anObj = new Class1();
    public void showIt() {
        System.out.println(anObj.obj);
    }
}

// in TestProg.java
public class TestProg {
    public static void main(String... args) {
        Class2 two = new Class2();
        two.showIt();
    }
}

Since obj in Class1 is not declared public, indeed no modifier is given, it has the default access which is package, so Class1 and Class2 would need to be in the same package to allow this use of anObj.obj.

Some hints or advice about your code that help you :

1. try to define your setter and getters for encapsulation purposes ,and having access to each field.

for example:

private int ID;

getter method is

public int getID(){
       return this.ID;
  }

setter method is

public void setID(int newID){
       this.ID = newID;
 }

2. Instead of having displayMinionData() , it is good practice to override toString method

For example if your variables are :

   private String came;
   private String city;

   public String toString(){
         return name + " " + city;
   }

I am not sure what you by accessing the solider in main method:

but you have this

Minion soldier = new Minion(0, "Soldier", "Human", "The First minion", 2, 1, 1);

As I told you

1. you can printout the whole info by using overridden toString on the console

2. you can extract each portion of the soldier variable by using getters

3. you can update each portion of the soldier variable by using setters

sample for toString:

System.out.print("Info about the current soldier is " + soldier.toString());

sample for getters:

System.out.println("ID:" + soldier .getID()):

sample for setters:

   int newID = 123456789;
   soldier.setID(newID);
   System.out.println("The new id of current soldier is " + soldier.getID()):

I believe the option that follows Object-Oriented Programming principles best is to pass the actual Player in as an argument, instead of just the money.

Basically, passing just the player's money in instead of the player themselves is like just handing your wallet over to the cashier. You wouldn't do that, right?

This way, the clerk can ask the customer if they have enough money by calling player.getMoney(), and the customer can tell them the answer.

After making the purchase, the player can remove the money from their wallet themselves when the clerk asks them to via player.setMoney().

Now, you asked in a comment about "passing the actual player as an argument without creating a new object of the player class." Java passes arguments by value, and all objects' values are simply the address that hold the information for that particular instance.

So for Player p1 in Beta, let's pretend all of p1's information is stored in a block starting at...let's say, address 21343. In this case, the variable p1 only contains that single number, 21343.

Since Java passes by value, then when you call s1.clerk(Player player), the player variable will also contain 21343. Since it's editing the items contained at the same address, you've essentially passed on p1 itself instead of creating a new Player. In short, the clerk and the main method work with the same object.

The fact that Java passes by value is also why passing just the player's money in doesn't adjust it automatically: The money is an int rather than an object. Since it's an int, when you pass it to the clerk, you're just saying "Hey, clerk, this is the amount of money being worked with." But the clerk has no idea who the money belongs to, so while it can take money, or even give it some, it's essentially just setting it down on the counter, and it's the responsibility of the player to pick it up from there when they're done. By passing in the player instead, the clerk knows who the money belongs to because it's actually asking the player how much money they have.

While interesting, both of the answers listed ignored that fact that the questioner is using static methods. Thus, any class or member variable will not be accessible to the method unless they are also declared static, or referenced statically. This example:

public class MyClass {
    public static String xThing;
    private static void makeThing() {
        String thing = "thing";
        xThing = thing;
        System.out.println(thing);
    }
    private static void makeOtherThing() {
        String otherThing = "otherThing";
        System.out.println(otherThing);
        System.out.println(xThing);
    }
    public static void main(String args[]) {
        makeThing();
        makeOtherThing();
    }
}

Will work, however, it would be better if it was more like this...

public class MyClass {
    private String xThing;
    public void makeThing() {
        String thing = "thing";
        xThing = thing;
        System.out.println(thing);
    }
    public void makeOtherThing() {
        String otherThing = "otherThing";
        System.out.println(otherThing);
        System.out.println(xThing);
    }
    public static void main(String args[]) {
       MyClass myObject = new MyClass();
       myObject.makeThing();
       myObject.makeOtherThing();
    }
}

First of all, in Java we usually use class names that start with a capital letter (Class1 and Class2)

public class Class1 {
    //...
}

public class Class2 {
    public static void main(String[] args) {
        Class1 c = new Class1();
    }
}

This means that you access an object of Class1 inside Class2 via a constructor.

In my example I am using the default constructor, but you can also define other constructors with parameters in your Class1 like:

public class Class1 {
    private String s1, s2;
    public Class1(String s1, String s2) {
        // do something (in general assign s1 and s2 to attributes s1 and s2
    }
}

Assume the Brand is a lightweight objects and Run is heavyweight then creating a field with the container for the lightweight objects and hiding it is a good idea.

But the Brand needs access the container it belongs to it could be done with the mapping but we are simply inject the Run to the Brand so it's better implement the Runable or annotate it with JSR330. And accessing the container through the Run in the normal way.

class MainClass {
  public static void main(String[] args) {
    Run r = new Run();
  }
}

class Run {
  private Container con1 = new Container();

  public Run() {
    Brand cola = new Brand("Coca Cola");
    Brand pepsi = new Brand("Pepsi");

    // Creates the container object "con1" and adds brands to container.
    add(cola);
    add(pepsi);
  }
  public void add(Brand b){
    con1.addToList(b);
    b.setRun(this);
  }

  public Container getContainer() {
    return con1;
  }
}

class Brand {
  // In this class I have a method which needs to accsess the con1 object
// containing all the brands and I need to access the method
  private String name;
  private Run run;

  public Brand(String name){
    this.name = name;

  }
  public void brandMethod() {
    if(getRun().getContainer().methodExample()) {        // Error here. Can't find "con1".**
      System.out.println("Method example returned true.");
    }
  }


  public Run getRun() {
    return run;
  }

  public void setRun(Run run) {
    this.run = run;
  }
}

class Container {
  // This class is a container-list containing all brands brands
  private ArrayList<Object> list = new ArrayList<Object>();

  public boolean methodExample(){
    return false;
  }

  public void addToList(Object o) {
    list.add(o);
  }
}