that true should be a parametric value which developers can set to true or false. Why forcing it to true???
I’m really disappointed :(

In the code above I defined a basic class called Monster, which is available under the package (namespace) com.jsmonstersbattle.monsters, declared using goog.provide(), then I created a constructor (by using the special jsDoc notation /** @constructor */) which receives three arguments and sets three private Monster’s variable (/** @private */), finally I defined a method attack which returns a number of damage points. Ok, by following the Monster’s example, we can now create as many classes and packages as we like, interfaces (using /** @interface */ and /** @impements */) and subcalsses (using the method goog.inherits()), let’s see briefly these implementation:

Extending a class:

Creating and implementing an interface:

Once we created all the necessary classes, we will put our “com” folder under “closure” folder. Then we will create a main js file which will includes all the code required to initialize and run the application, I called it “application.js” for convenience. This file will requires all the classes it needs by using goog.require():

After the import we will be able to use the classes, by referring them with the full qualified class name (“com.jsmonstersbattle.monsters.EvilMonster”), however since this means to write long strings, we can create references as the following:

or use the JavaScript with operator:

…and this is all today, I hope you enjoyed my post ;^)

UPDATE:
Don’t use the with operator nor take reference to fully qualified class name, otherwise you will get several errors if you use advanced compilation!

The build.xml above will first gathering all the necessary Closure files (dependencies) and then will compile the resulting js using a WHITESPACE_ONLY compilation. The result will be printed to the file “ant-generation.js” and the debug to “closure-compiler.log”.
To run the Ant process: right click on the build.xml and choose Run as Ant Build. This procedure can be also configured in order to execute all the task each time a file in the project is saved, but it’s not a great idea because the process can takes several seconds to complete.
If you want to learn more about Ant (I have to learn a lot too, since I never used it before :P), check the reference here: http://ant.apache.org

The code above, will do the following: 1. import the base library into the page, 2. dynamically load a series of additional js files which will be used to create and handle tabs components and events. Theoretically we could write more goog.require() statements, but they will be unnecessary because goog.ui.TabPane.TabPage, is able to require all files it needs, that is all the classes it uses internally (such goog.events, goog.dom and so on).
Ok, now that we have all the necessary files, let’s see how to do. There are fundamentally three ways to create ui components with Closure, one is totally code based, we can create components by writing all things in javascript, we can instead create a semantic HTML structure and then “convert” it to a ui component and finally we can mix things and create both components from HTML elements than from the scratch via javascript (in my example I will show this). To use an existent markup as the base for tabs component, we need a container (typically a div) containing a series of subelement (div works better here too) which contain respectively 2 or more subelements among which the first will represents the tab label and the others tab’s content. In practice the logic structure will be something like:

…and the HTML will be:

As you can see, the type of the tag doesn’t matter, what matters is the logic structure created.
Now, is possible to create a TabPane components by writing a single line of javascript:

With the code above we create a new instance of a TabPane component, which will be rendered using the “rules” of the given dom element (goog.dom.$() is the same as document.getElementById())
Is really so simple? Yes, but honestly is not so useful to haven’t a reference to the component, because we can’t handle events nor add extra elements, moreover our tabs will be display as an ugly pointed list rather than a cool tabs series. In fact Closure doesn’t apply a style to the ui components, but it simply handle the toggle of tabs by setting the containers with display “none” where necessary and making tabs dispatching certain events. Hey… this sucks! Wait! Closure, adds a series of CSS classes to the HTML nodes and the library provides several CSS (disseminated among the thousands of files) to give components a style (although the default theme is pretty ugly and you will feel the need to write your own stylesheet).
Ok, let’s see some concrete features and some more code, in order to: add a new tab and its relative content, get specific tab, enable/disable a tab, listen to tab selection/change.
First of all, let’s take a reference to the TabPane object:

Then, we can use its methods and we are able to select an arbitrary tab (the default behavior is to show the first)… let’s select the second:

Closure consider a page (an object of type ui.TabPane.TabPage) the content related to a tab. The method setSelectedPage() takes as first argument an object of that type and we pass it by using getPage(), which instead returns the TabPage for a given index.
To add a new page (aka a new tab and its related content) we will use the method addPage in the following way:

The code is pretty clear, goog.ui.TabPane.TabPage takes a dom node and a label as the first arguments.
Ok, let’s say we would like to disable the previous added page… it’s easy:

We can use its index to retrieve it and then call setEnabled()… of course if we create a reference to the page we can avoid getPage() method and enable the tab directly.
Let’s play a little with event handling, in order to toggle the status of a page (enabled/disabled). We can add a new HTML node:

and then:

goog.events.listen takes three fundamental arguments: the dom node to observe, the event name and a callback function.

…and this is the end! (at the moment)… if you like this post, add my blog to your bookmarks, because I just begin to dig and write about Google Closure! ;^)