As you know, Java's been around for a while.

And the way to develop rich GUI applications with Java

has evolved quite a bit over the years.

I want to take you on a little history tour real quick,

as you will see the predecessors mentioned and referenced.

The first thing to remember is that Java is intended to be,

write once, run anywhere.

As you know, different operating systems have a different way of looking.

Now, by different, I mean the native style.

You know, like, the window is rounded or sharp.

The checkbox has depth or it doesn't.

The scroll bar is around it.

You know, stuff like that.

So, in the very beginning there was a set of tools created called

the Abstract Window Toolkit, or AWT.

What AWT provided was a way to expose a very thin layer that would actually create

a native window and add a native controls.

While this was handy, designers didn't necessarily like how the same half looked

different on different platforms.

Now in addition to the cosmetic differences,

the way that you interacted with them was a little bit different on each platform,

and therefore, some deep knowledge was needed about all of the platforms.

Now these differences, often called quirks,

is a problem that plagues web browsers to this day.

It is not fun.

So, a couple of groups started projects to attempt to fix this quirky problem and

they ended up merging together into one called the Java Foundation Classes or JFC.

These were later renamed to Swing and added to Java, since its release 1.2,

which was released in late 1998.

Swing took a different approach.

It decided to render all of its components instead of relying on native components,

like check box and input field.

This is known as lightweight UI.

Now, under the covers, it in fact is still using AWT for

capturing input like keyboard pressing and mouse movements.

But it uses its own interface completely.

Swing introduced the concept of a pluggable look and

feel, also known as skinning.

What this means was you were able to change the way that

all of the components looked at once, to a completely different look.

Now Swing had a great run, and it introduced many advanced component types,

such as tabs, trees, tables, and lists.

Swing had widespread acceptance, and

it was the de facto way to build Java GUI applications for nearly a decade.

In late 2008, a new contender came on the scene, JavaFX.

Now at first, as expected, it received mixed reviews.

The first version introduced a new scripting language called JavaFX Script.

No.

By version two, this was scrapped, and now, things are just native Java.

JavaFX has matured, and releases now follow Java's releases.

So, JavaFX8 follows JavaSE8, which was released in 2014.

And the release for Java FX9 will follow JavaSE9.

JavaFX is intended to be the GUI solution for Java, replacing Swing.

It and Swing are included in the Java SE Java Runtime edition.

Both will be around for a considerable time though, and

they interoperate well together.

For instance, you can have a JavaFX component embedded in your Swing

application, and vice versa.

JavaFX supports Swing components.

Things that you learned in JavaFX will more or less, directly translate into

other UI frameworks that you encounter, including Swing.

So with that little Java GUI history lesson in place,

let's go spend sometime getting to know JavaFX.