Thread: Best way to work with internal frames.

Ok, well my first question would be: are you sure you mean internal frames and not panels?

As far as the interaction back and forth goes, I've handled this approach in the past by creating separate classes for each content panel. However, I would have an abstract class (which extends JPanel, or perhaps in your case: JInternalFrame) with a variable referring to the mainFrame and a constructor which accepts a mainFrame object. All of my content panel classes extend from my abstract class, and use the super constructor with the mainFrame parameter. Then, when I create the content panels, I pass in the instance of the mainFrame each time. This allows backwards interaction.
Here is a basic code example of what I am describing:

public class MainFrame extends JFrame {
	public MainFrame() {
		super();
		FirstPanel firstPanel = new FirstPanel(this);
		SecondPanel secondPanel = new SecondPanel(this);
	}
}
 
public abstract class AbstractPanel extends JPanel {
	private MainFrame mainFrame;
	public AbstractPanel(MainFrame mf) {
		super();
		mainFrame = mf;
	}
	public MainFrame getMainFrame() {
		return mainFrame;
	}
}
 
public class FirstPanel extends AbstractPanel {
	public FirstPanel(MainFrame mf) {
		super(mf);
	}
}
 
public class SecondPanel extends AbstractPanel {
	public SecondPanel(MainFrame mf) {
		super(mf);
	}
}

As for the database question: it depends on how often you are querying. If you do a lot of querying, you can probably keep it open. But if you only query in the beginning and then again in the end (for example), it is probably best to close it each time.

Why does your MainFrame extend JFrame but doesn't use any JFrame method? If you want your MainFrame class to behave like a JFrame, your first call in your constructor should be to a super constructor.

Consider your program from a long-term management point of view. The primary reason I separate my panel classes is to separate each panel's components from each other. Each panel class contains only the gui elements needed for that panel. When you create all of your panels in one huge gui class, you have all of those elements all thrown into once class with each other. On a tiny program this is manageable. But for a large program, or even a medium program, all of these variables together can lead to confusion for you or other developers, which greatly reduces how quickly and efficently you can modify your code.
Even creating them with methods in one gui class will lead to you having to create all the gui elements in that class. They may only have the scope of the method creating the internal frame, but that still results in a huge class file with hundreds, or maybe thousands of lines of code. I'd bet my life savings on this approach becoming too cumbersome for you to comfortably maintain in the long term.

Having many different class files can also appear cumbersome initially, but I personally prefer a lot of small files with specific goals and operations, compared to one massive file where I attempt to do everything. A lot of small files are thousands of times easier to maintain than one massive file.

You can combine both mine and your designs by creating a class like this:

public LoginFrame extends JInternalFrame {
	private MainFrame mainFrame;
 
	public LoginFrame(MainFrame mf, String title, boolean bool1, boolean bool2, boolean bool3, boolean bool4) {
		super(title,bool1,bool2,bool3,bool4);
		mainFrame = mf;
		// Create and add all of your log in frame components in the rest of your constructor
	}
}

And then in your MainFrame class you can have a method like this:

public void createLoginFrame() {
		final JInternalFrame login = new LoginFrame(this,"Internal Frame title", true, true, true, true);
	}