Thread: Concern about use of });

I am looking at some programs online and see that they close with

}
});
}

It looks strange to me to have

});

and not just

}

Please provide an example. I suspect there's more going on there than you've described; more than a program closing but likely a closing to a statement that included the creation of an anonymous inner class or a similar construction.

Thanks

How important is this SwingUtilities.invokeLater(...) method

Is it used often in programs or can I get by without ever using it

Thanks for posting the second bit in code or highlight tags.

The first example you posted,

    public static void main(String[] args)
    {
        //Schedule a job for the event-dispatching thread:
        //creating and showing this application's GUI.
        SwingUtilities.invokeLater( new Runnable()
        {
            public void run()
            {
                createAndShowGUI();
            }
        } );
      }

is constructing an anonymous inner class, Runnable, which requires a method run(). If you trace the construction carefully, you'll see the invokeLater() method takes a Runnable argument and the Runnable class is constructed between the open and close parentheses of invokeLater. The semi-colon is necessary at the end to end the statement that starts with SwingUtilities. . . .

Using SwingUtilities.invokeLater() runs or starts the Swing application on the Event Dispatch Thread, or EDT, and yes, it's important. There is more than one way to accomplish the same thing, but learn this way, memorize it, and use it. There are many Swing tutorials on the web that are bad examples because they don't launch their apps this way. It's wrong, it's bad, and now you know better. You can learn more about why it's important by searching and reading up on "Concurrency in Swing," and "Swing on the EDT," and similar searches.

Thanks

The whole thing seems a bit advanced to me but when I go into it further I will remember this advice

The ; just ends a statement. For examples:

frame.pack();
frame.setVisible(true);

frame.pack() has no parameters.
frame.setVisible(true) takes one parameter, a boolean, in this example, true.


SwingUtilities.invokeLater takes one parameter, a Runnable object. Rather than passing such an object in, there is one being created on the spot. This is where all of the {} come in to play.
Consider this:

SwingUtilities.invokeLater(MyRunnable);//This assumes MyRunnable implements Runnable.

Now this:

SwingUtilities.invokeLater(new Runnable() {
   });

See how the ); still ends the statement as in the above examples. The problem here is that the Runnable interface requires the implementation of a method with the signature: public void run()

Which leads to this:

SwingUtilities.invokeLater(new Runnable() {
   public void run() {
      //the statements to be executed
   }
});

So in the end it is really not a }); but the } closes off the implementation of the new Runnable, the ) closes off the end of the method invokeLater and the ; closes off the statement.

Thanks again for this comprehensive reply I will study it as soon as I get a chance

However how does MyRunnable implements Runnable. is it like a function within a function

As soon as I think it through I will probably ask the question in a different way

MyRunnable is just a theoretical class that could exist. Created to show how invokeLater(); is just another method call, just another statement, and has to end with a ;
The idea to grab is that the parameter being passed to the invokeLater method is an anonymous class defined inside the parentheses of the method, resulting in the odd looking series of });
Some reading on the subject

}
});
}

It looks strange to me to have

});

and not just

}

The others provided better answers, but here's the short version... Any time you see {, (, or [, there must be an accompanying }, ), or ] and vice-versa. Each of the first three opens some sort of element, and the last three close that element. If you open something but don't close it, or try to close something that isn't opened, the program just doesn't compile at all, full stop. And the closings have to come in the reverse order of the openings. So if you see {(, you need to close it with )}.

It's kind of like those Russian nesting dolls. If you're putting away the whole set, you need to close each and every one of them. You can't put the small and large dolls away, then forget about the medium one. Further, you can't put away the small one, then the large one, then the medium one. You have to pack them away the same way you unpacked them.