Develop Reference

What's the point of setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);?

I was taught to add this to always add this to the run method of jframe, but it doesn't change anything compared to not using it.
What I want to know is, what happens when you leave this out?
Thanks
#Override
public void run() {
frame = new JFrame(title);
frame.setPreferredSize(new Dimension(400, 200));
//frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
createComponents(frame.getContentPane());
frame.pack();
frame.setVisible(true);
}

The process of your app will still remain in memory.
This is from the official documentation:
-DO_NOTHING_ON_CLOSE (defined in WindowConstants): Don't do anything; require the program to handle the operation in the windowClosing method of a registered WindowListener object.
-HIDE_ON_CLOSE (defined in WindowConstants): Automatically hide the frame after invoking any registered WindowListener objects.
-DISPOSE_ON_CLOSE (defined in WindowConstants): Automatically hide and dispose the frame after invoking any registered WindowListener objects.
-EXIT_ON_CLOSE (defined in JFrame): Exit the application using the System exit method. Use this only in applications.

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE) is used to close your JFrame as well as Java process. Test it with a JFrame sample program without the setDefaultCloseOperaton. Close your jframe by clicking the windows close. Check your task manager/top command , you will find the java process will be still running.

I know this is an old question, but what I was taught to do was create an inner class in the class that extends JFrame.
The inner class should extend WindowAdapter, and you should override the windowClosing method, I usually just put System.exit(0); in it.
Then in the constructor of your JFrame class, add this line:
this.addWindowListener(new MyWindowAdapterClass());

How can I close the main GUI in Java SE?

Using swing, I want to close my mainGUI with "setVisible(false)", how can I close it when I opened it like this:
public void run() {
new mainGUI().setVisible(true);
}
I want to close the GUI from a method like this:
public void close(){
//Close GUI here
}
What call is missing from my code to let the GUI close itself?

It depends the place you wanna do that:
In the same class
// Close the window
this.detach();
or
// Hide the window
this.setVisible(false);
In other class you need to send the window like a param and use the same methods.
// Close the window
window.detach();
or
// Hide the window
window.setVisible(false);

I want to close the GUI from a method like this:
Presumably you invoke this method when the user clicks on a button or menu item. So the best way is to create an Action that you add to the component. Then the Action will be executed when the component is clicked.
For example you can use the Exit Action found in Closing An Application. The ExitAction will find the current window with focus and then close it.

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) or you could use focus listener
Go through this in java docs this might help you

How can save some Objects, directly after the User has closed the Applications JFrame, but before the Program exits?

Good day!
I'm developping a small Java Application with NetBeans IDE that extends JFrame. I implemented several ways to close the App, for example pressing Ctrl-Q and pressing the X of the JFrame.
But before the actual closing I'd like the program to execute some additional code for me, to save some objects the application needs to reuse the next time it starts up.
What is the best way to change the entire programs closing behavior?
I'm thinking about overriding/replacing the defaultCloseOperation, something like this:
setDefaultCloseOperation( myOwnCloseOperation );
Thanks for any help!

setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE )
Add a WindowListener or WindowAdapter - overriding either the windowClosing() or windowClosed() methods (I forget which) to catch the closing event.
Call the save functionality from the window method.
Call setVisible(false) or dispose() (as discussed in the comments) at the end.

Closing on a single window closes all the frames in java

I would like to make possible the navigation of frames in java.Whenever i close a frame the remaining frames which are also opened get closed;and the entire program stops.
Please help...

You probably used
//this will terminate or exit your application
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Maybe you want to use this instead,
setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
for your reference go to this link

If you want to close only that one frame, you should do something like this: setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE)
If you want to close all frames whenever a single frame closes you can do the following:
You could use a window listener and call System.exit(0); when the JFrame closes, or try setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); on each JFrame. That way your program would close all frames and end.
If you need to perform some tasks before application quits, you should probably use the window listener.

You can also do that graphicaly. right click on your frame and select properties and from there you can change that like the below picture.

If you were using swing palette. In frame properties choose default close operation as (Dispose). Follow as per the image given in this solution.

My problem was that I used a listener found on the basic tutorials :
WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
};
addWindowListener(l);
I know it's dumb. I didn't see it, but some people might have done the same thing, so I'll just leave this here ;)

How to close a GUI when I push a JButton?

Does anyone know how to make a jbutton close a gui? I think it is like System.CLOSE(0); but that didnt work. it also could be exitActionPerformed(evt);, but that didn't work either. just the line of code will work.
EDIT: never mind guys. the answer was System.exit(0);. thanks for the help though!

Add your button:
JButton close = new JButton("Close");
Add an ActionListener:
close.addActionListner(new CloseListener());
Add a class for the Listener implementing the ActionListener interface and override its main function:
private class CloseListener implements ActionListener{
#Override
public void actionPerformed(ActionEvent e) {
//DO SOMETHING
System.exit(0);
}
}
This might be not the best way, but its a point to start. The class for example can be made public and not as a private class inside another one.

By using System.exit(0); you would close the entire process. Is that what you wanted or did you intend to close only the GUI window and allow the process to continue running?
The quickest, easiest and most robust way to simply close a JFrame or JPanel with the click of a JButton is to add an actionListener to the JButton which will execute the line of code below when the JButton is clicked:
this.dispose();
If you are using the NetBeans GUI designer, the easiest way to add this actionListener is to enter the GUI editor window and double click the JButton component. Doing this will automatically create an actionListener and actionEvent, which can be modified manually by you.

See JFrame.setDefaultCloseOperation(DISPOSE_ON_CLOSE)1. You might also use EXIT_ON_CLOSE, but it is better to explicitly clean up any running threads, then when the last GUI element becomes invisible, the EDT & JRE will end.
The 'button' to invoke this operation is already on a frame.
See this answer to How to best position Swing GUIs? for a demo. of the DISPOSE_ON_CLOSE functionality.The JRE will end after all 3 frames are closed by clicking the X button.

You may use Window#dispose() method to release all of the native screen resources, subcomponents, and all of its owned children.
The System.exit(0) will terminates the currently running Java Virtual Machine.

In Java 8, you can use Lambda expressions to make it simpler.
Close application
JButton btnClose = new JButton("Close");
btnClose.addActionListener(e -> System.exit(0));
Close window
JButton btnClose = new JButton("Close");
btnClose.addActionListener(e -> this.dispose());

Create a method and call it to close the JFrame, for example:
public void CloseJframe(){
super.dispose();
}

JButton close = new JButton("Close");
close.addActionListener(this);
public void actionPerformed(ActionEvent closing) {
// getSource() checks for the source of clicked Button , compares with the name of button in which here is close .
if(closing.getSource()==close)
System.exit(0);
// This exit Your GUI
}
/*Some Answers were asking for #override which is overriding the method the super class or the parent class and creating different objects and etc which makes the answer too long . Note : we just need to import java.awt.*; and java.swing.*; and Adding this command : class className implements actionListener{} */