Description

What does this workshop cover?
Why is this workshop important?
What will I learn?
Who should attend?
What is a targeted needs assessment?

What does this workshop cover?

This intensive, four-day, hands-on programming workshop, is a comprehensive course on JavaBeans. Topics include: inner classes and the 1.1 Event Delegation Model; 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).

What will I learn?

At the end of this course, you will be able to:

• Build a bean from start to finish that contains properties (bound, constrained and indexed), custom events, custom property editors and a customizer.
• Use the 1.1 Event Delegation Model to handle events with the AWT 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.

Who should attend?

• Java developers who need to create beans or to write a bean-aware utility

Basic Java programming experience is required. Attendees must already understand Java 1.1 programming (language, basic packages, threads, Layout and AWT). Attendees not meeting this prerequisite should consider one of our Ultimate Java Programming Series (for C++ Developers, for C Developers), or for Non-C Developers .)

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.