Well, I usually write a whole bunch of code like

public class MyClass extends JFrame {
   public MyClass () {
       JButton doItButton = new JButton();
       JPanel mainPanel = ...
       ... new BoxLayout(BoxLayout.LINE) ...
       ... BorderFactory.get...
       pack();
   }
}

...

fooFrame = new MyClass();
fooFrame.setVisible(true);

Sun's Swing tutorial at www.java.com is invaluable if you're going to
be hand-hacking the GUI, and you'll eventually find you have enormous
control over the UI, to the point of being able to extend Swing if you
need to with new Borders or LayoutManagers or whatever; no terrible
resizing behavior because of god-awful absolute hardcoded pixel
coordinates*; and yes, even maintainable source code anyone can edit
with any tool(!)...

* I don't know if the GUI builder that comes with NetBeans does
anything this evil, but I do know that an awful lot of visual GUI
design tools do, and that every last one of them produces brittle code
that can't be hand-hacked and still be read by the GUI tool. A well-
designed such tool would be available as an Eclipse plugin, use its
own source file format it can compile into a default-access helper
class of static methods to put in the same package as and call from
your GUI class, and produce UI that uses layouts rather than hard-
coded coordinate values. It would behave like yacc or bison, turning a
source file type of its own into a separate Java source file meant to
be treated as object code, and embed the Java code for your listeners
in both files the way snippets of C code occur in bison source files.
And help generate the anonymous inner class bubblepak for the
listeners. Normally you'd just call methods of your GUI classes or
other methods in your main Java sources from them, and it would let
you supply any expressions that evaluate to listener objects.

There are a number of available plugins for Eclipse that have point-
and-click GUI editing (Such as Jigloo http://www.eclipse-plugins.info/eclipse/plugin_details.jsp?id=472
), but for simpler programs the amount of hand-coding is fairly
trivial. You're going to want direct control over the source either
way, though, so make sure that any tool you use for layouts doesn't
close the hood on it.

And to give you a more pointed reference to the tutorial Twisted
mentioned: http://java.sun.com/docs/books/tutorial/uiswing/

HTH,
Andrew

To compare NetBeans and Eclipse for GUI development you need to add
the VEP plugin <http://www.eclipse.org/vep> to Eclipse. This makes
Eclipse almost as capable NetBeans was _before_ the Matisse GUI
development environment was included in NetBeans 5.0.

However, it is unfair to compare the IDEs only on the capabilities of
their GUI designers and I have never seen anybody advocate Eclipse
over NetBeans in that respect.

Yes.

Manifold.

By typing code into the editor.

I came to Java from Delphi, so I'm used to using a GUI form-designer but
 I don't really miss it when writing Java.

As others have pointed out, there are several GUI forms-designers that
can be plugged into Eclipse.