This intensive, three-day module is a comprehensive mini-course on JavaBeans. Topics include: how the builder tool generates a meaningful GUI to interact with the bean; publishing a bean's interface (methods, properties and events); bean serialization; building property editors and customizers; creating indexed, bound and constrained properties. Complex issues regarding multi-threading are discussed.

From start to finish you will create several robust and complete beans. Using a builder tool you will also create an application that utilizes your beans. You will learn all the "ins" and "outs" of developing beans. You will also learn several time-saving tips that will help you get your beans "up and running" quickly. When you have completed this course, you will be ready to design and develop commercial, robust JavaBean components.

Why is this workshop important?

A bean is a Java software component that can be manipulated in a visual programming environment (much like VBX or OCX/ActiveX components can be manipulated in visual builder tool such as Visual Basic, Powerbuilder, or Visual C++). Using a builder tool that supports JavaBeans, application developers can instantiate beans from a component palette and integrate them together into an application by visually manipulating the bean's properties and events. By packaging your component as a bean, your component is far easier to use because it can be programmed visually (in addition to being programmed manually).

• Build a bean from start to finish that contains properties (bound, constrained and indexed), custom events, custom property editors and a customizer.
• Use the Event Delegation Model to handle events with the AWT and Swing components. Employ inner classes as event listeners.
• Know when (and how) to use default serialization. Know when (and how) to full take control over the Serialization of your component.
• Use the Jar utility to bundle your bean. Know how the manifest file is used by the builder tool.
• Use the fundamental classes in the Reflection API.
• Understand how the Introspector uses Reflection and "design patterns" to implicitly publish the interface (methods, properties and events) of a bean.
  • Override implicit publishing by employing the BeanInfo interface, SimpleBeanInfo class, and a collection of FeatureDescriptor classes.
• Make your bean generate custom events.
  • Know when to use standard events versus custom events.
  • Be able to design custom events classes.
  • Manage the registration (and removal) of Listeners .
  • Deliver events synchronously or asynchronously.
• Build robust beans that will work in a complex multithreaded environment.

Specifications

• Duration (total): 3 days
• Duration of Exercises: 1.5 days
• Duration of Lecture: 1.5 days

Pre-requisites

If you are building a custom course, you will need to cover these topics before this topic can be presented:

• Inner Classes
• Event Delegation Model
• Serialization

• Working knowledge of how to create a GUI with events.
• Basic Java knowledge is assumed, including exception handling, threads, full use of all the language constructs, and familiarity with the core Java 1.1 APIs.
• Those without these pre-requisites should consider one of our Ultimate Java Programming Workshops.

A table of contents of this module is available upon request.

Return to the Custom Order Page.

Copyright ©2007 by Petronio Technology Group, Inc. All rights reserved. Petronio, "Targeted Technology Training", "T3" and "Turning new technologies into your competitive advantage" are trademarks of Petronio Technology Group. All other trademarks are the properties of their respective companies.