Introduction

Since the Study Guide is broken into four main categories, we will do the same. The summary will also provide information about the Borland Partnership Programs at the date of this writing.

The following list provides quick links to each section that follows:

• JBuilder 3 Technical Resources
• General Knowledge
• Certification Program and Benefits
• Summary
• About the Author

JBuilder 3 Technical Resources

There are also many books available about JBuilder, but my recommendation is that you start with a solid foundation in Java, take the official course, and then browse through the JBuilder manuals for anything else you might have missed. The course covers most of what you need. If you would like resources on Java, consider the following:

• The Java Developer's Connection
• The Java Developer's Journal
• The JBuilder Developer's Journal
• The Java Report
• JavaWorld (web-zine)
• ServletCentral

(back to intro)

General Knowledge

Section 1: Java Virtual Machine

One of the features that makes Java portable is its treatment of primitive types. Whereas most languages define primitives types in terms of the native CPU size, Java defines all primitives to be the same, regardless of deployment platform. That means that an integer in Java (represented by the int type) is 32 bits, whether the native operating system is 32 bits or 64 bits. The results is that files written from Java on one OS should be readable into Java on a different OS without concern for formatting. (You should also learn the primitive types, but that is part of section 3.)

Also important to the production use of Java is the advent of the JIT compiler. A JIT compiler is a Java Virtual Machine that loads and interprets Java byte codes just as any other virtual machine. However, the JIT compiler caches the resulting machine code for quicker execution at a later time, rather than working in a strictly interpretive mode. Recently, JIT compilers have appeared that use predictive algorithms to look ahead of your process and compile Java byte code before you need it, enhancing performance even more. (Sun's HotSpot Performance Engine is an example of such a machine.)

Section 2: Java Development Kit

Deprecation is an unrelated term that refers to methods and classes in a previous version of the JDK which were replaced by newer substitutes in the current version. Again, it is a compiler option that generates warnings whenever deprecated methods are used in your code. It is a good idea, in general, to remove references to deprecated methods in favor of their newer alternatives, since deprecated methods may be completely removed from a subsequent JDK release.

Often, a deprecated method is replaced by more than one method, or by an entire collaboration of classes, so replacing the method call may not be trivial. In other cases, methods are deprecated without a suggested alternative. Such is the case with the stop method and other related methods of the Thread class. Explicitly stopping a Thread can be dangerous and lead to deadlocks because the Thread does not have a chance to release its resources or other locks before termination. During the tutorial, you will get an alternative pattern you can use. If you wish, here is some space to take notes:
 

You are welcome.

Another feature of the JDK is its support for Unicode characters. Unicode characters are 16 bits, rather than the typical ASCII character set which is 8 bits. (ASCII is also called Latin-1, or ISO 8850-1, and is also a standard.) As a larger character format, Unicode supports 65,535 characters, providing Java international language capabilities. All characters manipulated within the JVM are in Unicode, and Java provides methods for reading and writing Unicode text files. Most ASCII manipulation is not affected by Unicode, since the printing ASCII characters map directly to Unicode equivalents.

Finally in this section, we have to talk about Java Servlets. A topic in itself, servlets are one of the current rages of Java programming today. Servlets allow us to extend the functionality of our web servers, returning any HTTP response given any HTTP request. Servlets are not required to communicate via HTML, and extensive web applications can be constructed using servlets as a mechanism to tie web clients into your internal Java distributed object bus (if available).

To write a servlet, you typically override a method called doGet or doPost, or both, depending on what your servlet intends to do. For more general servlet requests, you can always override the default service method instead. Typically, the web server calls the service method, which checks the type of the request, and either calls doGet or doPost. Most servlet methods take an HTTPRequest and HTTPResponse object as parameters, which they use to communicate with the web server to handle the request.

Section 3: Java Language

Basics

Packages and the import Declaration

When writing code for a class in package p1, you may need to reference a class defined in package p2. By placing an import declaration at the top of your source code file similar to:

import p1.*;

- or -

import p1.ClassName;

In the event that an import statement results in an ambiguity to the compiler, you will have to use the fully qualified class name to refer to either class in question. For example, the following code is ambiguous and will not compile as-is:

1:  import org.omg.CORBA.*;
2:  public class C {
3:    ...
4:    public Object f() {
5:      ...
6:      return null;
7:    }
8:  }

Overloading Methods

Reference Semantics

Consider the following declarations:

Object o1, o2;

The JVM implements a garbage collector as a low priority thread that scans for unused objects that have been allocated-- that is, those objects with no current references. When an object has no current references, the garbage collector will attempt to restore the memory allocated to the object to the heap.

Of particular interest is the methods available in Java to compare references. The equality operator is normally applied to primitive types as follows: (x == y) is true if and only if x and y have the same value. For reference types, (x == y) is true if and only if x and y refer to the same object on the heap. In pointer parlance, you might say that x and y point to the same address in memory.

Many times we are more concerned whether the objects that x and y refer to are equivalent (they are the same, member for member). In that case, we use the equals method found in every Java object: (x.equals(y)) is true if the object y refers to is equivalent in value to the object x refers to. Note that x.equals(y) does not imply y.equals(x): the Java programmer can define in their equals method what it means for another object to be equivalent. By default, the equals method does a member-for-member comparison using the == operator.

Incidentally, it is strongly recommended that if two objects references are ==, they should always be equals as well. Again, this is not required, but don't think too long about it... it should always hold true.

Object-Oriented Features

Abstraction and Encapsulation

Java classes also have visibility modifiers: a class may be either public or not (as before, no modifier implies package-level visibility). For any public class, the Java compiler requires that its source code file have the same name as the class. This implies that there can be only one public class per Java source file. There is no limitation of this sort for non-public classes.

Go ahead and cover the table above, then try this quiz:

Given the following diagram:

a) What is the visibility of class A?  ________________
b) Which of class A's members is visible to each of the following classes?
 

	A	A1	A2	B	C
private
(package-level)
protected
public

So if an object hides its data inside and provides only valid methods for manipulating that data, how do we make sure the internal data start out in a valid state? We write one or more constructors that tell the object how to initialize!

A Java constructor always has the following attributes:

1. A constructor looks like a function, including visibility modifiers, but
2. It must have the exact same name as the class (remember case sensitivity), and
3. It cannot return any type, not even void!

JTextField jtfLastName = new JTextField(<parameters>);

If you do not provide a constructor for a particular class, a default constructor is provided that:

1. Takes no parameters, and
2. Calls the parameterless constructor of its inherited class

Implementation Inheritance

A Java class may inherit from only one other class (this is called single inheritance), and all classes in Java ultimately inherit from a common general (base) class, java.lang.Object. By relating all classes in Java to one common ancestor, the Object class provides application-wide utility functions that are available to all Java objects. We already discussed the equals method in our section on reference semantics, but Object also contains methods like toString, clone, and others.

When a class like HomePolicy inherits functionality from a Policy class, it may be necessary to modify the inherited behavior. This modification is facilitated by overriding the inherited functionality-- writing a new implementation for the method, with exactly the same parameter list and return type. Overriding a method provides enables polymorphism, which is discussed in the next section.

There are times when you know how to override a method, but you have more difficulty with the general implementation than the specific. For example, the getPremium method of a HomePolicy might be expressed in terms of house location, building materials, flood zones, dead-bolt locks, etc. But if HomePolicy inherits the method from the Policy class, how would you implement getPremium in the Policy class?

This problem provides two original options you might choose think of:

1. Remove getPremium from the Policy class-- Unfortunately, then, it is no longer true that all policies have a getPremium method. If a new BoatPolicy class were created and the developer of the class neglected to include getPremium, you would have no way to retrieve the premium on a BoatPolicy.
2. Provide a default implementation in Policy that generates an exception-- In this case, all policies have a premium, and if a developer forgets to override the method, it will generate an error. However, code that uses any policy type will have to catch the error, in case it occurs.

Any class that has at least one abstract method must be declared abstract as well. Furthermore, the Java compiler does not let you use the new operator on any abstract class. This implies that to create an instance of a BoatPolicy, the developer must implement the getPremium method.

While the term abstract implies that you have to create a subclass before creating an instance, the term final implies that a class may not be subclassed. The final keyword is used throughout the JDK in places where Sun does not intend you to create new subclasses that might override expected or required functionality. For example, the String class is a final class: you cannot extend the class to override any of its methods.

Just as a class can be marked final, individual methods may also be marked final. In that case, the class can be extended, but its final methods may not be overridden.

Polymorphism

public void getPortfolioTotalCost(Policy[] portfolio) {
  double total = 0;
  for (int i = 0; i < portfolio.length; i++)
    total += portfolio[i].getPremium();
  return total;
}

Now in real-life, if you have a collection of insurance policies, you might refer to them general as a portfolio. But if you thumb through each one, totaling their premium, you expect that looking at each policy, you will get its exact premium, and not some general default. Polymorphism allows us to simulate the same effect in software.

You see every object reference in Java has two types: its perceived type at compile-time, and its actual type at runtime. Our function would not compile the call to getPremium if all policies did not have this method. However, the actual behavior of the method call is not determined until this code actually executes with some real portfolio of specific policy types. By our own definition, we have written code that deals with a general class (Policy) and used polymorphism to get specific behavior out of each specific policy type.
 

Since the compiler prevents us from accessing specific methods and data that are not defined at the general level, is there any way to access that information after placing a specific object into a generic reference? In Java, we can always test the runtime type of an object using the instanceof operator. Then you can typecast to extract your specific information as follows:

if (portfolio[i] instanceof HomePolicy) {
  HomePolicy homePolicy = (HomePolicy)portfolios[i];
  riskManager.assessRisk(homePolicy.getOutstandingLiens());
}

Interface Inheritance

Java defines a type, similar to a class, called an interface. This interface specifies a collection of function signatures, which are implicitly public and abstract. (Optionally, any variables declared in an interface are implicitly public, static and final.) A class that implements the interface must provide code for each of the functions it declares, or the class is also abstract and cannot be instantiated.

Using interfaces allows you to define new types in Java, whose instances do not have to be related through inheritance. In essence, any object that implements a given interface is substitutable for any other object that implements the same interface. This gives us the benefits of polymorphism, without tying us into a rigid hierarchical inheritance structure.

The Java language allows a class to inherit its implementation from only one other class, although a class can implement as many interfaces as necessary. In this sense, Java support single implementation inheritance, but multiple interface inheritance.

Special Considerations

Static Members

class MyClass {
  public static int i;
}

Similarly, a static function also belongs to its class, and can be referenced from any instance or from the class itself. A function declared static cannot reference the implicit this variable or any instance variables, since it may have been invoked on the class. These types of functions are useful to implement certain important object oriented design patterns, to bootstrap an application, or to write the Java equivalent of library (utility) functions.

Strings

Strings are immutable in Java, meaning that you cannot change their value after creation. In the following example...

String s1 = "Hello";
String s2 = "World";
s1 += s2;

This is especially significant when you wish to compare two strings. Keep in mind that String references are object references, not primitive types. Using the == operator checks whether two references refer to the same String object, while the equals method compares whether two strings have equals values. Strings also provide several useful utility method, including equalsIgnoreCase, which compares the strings in a case insensitive way.

Inner Classes

An inner class is simply a class defined within another class. The benefits of inner classes may be elusive at first, especially when you consider that some inner classes are not visible outside a localized scope. This usually implies that inner classes are not as reusable, which leads many developers away from using them.

Inner classes perform a vital role in solid Java development, however. Inner classes preserve encapsulation by providing the class access to the private variables of its containing class. There are some who feel that this violates encapsulation, since another class has access to internal state, but remember that the entire inner class is also part of the internals of the object!

Your alternative using standard classes is to pass Object references to these external objects, through which callbacks provide access to state, either as non-private instance data, or through mutator functions that must be made available not only to the external class, but also must be available to the entire package. Inner classes let you keep your data, and even many of your functions, private from the perspective of the outside world.

Of the inner class types, you can define simple inner classes within other classes. You can also define local classes, which are classes defined in the scope of a particular method, and have the added advantage of accessing local data and parameters declared final. Lastly, you can define anonymous inner classes, which are local classes that are declared and instantiated on-the-fly, without assigning a class name. These classes are most often used for event handler adapters in GUI development.

Section 4: Applets

Sections 5 - 7: Using JBuilder

The IDE

• The AppBrowser refers to that portion of the JBuilder environment under the main menubar and toolbars. It is divided into the Navigation Pane, the Structure Pane and the Content Pane.
• Use the Tool Options... menu item in JBuilder's Tools menu, as shown in the image to the left.
• To switch JDK's in JBuilder 35, you first have to define the target JDK you wish to switch to. From the Project Properties dialog, select the Paths tab, and click the "Set..." button next to the JDK version text field. This will bring up the option to select your target JDK, or you can click New to define a new target version. Locate the home directory of the new JDK version, and select OK a few times to create the new target and associate it with your project. The version of the JDK you wish to use may impact debugging and deployment, so you will have to keep this in mind.
• In JBuilder 35, all standard output goes to a tab in the message area of the UI, the execution log is gone.
• CodeInsight provides information about the methods callable from a specified object and the overridden parameter sets to those methods, in addition to information about syntax errors as you type.
• The Object Inspector provides information when in the GUI designer about the selected JavaBeans properties and events.
• To set menu shortcuts, set the mnemonic property to the character that you wish to use to invoke the menu item. To specify a menu accelerator, set the accelerator property to an instance of KeyStroke you have created within the container class.
• JBuilder 35 libraries associate a portion of your runtime classpath with an alias name that describes the main API's the classpath represents.
• JBuilder has a compiler option to "make packages stable", which instructs the compiler to build all files in a package, and mark the package "stable". By default, JBuilder will check whether a stable package has changed when determining what to compile on subsequent builds, saving compile time.
• JBuilder ships with the following command-line tools:

JBuilder Command Line Tools

CD Image	Tool	Purpose
Borland JBuilder 3.5	java, javaw, javac, javap, javah, javadoc, jarsigner, keytool, jdb, appletviewer, rmic, rmiregistry, etc.	JDK tools
	DataStore Explorer	Browsing and querying the all-Java DataStore
Borland AppServer	gatekeeper, osagent, oad, oadutil, vregedit, printIOR, osfind	VisiBroker for Java command line tools

Configuration

• The batch file setvars.bat initializes the command line environment to a similar configuration that JBuilder executes in (specifically the PATH and CLASSPATH environment variables).
• To make a Java library available to JBuilder designers, you have to add a line to the JBuilder.config file similar to:

addjars c:myjars, which tells JBuilder on startup to includes all jar files in that directory in its classpath.
• JBuilder projects are defined in files with a JPR extension.
• The following configuration files are provided for customizing the JBuilder environment:

JBuilder Configuration Files

File Name	Location	Purpose
Column.properties	user profile directory	Stores the default properties for creating database column objects of different specified types
Default.jpr	user profile directory	Stores the configuration properties used by JBuilder to create new projects
library.properties	user profile directory	Stores the definitions of add-on Java libraries for use in JBuilder projects
palette.ini	user profile directory	The configuration of the GUI component palette
propertyEditors.properties	user profile directory	Stores the association of JBuilder types to their GUI property editors
tools.cfg	user profile directory	Specifies the customized options in your tools menu and how to spawn them
user.properties	user profile directory	User-customized settings as modified by the options in the Tools|IDE Options... menu
JBuilder.config	JBuilder binary directory	Establishes the JVM and classpath used by the JBuilder IDE, dynamically includes jdk.config
jdk.config	JBuilder binary directory	Defines the core JVM used by the JBuilder environment
jdbce.config	JBuilder binary directory	Configuration for the JDBC Explorer
dss.config	JBuilder binary directory	Configuration for DataStore Server
dse.config	JBuilder binary directory	Configuration for DataStore Explorer

Keyboard Shortcuts in the Default Keymapping

• Within the source code, you can explore any class or interface by placing the cursor on the type, or an instance of the type, and pressing CTRL+ENTER. As an alternative, you can also right-click the identifier and select "Browse Symbol" from the context menu.
• JBuilder 35 does not allow record and playback of simple macros. Instead, set up named macros using Tools|IDE Options|Code Templates. Specify a short name and a description for your template, then type the template into the dialog space provided. To activate the template, type its short name into the source code editor, and press CTRL+j.
• The source code editor provides shortcuts for creating bookmarks for quick navigation. You can have up to ten per file. To set a bookmark, place your cursor in the desired place, then press CTRL+SHIFT+<a number>. From any other place in the file, you can navigate to your bookmark using just CTRL+<the number>.
• There is also a shortcut for finding matching delimiters '(', ')', '[', ']', '{', and '}', even with comments and strings. Simply press the ALT key and the left or right square bracket when your cursor is on one delimiter, and it will jump to the matching delimiter.
• To make a quick clone of a GUI component or a selection, press the CTRL key while dragging. To nudge a component one pixel in any direction, hold the CTRL key when selecting the component(s) and press the arrow key corresponding to the direction you wish to move.

JDBC & SQL

• A SQL statement may be parameterized using question marks (?) to denote its parameters. Using JDBC, parameterized queries are created using a PreparedStatement. In DataExpress, a normal QueryDataSet will do, but you have to specify parameter values using another ReadWriteRow that you supply.
• JDBC drivers are vendor implementations of the java.sql.Driver interface that implement connection capabilities to one or more databases. There are four levels or types of JDBC drivers, and they differ based on their architecture and network protocol. Of the different types available, type 3 and type 4 drivers provide an all-Java client speaking over the open network. These drivers are considered portable and deployable with a Java application, as opposed to types 1 and 2, which require client configuration.

Data Express

DataExpress is the database architecture for quickly building database applications in JBuilder. As a thin layer over JDBC, DataExpress provides facilities for filtering, sorting and searching through resultsets that may be cached locally in memory, persisted on disk, or distributed as a serializable Java object. A class hierarchy of the main DataExpress classes is shown in the graphic to the right. The following key points address questions asked in the Study Guide about DataExpress:

• Among the usability features of DataExpress, there are several methods for navigating through records, including first, next, prior, last, and locate. While navigating, you may also make use of atFirst, atLast, and inBounds.
• When DataExpress is used, GUI components can be linked directly to a dataset through their dataset property, if available, or you can use any of a set of predefined models and "binders" to associate DataExpress data with third party or standard java components that are not otherwise "data aware".
• Components that may be directly linked to DataExpress data have icons with small gray grids in their backgrounds. Those that manipulate only a single column of the dataset have a columnName property.
• DataExpress includes a Java interface called DataModule, which allows developers to use the JBuilder visual designers for non-visual components. As a tag interface (one with no method requirements), any class could implement DataModule.
• A master-detail relationship is established to represent a one to many relationship in the resultset cache in which the values on the many side are trimmed to just those corresponding to values on the one side. To establish the master-detail relationship property, set the masterlink property of the detail dataset.
• Certain master-detail relationships can be set up to use "delayed fetching". Setting this property instructs the detail dataset to fetch records only when required to support the relationship with the master dataset.
• By default, storage datasets persist their data to a block of physical memory. You can redirect this storage to a JDataStore to persist the data to your file system instead. Using JDataStore results in a slight degradation of performance for small datasets, but tends to be faster and require less memory when working with larger datasets.

JavaBeans

• BeansExpress is a series of editors that provide easy-to-use features to write beans conforming to the JavaBeans specification.
• Within BeansExpress, you can define properties, event sets, editors and customization information for a JavaBean you are writing.
• JavaBeans properties are implemented by optional accessor and mutator methods, often called "getters" and "setters". Properties may also be "bound" or "constrained", which signifies that changes and attempts to change to property values will fire events, allowing external notification and validation, respectively.
• JBuilder is able to determine the properties and events of a JavaBean using introspection of the class members. Introspection provide meta-information about the member of a class, and if the class compiles with JavaBeans standards, a GUI builder tool can interpret which methods correspond to properties, providing the appropriate property editors.
• There are times when the bean itself is not enough to correctly manipulate properties in JBuilder. In some cases, you will associate a BeanInfo class with your bean that more comprehensively describes its features. A BeanInfo class may specify customized property editors for your bean, bitmaps for use in JBuilder's component palette, tooltip text for each property and event handler method, method descriptions, etc.
• Property editors provide GUI developers assistance in setting property values, by representing those values in English terms, by using visual metaphors like lists, dialogs or colors, or any other information related to the property.
• Using JBuilder, you can also create Enterprise JavaBeans. The types available include both session and entity bean types.

Certification Program and Benefits

• Systems Integration Companies
• Technical Education Centers
• Tool and Component Developers and Development Companies
• Technical Instructors
• Individual Developers

Developer Certification

After successful completion of the exam, you will be Borland Product Certified. You will receive an official plaque and be granted the use of a logo as evidence of your qualifications to show to employers and customers. Your certification positions you to meet increasing customer demands for qualified service providers and sets you apart from other developers in your field. Certification also verifies the specific knowledge and skill you brings to a job, and the credential becomes increasingly important as skill demands for IT professionals change rapidly.

There are also benefits to your organization, which can effectively distinguish who has the skills needed for particular technical jobs and more efficiently recruit, train, and deploy technical staff.

Instructor Certification

In addition to passing the Borland Product Certification exam for JBuilder, it is the responsibility of prospective certified instructors to be sure they meet the following prerequisites:

• A working knowledge of Java
• A working knowledge of another database programming platform (e.g. Visual Basic, PowerBuilder)
• Development experience for one of the following SQL database servers:

InterBase 4.x/5.x, Microsoft SQL Server, Sybase, Oracle, Informix, or an ODBC-supported server.
• Recommended reading: Java in a Nutshell, David Flanagan, O'Reilly Press, 2nd Edition, ISBN#1-56592-262-X, Chapters 1-10

It is recommended, though not required, that an instructor attend the applicable product Foundations class before attending a Train-the-Trainer class. By taking the class at least once, it is hoped that prospective instructors learn more about the scope and flow of the class, as well as trouble areas and points of confusion for real students.

Finally, all certified instructors must sign a contractual agreement with Borland which details the responsibilities of both parties. Their employer must also complete and Authorized Education Center application before open enrollment classes may begin.

Benefits of the ESP Program

Summary

JBuilder certification, especially as an instructor, is a privilege and an honor, rewarding an individual time-and-again with esteem from peers and pupils alike. The Borland certified community is a high-profile assembly of developers and technology evangelists, a close network of business professionals who interact to increase visibility, knowledge and opportunity for their companies. Some travel around the world teaching and mentoring, others have authored popular technical resources, and still more are executives and founders of startup and mid-size training and consulting organizations.

To close, let me just add that I hope today is the day that you join our ranks. Speaking for the certified development community, I believe that I can safely say, we would love to add another to our ranks and to take the opportunity to leverage your knowledge and experiences as our community grows in support of Borland development tools and platforms.

(back to intro)

About the Author

Paper originally presented at the 11th Annual Borland Conference, July 2000.