Thread: Drawing to a JFrame From Other Classes

I'm attempting to port over a very simple game I've written in another language as my very first Java project. However, I'm a bit unsure as to how I should be drawing the images I've loaded from file. The idea that every JComponent has its own drawComponent() method is totally new to me. I come from the experience where each game object manually drew itself onto a shared graphics back buffer, which was then swapped to the front after everything had been drawn.

My first idea has been to use the JFrame I'm using as my main game window (is this even the way they're intended to be used?) to determine what needs drawing and then do so, but it's probably going to lead to a very bloated class. The ideal way, I'd imagine, would be for me to offload the code responsible for drawing each object to a class of that object, but so far my experiments with trying to have them draw to my main JFrame have all ended in failure. I'm not sure what the "correct" approach to this problem would be. I don't really have any code to show at this point because I haven't gotten past the concept/test phase.

For a specific example: Would there be a way to have a method of a class draw a Line onto an unrelated JFrame-type class? Google hasn't turned up anything useful, but the wording for this one is a bit tricky. All of the other simple Java game examples I've found use a single class to draw everything, as well as for most of the logic.

EDIT: Should this actually go in the Java Theory & Questions sub-forum?

a way to have a method of a class draw a Line onto an unrelated JFrame-type class?

Each Swing component has a paintComponent() method that will draw in the Graphcis space it occupies in the GUI.
That method is called when the java program thinks the component's GUI need to be drawn or in response to a call to repaint().
The paintComponent method is passed a Graphics object that is used to draw on. If you want a method in another class to draw using that Graphics object, call the method and pass it the Graphics object.

Recommended reading: Lesson: Performing Custom Painting (The Java™ Tutorials > Creating a GUI With JFC/Swing)

Just to make Norm's advice (which is spot on correct) more concrete, I'll give you a little example:

public class GamePanel extends JPanel{
   GameObject gameObject = new GameObject(250, 250); //put it in the middle
 
 
   public void paintComponent(Graphics g){
      super.paintComponent(g);
      gameObject.draw(g);
   }
 
 
   public static void main(String... args){
      JFrame frame = new JFrame("Test Game");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      GamePanel gamePanel = new GamePanel();
      frame.add(gamePanel);
      frame.setSize(500, 500);
      frame.setVisible(true);
   }
 
}
 
public class GameObject{
   int x;
   int y;
 
   public GameObject(int x, int y){
      this.x = x;
      this.y = y;
   }
 
   public void draw(Graphics g){
      g.setColor(Color.GREEN);
      g.fillOval(x, y, 10, 10);
   }
}

Hopefully that's pretty straightforward. But usually the basics are this: you extend JPanel (or JComponent) and override paintComponent. You call the super class's paintComponent to handle the background and stuff, then you tell whatever Objects to paint themselves using the Graphics instance given to paintComponent. You then add your JPanel to a JFrame or a JApplet.

And this is the correct forum for this question.

Java passes everything by value. (And returns things that way. And assigns things that way.)

In the expression "gameObject.draw(g);" what gets passed is the value of the variable g not a reference to that variable. draw() receives a copy of the value of the caller's variable: as can be seen from the fact that nothing draw() can do can alter the value of the caller's variable.

This isn't the default behaviour, it's the only behaviour: there are no references to variables.

See JavaRanch Campfire - Cup Size: a Story About Variables and JavaRanch Campfire - Pass By Value, Please

Alright then, would it be appropriate to compare this to passing a copy of a pointer to an object (not an actual pointer, but the same idea), as in some other languages? Wouldn't that basically mean that regular variables are passed by value, and object are passed by reference in essence? I'm going off of what I read through the two links you took the time to find for me, and what I found in a couple books. I don't mean to ask questions that the links seem to already answer, I just want to make sure I don't have an incomplete picture of what's happening in this circumstance. Otherwise, I know exactly what I'm dealing with and should be fine.

EDIT: To clarify where I'm coming from, in the languages I've personally dealt with, passing an object By Value and then using its member functions would have absolutely no result outside of the method because you were only altering the state of a copy. You had to either pass By Reference or pass a pointer (the same thing usually).

Everything is passed by value. A copy of the address of an object is passed allowing a method to get to the object referenced by the "pointer" passed to it.
There is no way to define an object as a variable. You always get its address in a "pointer" when you use the new statement.