Invoking methods of a class that instantiated this one

I'm developing a game in Java which uses the Lightweight Java Game Library (LWJGL) with OpenGL.

I encountered the following problem.

I want to create an ArrayList of all textures in an object in the main loop, and access these from objects instantiated in this main object. A simplified example:

game.class:

public class Game {

  ArrayList Textures; // to hold the Texture object I created
  Player player; // create Player object

  public Game() {
    new ResourceLoader(); // Here is the instance of the ResourceLoader class
    player = new Player(StartingPosition) // And an instance of the playey, there are many more arguments I give it, but none of this matter (or so I hope)

    while(true) { // main loop
      // input handlers

      player.draw() // here I call the player charcter to be drawn

    }
  }

  // this method SHOULD allow the resource loader to add new textures
  public void addTextures (Texture tx) {
    Textures.add(tx);
  }
}

ResourceLoader.class

public class ResourceLoader {
  public ResourceLoader() {
    Interface.this.addTexture(new Texture("image.png")); // this is the line I need help with
  }
}

Player.class

public class Player {
  public player() {
    // some stuff, including assignment of appropriate textureID
  }

  public void draw() {
    Interface.this.Textures.get(this.textureID).bind(); // this also doesn't work
    // OpenGL method to draw the character
  }
}

In my real code the ResourceLoader class has about 20 textures to load.

There is a total of over 400 entities in the game that have a draw method just like Player.class and most of them share the same texture; e.g. there are about 150-180 wall object all showing the same image of bricks.

The Game object is not the main class and it does not have the static void main() method, but it is one of the only few things instantiated in the main() method of the game.

Also, in the past, I worked around the problem by letting each entity load its own texture file. But as I increased the complexity and map size, it becomes very inefficient to load the same image hundreds of times.

I arrived at the state of the code above from this answer.

I believe I would have to put ResourceLoader.class and Player.class inside the game.class, which would not be a good solution considering that there are about 20 files that need this treatment and most of them are 200+ lines long.

I think my Texture object as well as initialization of OpenGL and other stuff are pretty generic and should not impact the issue in question. I can provide these if necessary.

Make the "outer" class instance a parameter to the constructors:

public class Player {
   final Interface obj;

   public player(Interface obj) {
       this.obj = obj;
      // some stuff, including assignment of appropriate textureID
   }

   public void draw() {
       obj.Textures.get(this.textureID).bind();
   }
}

public class ResourceLoader {
   public ResourceLoader(Interface obj) {
      obj.addTexture(new Texture("image.png"));
   }
}

And instantiate those in Game like:

new Player(this);

Note: The example lines used Interface but Game does not implement it. I assume that's an artifact of code cleaned for the posting. Just use the type that is appropriate for your situation.