Java Swing: getting reference to GUI component

I have started to learn Java and thus Swing as well. I have been looking into building a GUI and wondering, how can I get the reference of GUI component to modify/read/delete it after I created it. Do I have to hold on to the reference I get when creating the component? Or is there something like in Javascript: document.querySelector(), .querySelectorAll(), .getElementBy...()?

As an example we can use a button and a label. When I click the button, I want to change the label. Everyone in this example seems to just hold on to the reference they got when creating the components.

I have read about MVC and so on, but that seems to me that it is even more advanced and more suitable for bigger apps.

Could you please also point me in the right direction of learning Swing - reliable source of information - (there are tons of tutorials, but not all of them seem to be of sufficient quality).

Also I am aware that I will have to learn MVC at some point to create more sophisticated GUIs. So if you could share some reliable links on that topic I would also be very grateful.

Thank you.

JButton button = new JButton();
	button.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e) {
            //runs when button is pressed

			button pressed = (JButton)e.getSourse();
		}
		
	});

you can add a actionListener to a button and then get the button instance from the Event e

JFrame f = new JFrame();
	f.setSize(500, 500);
	f.setVisible(true);
	
	JButton button = new JButton();
	button.setBounds(0, 0, 100, 100);
	f.add(button);
	
	button.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e) {
			System.out.println("pressed");
			JButton b = (JButton)e.getSource();
			b.setSize(200,200);
		}
		
	});

thats how I tested it, and it just works fine

As mentioned in the comments, an easy way of acquiring a reference to a desired component, is just to store the reference yourself. For your example where a button updates a label, you can maintain somewhere the reference to the label in your code. For example:

import java.awt.Font;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class Main {
//Utility method to create a String with random contents:
private static String randomString(final int length) {
//Create the alphabet:
String alphabet = "abcdefghijklmnopqrstuvwxyz";
alphabet += alphabet.toUpperCase();
alphabet += "0123456789";
final int alphabetLength = alphabet.length();
final Random rand = new Random();
final char[] chars = new char[length];
//Fill the random String:
for (int i = 0; i < chars.length; ++i)
chars[i] = alphabet.charAt(rand.nextInt(alphabetLength));
return new String(chars);
}
private static void createAndShowGUI() {
//Initialize a JLabel with a random text:
final JLabel label = new JLabel(randomString(10));
//Change font to MONOSPACED BOLD (of the current size):
label.setFont(new Font(Font.MONOSPACED, Font.BOLD, label.getFont().getSize()));
//Create the JButton:
final JButton button = new JButton("Click to change label text");
//See here we maintain a reference to the label in the lambda expression:
button.addActionListener(event -> label.setText(randomString(10)));
//Create a Container (JPanel is-a Container) for the button and the label:
final JPanel contents = new JPanel(); //FlowLayout by default.
contents.add(button);
contents.add(label);
final JFrame frame = new JFrame("Main");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Declares that the application will exit when we click the close icon of the frame.
frame.getContentPane().add(contents);
frame.pack(); //Adjust the size of the frame according to its contents.
frame.setLocationRelativeTo(null); //Make the frame centered in screen.
frame.setVisible(true); //Show the frame.
}
public static void main(final String[] args) {
//Always call Swing related code on the EDT. On way to achieve this is by calling invokeLater like so:
SwingUtilities.invokeLater(Main::createAndShowGUI); //Main::createAndShowGUI is just another lambda expression.
}
}

The most reliable source of information for Swing, according to my knowledge, is the official turorial of Oracle in the following link: https://docs.oracle.com/javase/tutorial/uiswing/index.html which leads to many more links of tutorials about many topics on Swing.

As for the helper methods to get a reference of a Component, Window, etc other than the current one, you can use the methods in SwingUtilities class, such as:

• getAncestorNamed: Every Component has-a name with corresponding accessor and mutator methods. As such, you can get a refernce to a Component by name.
• getRoot: When you are creating Components and adding the to Containers, and essentially Windows, you create a Component tree hierarchy. You can access the root Component of that hiearchy for any given Component via a call to this method.
• getUnwrappedParent: Every Component belonging to a tree hierarchy of Components has an ancestor (unless it is the root Component or a Component not belonging to any hierarchy yet). You can get its ancestor with this method.
• getWindowAncestor and windowForComponent: With those two equivalent methods, you can get the first Window ancestor of a Component (which in turn already belongs to a tree hierarchy of Components).

But the most common case is that you will rarely use those methods (depending on your programming style) and usually maintain a reference, to all the Components you need, in your class.

Finally there are also some common methods for accessing all Components of a Container such as getComponents which returns all the Components inside a Container (and note here JFrame is-a Window which is-a Container).

The reverse operation (ie getting the parent Container on which a Component belongs to) is performed with getParent on a Component.

Most of those methods are used after you add your Components to the tree hierarchy. For example there is not point in getting the window ancestor of a Component which is not added to any Window.