back to CUSTOMER—you cannot record a call for a customer who does not already have a record in
CUSTOMER. A single nonkey attribute, Call_Date, is created within the CUSTOMER_CALL table.
create table CUSTOMER_CALL
(Customer_ID NUMBER,
Call_Number NUMBER,
Call_Date DATE,
constraint CUSTOMER_CALL_PK
primary key (Customer_ID, Call_Number),
constraint CUSTOMER_CALL_FK foreign key (Customer_ID)
references CUSTOMER(Customer_ID));
For example, you could have the following CUSTOMER and CUSTOMER_CALL entries:
insert into CUSTOMER values
(123,'SIGMUND','47 HAFFNER RD','LEWISTON','NJ',22222);
insert into CUSTOMER values
(234,'EVELYN','555 HIGH ST','LOWLANDS PARK','NE',33333);
insert into CUSTOMER_CALL values
(123,1,TRUNC(SysDate)-1);
insert into CUSTOMER_CALL values
(123,2,TRUNC(SysDate));
The foreign key from CUSTOMER_CALL to CUSTOMER defines the relationship between the
tables. From an OOP point of view, the records in CUSTOMER_CALL reference the records in
CUSTOMER. Therefore, we must find a way to assign OID values to the records in CUSTOMER
and generate references in CUSTOMER_CALL.
How to Generate OIDs
First, use an object view to assign OIDs to the records in CUSTOMER. Remember that OIDs are
assigned to records in an object table—and an object table, in turn, is based on an abstract datatype.
Therefore, we first need to create an abstract datatype that has the same structure as the CUSTOMER
table:
create or replace type CUSTOMER_TY as object
(Customer_ID NUMBER,
Name VARCHAR2(25),

Street VARCHAR2(50),
City VARCHAR2(25),
State CHAR(2),
Zip NUMBER);
/
Now, create an object view based on the CUSTOMER_TY type, while assigning OID values
to the records in CUSTOMER:
create or replace view CUSTOMER_OV of CUSTOMER_TY
with object identifier (Customer_ID) as
658
Part V: Object-Relational Databases
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:658
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:25 PM
Color profile: Generic CMYK printer profile
Composite Default screen
select Customer_ID, Name, Street, City, State, Zip
from CUSTOMER;
The first part of this create view command gives the view its name (CUSTOMER_OV) and tells
Oracle that the view’s structure is based on the CUSTOMER_TY datatype:
create or replace view CUSTOMER_OV of CUSTOMER_TY
The next part of the create view command tells the database how to construct OID values for
the rows in CUSTOMER. The with object identifier clause is followed by the column to use for the
OID—in this case, the Customer_ID value. This will allow you to address the rows within the
CUSTOMER table as if they were referenceable row objects within an object table.
with object identifier (Customer_ID) as
The final part of the create view command gives the query on which the view’s data access
will be based. The columns in the query must match the columns in the view’s base datatype.
select Customer_ID, Name, Street, City, State, Zip

from CUSTOMER;
The rows of CUSTOMER are now accessible as row objects via the CUSTOMER_OV view.
The OID values generated for the CUSTOMER_OV rows are called
pkOID
s, because they are
based on CUSTOMER’s primary key values. Relational tables can be accessed as row objects if
you create object views for them.
How to Generate References
The rows of CUSTOMER_CALL reference rows in CUSTOMER. From a relational perspective, the
relationship is determined by the foreign key pointing from the CUSTOMER_CALL.Customer_ID
column to the CUSTOMER.Customer_ID column. Now that the CUSTOMER_OV object view has
been created, and the rows in CUSTOMER can be accessed via OIDs, you need to create reference
values in CUSTOMER_CALL that reference CUSTOMER. Once the REFs are in place, you will be
able to use the DEREF function (shown earlier in this chapter) to access the CUSTOMER data from
within CUSTOMER_CALL.
The create view command for the object view of CUSTOMER_CALL is shown in the following
listing. It uses a new function, MAKE_REF, which is described following the listing.
create view CUSTOMER_CALL_OV as
select MAKE_REF(CUSTOMER_OV, Customer_ID) Customer_ID,
Call_Number,
Call_Date
from CUSTOMER_CALL;
With the exception of the MAKE_REF operation, this create view command looks like a normal
create view command. The MAKE_REF operation is shown in this line:
select MAKE_REF(CUSTOMER_OV, Customer_ID) Customer_ID,
Chapter 36: Advanced Object-Oriented Concepts
659
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:659
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp

Friday, August 13, 2004 1:51:26 PM
Color profile: Generic CMYK printer profile
Composite Default screen
The MAKE_REF function takes as arguments the name of the object view being referenced
and the name of the column (or columns) that form the foreign key in the local table. In this case,
the Customer_ID column of the CUSTOMER_CALL table references the column that is used as the
basis of OID generation in the CUSTOMER_OV object view. Therefore, two parameters are passed
to MAKE_REF: CUSTOMER_OV and Customer_ID. The result of the MAKE_REF operation is given
the column alias Customer_ID. Since this command creates a view, the result of an operation must
be given a column alias.
What does MAKE_REF do? It creates references (called
pkREF
s, since they are based on primary
keys) from the CUSTOMER_CALL_OV view to the CUSTOMER_OV view. You can now query
the two views as if CUSTOMER_OV were an object table and CUSTOMER_CALL_OV were a
table that contains a REF datatype that references CUSTOMER_OV.
Querying the Object Views
The queries of the object views with REFs mirror the structure of the queries of table REFs. You
use the DEREF function to select the value of the referenced data, as shown earlier in this chapter.
Applied to the object views, the query will be
select DEREF(CCOV.Customer_ID)
from CUSTOMER_CALL_OV CCOV
where Call_Date = TRUNC(SysDate);
DEREF(CCOV.CUSTOMER_ID)(CUSTOMER_ID, NAME, STREET, CITY, STATE,ZIP)

CUSTOMER_TY(123, 'SIGMUND', '47 HAFFNER RD', 'LEWISTON','NJ',22222)
The query found the record in CUSTOMER_CALL for which the Call_Date value was the current
system date. It then took the Customer_ID value from that record and evaluated its reference. That
Customer_ID value, from the MAKE_REF function, pointed to a pkOID value in the CUSTOMER_
OV object view. The CUSTOMER_OV object view returned the record whose pkOID matched

the referenced value. The DEREF function then returned the value of the referenced row. The query
thus returned rows from CUSTOMER even though the user only queried CUSTOMER_CALL.
Object views of column objects enable you to work with tables as if they were both relational
tables and object-relational tables. When extended to row objects, object views enable you to
generate OID values based on established foreign key/primary key relationships. Object views
allow you to continue to use the existing constraints and standard insert, update, delete, and
select commands. They also allow you to use OOP features such as references against the object
tables. Object views thus provide an important technological bridge for migrating to an OOP
database architecture.
As described earlier in this chapter, Oracle performs joins that resolve the references defined
in the database. When the referenced data is retrieved, it brings back the entire row object that
was referenced. To reference the data, you need to establish pkOIDs in the table that is the
“primary key” table in the relationship, and use MAKE_REF to generate references in the table
that is the “foreign key” table in the relationship. You can then work with the data as if it were
stored in object tables.
660
Part V: Object-Relational Databases
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:660
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:26 PM
Color profile: Generic CMYK printer profile
Composite Default screen
Object PL/SQL
PL/SQL programs can use the abstract datatypes you have created. Whereas earlier versions of PL/SQL
could only use the Oracle-provided datatypes (such as DATE, NUMBER, and VARCHAR2), you
can now use your own user-defined datatypes as well. The result is the merging of SQL, procedural
logic, and OOP extensions—a combination referred to as
object PL/SQL.
The following anonymous PL/SQL block uses object PL/SQL concepts. The CUSTOMER_TY

abstract datatype is used as the datatype for the
Cust1
variable, and its value is populated by a
query of the CUSTOMER_OV object view.
set serveroutput on
declare
Cust1 CUSTOMER_TY;
begin
select VALUE(COV) into Cust1
from CUSTOMER_OV COV
where Customer_ID = 123;
DBMS_OUTPUT.PUT_LINE(Cust1.Name);
DBMS_OUTPUT.PUT_LINE(Cust1.Street);
end;
/
The output of this PL/SQL block is
SIGMUND
47 HAFFNER RD
In the first part of the PL/SQL block, a variable is declared using the CUSTOMER_TY datatype:
declare
Cust1 CUSTOMER_TY;
The
Cust1
variable value is selected from the CUSTOMER_OV object view (created in the
preceding section of this chapter). The VALUE function is used to retrieve the data in the structure
of the abstract datatype. Since the data will be selected in the format of the abstract datatype,
you need to use the CUSTOMER_OV object view created on the CUSTOMER table.
begin
select VALUE(COV) into Cust1
from CUSTOMER_OV COV

where Customer_ID = 123;
The Cust1.Name and Cust1.Street values are then retrieved from the attributes of the
Cust1
variable and displayed. You cannot pass the entire
Cust1
variable to the PUT_LINE procedure.
DBMS_OUTPUT.PUT_LINE(Cust1.Name);
DBMS_OUTPUT.PUT_LINE(Cust1.Street);
end;
Chapter 36: Advanced Object-Oriented Concepts
661
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:661
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:27 PM
Color profile: Generic CMYK printer profile
Composite Default screen
This is a deliberately simple example, but it shows the power of object PL/SQL. You can use
object PL/SQL anywhere you use abstract datatypes. Your PL/SQL is thus no longer bound to the
Oracle-provided datatypes, and may more accurately reflect the objects in your database. In this
example, an object view was queried to illustrate that the queries can access either column objects
or row objects. You can then select the attributes of the abstract datatype and manipulate or display
them. If you have defined methods for the abstract datatype, you can apply them as well.
For example, you can call the datatype’s constructor methods within your PL/SQL blocks. In
the following example, a variable named
NewCust
is defined using the CUSTOMER_TY datatype.
The
NewCust
variable is then set equal to a set of values using the CUSTOMER_TY constructor

method. The
NewCust
variable’s set of values is then inserted via the CUSTOMER_OV object view.
declare
NewCust CUSTOMER_TY;
begin
NewCust :=
CUSTOMER_TY(345,'NewCust','StreetVal', 'City','ST',00000);
insert into CUSTOMER_OV
values (NewCust);
end;
/
You can see the result of the insert by querying CUSTOMER_OV:
select Customer_ID, Name from CUSTOMER_OV;
CUSTOMER_ID NAME

123 SIGMUND
234 EVELYN
345 NewCust
In addition to calling constructor methods, you can call the methods you have created on
your abstract datatypes. If you will be comparing the values of variables that use the abstract
datatypes, you will need to define map or order methods for the datatypes. This capability allows
you to further extend object PL/SQL—you define the datatypes and the functions at the database
level, and they are callable within any of your PL/SQL programs. Object PL/SQL represents a
significant enhancement over traditional PL/SQL.
Objects in the Database
The features available in Oracle—column objects, row objects, and object extensions to PL/SQL—
enable you to implement objects in your database without sacrificing the investment you have
already made in analysis and design. You can continue to create systems based on relational
design techniques and tune them based on relational access methods. The tools that Oracle

provides allow you to create an OOP layer above your relational tables. Once you have that
layer in place, you can access the relational data as if it were stored in a fully OOP database.
Having an OOP layer allows you to realize some of the benefits of an OOP system, such as
abstraction and encapsulation. You can apply the methods for each abstract datatype across a set
662
Part V: Object-Relational Databases
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:662
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:28 PM
Color profile: Generic CMYK printer profile
Composite Default screen
of consistently implemented objects, and benefit from object reuse and standards enforcement.
At the same time, you can benefit from Oracle’s relational features. The ability to use both relational
and object technology within an application lets you use the proper tool for the proper job within
the database.
Note that implementing object-relational features may force you to change your approach
to data relationships and the tools you use to access the data. If you use row objects, the
relationships among tables are among row objects, not their data—possibly resulting in dangling
REFs. Additionally, unless you use object views you will need to use new SQL syntax for queries
and DML operations.
When implementing the object portion of an object-relational database, start by defining the
abstract datatypes that are the core components of your business. Every object-relational feature,
whether it relates to column objects or row objects, is based on an abstract datatype. The better
you have defined your datatypes and their methods, the better you will be able to implement objects.
If necessary, nest objects so that you can have multiple variations of the same core datatype. The
result will be a database that is properly designed to take advantage of both relational and object-
oriented features.
Chapter 36: Advanced Object-Oriented Concepts
663

ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 36
Blind Folio 36:663
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:28 PM
Color profile: Generic CMYK printer profile
Composite Default screen

ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:665
PART
VI
Java in Oracle
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:29 PM
Color profile: Generic CMYK printer profile
Composite Default screen
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:666
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:29 PM
Color profile: Generic CMYK printer profile
Composite Default screen
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:667
CHAPTER
37
An Introduction
to Java
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:29 PM

Color profile: Generic CMYK printer profile
Composite Default screen
668
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:668
I
n this chapter, you will see an overview of Java as it relates to Oracle database
applications. There are numerous uses of Java beyond Oracle applications, and there
are many features of the language that will not be used by most Oracle developers.
The goal of this chapter is to provide developers who have a background in SQL and
PL/SQL with an understanding of the Java language structures. This is not an exhaustive
review of Java (numerous books are available that accomplish that goal) but rather a short overview
of the Java language components most commonly used by Oracle developers.
Although in many cases PL/SQL and Java correlate well to each other, there are significant
differences in terminology and usage. That shouldn’t be surprising because the two programming
languages were developed independently. Furthermore, PL/SQL’s object oriented capabilities
were not part of its initial implementation, whereas Java has been object oriented since its inception.
To use Java effectively, you need to take a different approach than the one you may have taken
in the past with PL/SQL.
Chapter 29 presented an introduction to the PL/SQL language structures and flow control.
This chapter mirrors that approach: You will see the structures used by Java and the basic flow-
control methods provided. Where applicable, you will also see the matching PL/SQL structures.
You should be familiar with PL/SQL (Chapter 29); packages, functions, and procedures (Chapter 31);
and abstract datatypes and methods (Chapter 33) before reading this chapter.
Java vs. PL/SQL: An Overview
In comparing PL/SQL to Java, you get no further than the basic PL/SQL structure—a block—before
you encounter a significant difference in terminology between the two languages. In PL/SQL, a
block
is a structured piece of code that has a Declarations section, an Executable Commands section, and

an Exception Handling section. For a PL/SQL block, the structure may be represented as follows:
declare
<
declarations section>
begin
<
executable commands>
exception
<
exception handling>
end;
In Java, the term
block
refers to a much smaller subset of code. In Java, a block is a collection
of statements enclosed by curly braces, { and }. For example, the following pseudo-code contains
two Java blocks:
if (
some condition
) {
block of code to process if condition is met
}
else {
block of code to process if condition is not met
}
Within PL/SQL, that entire code section would be merely one part of a larger block; within
Java, it contains two separate blocks. Throughout this chapter, all references to “blocks” refer
to Java blocks unless otherwise specified.
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:30 PM
Color profile: Generic CMYK printer profile

Composite Default screen
A PL/SQL procedure is bound by a begin and end, whereas a Java method is bound by opening
and closing braces. These braces are also utilized to isolate individual blocks of scoped code, or
as indicators of the opening and closing of conditional segments.
A second major difference between PL/SQL and Java is in the declaration of variables. In a
PL/SQL block, you define your variables before you begin the Executable Commands section.
In a Java program, you can define variables where they are needed within the program. A Java
program has no Declarations section comparable to the one used in PL/SQL blocks.
Throughout this chapter, you will see a number of other differences between PL/SQL and Java.
It’s important to remember that Java does not replace PL/SQL within your applications—you can
continue to use PL/SQL for Oracle applications. For data-retrieval operations, you should test the
performance of PL/SQL and Java before deciding on a technical direction to follow.
Getting Started
To use the examples in this section, you need a copy of the Java Development Kit (JDK), which is
available for free download from You need to install the JDK on the server on
which you will be running the Java programs. As of the time of this writing, JDK 1.4 is the most
recent production release; most development efforts use JDK 1.3.1. At a minimum, you should use
JDK 1.2.2.
NOTE
The JDK is installed as part of the Oracle Database 10
g
installation.
Be sure to install both the database kernel software and the software
that comes on the Companion CD.
Declarations
Within Java, you can declare variables as needed. A variable has a name and a datatype, and it’s
used to store a data value during the program’s execution. A variable also has a scope, allowing
it to be publicly accessible or private—similar to the manner in which procedures within packages
can have private variables.
Here are examples of Java variable declarations:

char aCharVariable = 'J';
boolean aBooleanVariable = false;
By convention, Java variables always start with a lowercase letter, as shown in this example,
where the datatypes are CHAR and BOOLEAN, and each variable is assigned an initial value.
Note that the assignment character in Java is =, as opposed to := or => in PL/SQL. Each declaration
is terminated with a semicolon.
The available primitive datatypes in Java are listed in Table 37-1.
In addition to the primitive datatypes listed in Table 37-1, you can use reference datatypes,
which are based on the contents of variables. You may note that there is no primitive datatype for
variable-length character strings—Java provides a String class for that purpose. Classes are discussed
later in this chapter.
Chapter 37: An Introduction to Java
669
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:669
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:31 PM
Color profile: Generic CMYK printer profile
Composite Default screen
Executable Commands
You can assign values to variables via the use of expressions and statements. The arithmetic operators
supported by Java include the following:
Operator Description
* Multiplication
/ Division
+ Addition
– Subtraction
% Modulus
In addition to these operators, you can use Java’s unary operators to simplify your coding.
For example, you can increment variables via the ++ operator, as shown here:

aLoopCounter = aLoopCounter++;
Or you could simply write this:
aLoopCounter++
NOTE
The ++ operator is called a unary operator because it has only one
operand. If an operator requires two operands (such as *), it is called
a binary operator.
670
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:670
Datatype Description
Byte Byte-length integer
Short Short integer
Int Integer
Long Long integer
Float Single-precision floating-point real number
Double Double-precision floating-point real number
Char A single Unicode character
Boolean A Boolean value, true or false
TABLE 37-1.
Primitive Java Datatypes
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:31 PM
Color profile: Generic CMYK printer profile
Composite Default screen
In PL/SQL, that would have been written as follows:
aLoopCounter := aLoopCounter +1;
If the ++ operator is placed in front of the variable name, it is a
pre-increment

operator rather
than a
post-increment
operator:
int anotherCounter = ++aLoopCounter;
In this example, the variable
anotherCounter
is set to the incremented value of
aLoopCounter
.
By contrast,
int anotherCounter = aLoopCounter++;
sets
anotherCounter
to the value of
aLoopCounter
before it is incremented. You can decrement a
variable’s value via the unary operator:
aLoopCounter = aLoopCounter ;
You can also combine the assignment of values with an operation. For example, instead of
writing
aNumberVariable = aNumberVariable * 2;
you can write
aNumberVariable *= 2;
You can perform similar combinations using /=, %=, +=, and –=.
If you perform multiple arithmetic operations, you should use parentheses to clearly indicate
the order in which the operations should be evaluated, as shown in the following example:
aNumberVariable = (aNumberVariable*2) +2;
Terminating these operations with semicolons makes them
statements

—complete units of
execution.
Conditional Logic
You can evaluate variables by using expressions and statements. To do so, you may use one or
more of the fundamental classes provided as part of Java. A full listing of those methods is beyond
the scope of this book; see Sun’s Java documentation site or one of the many Java books available
for the functionality currently provided.
NOTE
The number of supplied classes usually changes dramatically with
each release of Java.
Chapter 37: An Introduction to Java
671
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:671
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:33 PM
Color profile: Generic CMYK printer profile
Composite Default screen
In the following listing, the Character.isUpperCase method is used to evaluate the
aCharVariable
variable declared earlier:
if (Character.isUpperCase(aCharVariable)) {
some commands to execute
}
If the
aCharVariable
value is uppercase, the commands in the following block will be executed;
otherwise, flow will continue to the next part of the program.
The following is the general syntax for if clauses:
if (

expression
) {
statement
}
Notice the lack of a then clause. If the expression being evaluated is true, the following block is
automatically executed. Also, note the lack of an end if clause. Java blocks are simply terminated
by the closing brace of the statement.
You can also have else clauses to evaluate different conditions, as shown in the following listing:
if (
expression
) {
statement
}
else {
statement
}
If you have multiple conditions to check, you can use the else if clause to evaluate each in
turn, ending with an else clause. The following listing illustrates the use of else if clauses:
if (aCharVariable == 'V') {
statement
}
else if (aCharVariable == 'J') {
statement
}
else {
statement
}
NOTE
PL/SQL supports the use of elsif clauses to choose between
alternatives. A single if clause can have multiple elsif clauses.

In addition to supporting if clauses for conditional logic, Java features a switch clause. Used
in conjunction with its break clause and statement labels, the switch clause can approximate the
functionality of goto clauses (which Java does not support). First, let’s look at a simple switch
example. Using the case statement, multiple values of the
aMonth
variable are evaluated. Depending
672
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:672
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:34 PM
Color profile: Generic CMYK printer profile
Composite Default screen
on the
aMonth
value, the text name for the month is displayed, and the processing leaves the
switch block by means of a break.
int aMonth=2;
switch (aMonth) {
case 1:
System.out.println("January");
break;
case 2:
System.out.println("February");
break;
case 3:
System.out.println("March");
break;
default:

System.out.println("Out of range");
break;
}
NOTE
In Java, the arguments of a case statement must be integers.
This kind of code is much more complex to write than a simple TO_CHAR, but it illustrates
the switch usage. The switch operator takes the
aMonth
variable as its input and then evaluates
its value. If the value matches a case value, the System.out.println method is called to print the
month’s name, and processing control leaves the switch block by means of a break. If the value
does not match one of the case clauses, the default option is executed.
Where does control go? By default, it goes to the next section of the program. However, you
have the option of creating labels for sections of your code and passing the names of those labels
to the break clause. The following listing shows an example of a label and a break clause:
somelabel:
if (aCharVariable == 'V') {
statement
}
else {
statement
}
int aMonth=2;
switch (aMonth) {
case 1:
System.out.println("January");
break somelabel;
case 2:
System.out.println("February");
break someotherlabel;

case 3:
System.out.println("March");
Chapter 37: An Introduction to Java
673
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:673
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:35 PM
Color profile: Generic CMYK printer profile
Composite Default screen
break somethirdlabel;
default:
System.out.println("Out of range");
break;
}
In this example, the if clause is evaluated, followed by the switch clause. Note that the
aMonth
variable is not declared until just before it is needed. For this example, the
aMonth
variable is
assigned a value of 2, so the program will display the word “February” and will then branch over
to the section of code identified by the someotherlabel label. If the
aMonth
value had been 1, the
if clause at the beginning of the code listing would have been reexecuted.
Java also supports a
ternary
operator—an operator that takes three operands and whose function
is similar to that of DECODE. Acting as an inline if-else combination, the ternary operator evaluates an
expression. If the expression evaluates to true, the second operand is returned; otherwise, the third is

returned. The syntax is as follows:
expression
?
operand1
:
operand2
The following listing shows a sample ternary operation:
aStatusVariable = (aCharVariable == 'V') ? "OK" : "Invalid";
In this example, the expression
(aCharVariable == 'V')
is evaluated. If it is true, “OK” is returned; otherwise, “Invalid” is returned.
You can use the ternary operator to simulate the use of a GREATEST function:
double greatest = (a > b) ? a : b;
In this example, the expression (a > b) is evaluated, where
a
and
b
are the names of variables. If that
expression is true,
a
’s value is returned; otherwise,
b
’s value is returned.
NOTE
Java has a “greatest” method for numeric values—the Max method
within the java.lang.Math class. The ternary example in the preceding
listing can be rewritten as double greatest = Math.Max(a, b);
You can combine multiple logic checks via the use of AND and OR operations. In Java, an AND
operation is represented by the && operator:
if (aCharVariable == 'V' && aMonth == 3) {

statement
}
The OR operation is represented by ||, as shown in the following listing:
674
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:674
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:36 PM
Color profile: Generic CMYK printer profile
Composite Default screen
if (aCharVariable == 'V' || aMonth == 3) {
statement
}
For performance reasons, the && and || operations are carried out only if required; the second
expression is not evaluated if the first expression determines the result. In the case of the AND
operator, if the first value is false, the evaluation ends at that point and the Boolean value false is
returned. In the case of the OR operator, if the first expression is false, the second expression will
still be evaluated because only one of the test conditions needs to be true for the Boolean value
true to be returned. If the first value of the OR operator were true, subsequent expressions would
not need to be evaluated and true would be returned.
The & and | operators are bitwise AND and OR; they are not short-circuited as && and || are.
All expressions will always be evaluated. This functionality can be important if you are testing the
return values of method calls and you need to make sure the methods are executed.
Loops
Java supports three main types of loops: WHILE loops, DO-WHILE loops, and FOR loops. In this
section, you will see examples of each type of loop. Because Java is not written as an extension
of SQL, it does not support Cursor FOR loops as PL/SQL does.
WHILE Loops and DO-WHILE Loops
A while clause evaluates a condition; if the condition is true, the associated block of statements

is executed. The syntax for a WHILE loop is of the following form:
while (
expression
) {
statement
statement
}
The WHILE loop executes the block of statements (the section within the { and } braces)
repeatedly until the
expression
is no longer true:
int aNumberVariable = 3;
while (aNumberVariable < 7) {
some_processing_statement
aNumberVariable++;
}
In this example, a counter variable
(aNumberVariable)
is created and initialized. The variable’s
value is then evaluated via the while clause. If the value is less than 7, the associated statement
block is executed. As part of that block, the variable is incremented. When the block completes,
the variable is again evaluated and the loop continues.
NOTE
For examples of WHILE loop processing, see “Classes” later in this
chapter.
Chapter 37: An Introduction to Java
675
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:675
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp

Friday, August 13, 2004 1:51:37 PM
Color profile: Generic CMYK printer profile
Composite Default screen
You could also write this as a DO-WHILE loop:
int aNumberVariable = 3;
do {
some_processing_statement
aNumberVariable++;
} while (aNumberVariable < 7);
In a DO-WHILE loop, the expression’s value is not evaluated until the block has been processed
at least one time.
FOR Loops
You can use a FOR loop to repeatedly execute a block of code. In a FOR loop, you specify an
initial value, a termination value, and an increment for the loop counter. The loop counter will
be incremented each time through the loop, by the increment you specify, until the termination
value is reached. The following is the syntax for a FOR loop:
for (
initialization
;
termination
;
increment
) {
statement
;
}
The prior section’s WHILE example can be rewritten with a for clause, as shown in the following
listing:
for (int aNumberVariable=3; aNumberVariable<7; aNumberVariable++) {
some_processing_statement

}
The for clause version for this example is much shorter than the while version. In this example,
the
aNumberVariable
variable is declared and initialized within the FOR loop. As long as the
variable’s value does not exceed 7, the block will be executed. For each pass through the loop,
the variable’s value is incremented by 1 via the ++ unary operator.
Within a loop, you can use the continue clause to jump to another statement within the loop.
If you just use the continue clause by itself, the process flow will jump to the end of the loop body
and evaluate the loop’s termination test. If you use continue with a label (as shown previously in
the section on the switch clause), processing will continue at the next iteration of the labeled loop.
Cursors and Loops
Within PL/SQL, you can use Cursor FOR loops to iterate through the results of a query. You can
use Java’s WHILE and FOR loops to simulate the functionality of a PL/SQL Cursor FOR loop. The
examples provided with Oracle show how this can be accomplished. Oracle provides sample
files on the Companion disc that accompanies the Oracle software installation. The Companion
disc uses the Oracle Universal Installer to load software drivers and demonstration files, including
those supporting JDBC development. Following installation of the Companion disc, the JDBC
examples will be in a file named demo.zip in the /jdbc/demo subdirectory under the Oracle
software home directory; when unzipped, the files referred to in this chapter will be located in
the /jdbc/demo/samples/generic subdirectory. The SelectEmployee.java demo issues the following
commands:
676
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:676
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:38 PM
Color profile: Generic CMYK printer profile
Composite Default screen

Statement stmt conn.createStatement();
ResultSet rset = stmt.executeQuery ("select FIRST_NAME, "
+ "LAST_NAME from EMPLOYEES");
// Iterate through the result and print the employee names
while (rset.next ())
System.out.println (rset.getString (1) + " " + rset.getString (2));
This example assumes that a connection to the database has already been established. The
first line of the example creates a variable called
stmt,
based on a connection variable called
conn
(not shown in this partial listing). The second line of the example creates a variable called
rset,
based on the result set that the query
stmt
will return. Following a comment (prefixed by // ), a
while clause fetches each row in the result set. If the fetch retrieves a row from the result set,
the ENAME from that EMP row is printed; otherwise, the loop will end.
From a programming perspective, you should be specific in the data returned (as in the preceding
example), specifying the column names to be returned.
The JDBC (Java Database Connectivity; see Chapter 38) demos provided by Oracle show
examples of queries involving procedure calls, LOBs, and DML. In most cases, your Java code
will be performing in a similar manner to the previous example: Write the process flow-control
language in Java and pass it a statement to execute. Based on the outcome of that statement, you
can direct different actions to occur via the use of while, for, if, break, continue, and switch clauses,
as shown earlier in this chapter.
Exception Handling
In a PL/SQL procedure, you have a single EXCEPTION block; in Java, you can have as many try/
catch blocks as you desire. Java provides a robust set of error-handling routines and enables you
to create complex error-handling procedures. In PL/SQL, you raise an exception; in Java, you

throw exceptions. If an exception is thrown, you need to use the Java catch clause to capture
and properly process the exception.
Java’s exception-handling syntax is based on three blocks: try, catch, and finally. The try block
includes the statements that might throw an exception. The catch block immediately following the
try block associates exception handlers with the exceptions that may be thrown by the try block.
The finally block cleans up any system resources not properly cleaned up during the catch block
processing. The general structure is as follows:
try {
statements
}
catch ( ) {
statements
}
catch ( ) {
statements
}
finally {
statements
}
Chapter 37: An Introduction to Java
677
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:677
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:39 PM
Color profile: Generic CMYK printer profile
Composite Default screen
For example, consider the following Java code:
try {
Statement stmt = conn.createStatement ();

stmt.execute ("drop table plsqltest");
}
catch (SQLException e) {
}
In this example, a variable named
stmt
is created to execute a drop table command. If the
execution fails—for example, if the table does not exist—how will that error be processed? The
catch clause tells Java to handle it via an exception object called SQLException, a standard part
of Java’s SQL implementation. As shown in the example, the catch clause takes two parameters
(an exception object and a variable name) and is optionally followed by a block of statements to
execute.
The try block can contain multiple statements, or you can create separate try blocks for each
statement. In general, it is easier to manage exception handling if you consolidate your catch blocks,
so consolidating your try blocks will help you manage your code as it changes and grows. The
when others clause in PL/SQL is essentially catch (Throwable th) in Java.
The finally block cleans up the state of the current code section before passing control to any
subsequent parts of the program. At run time, the contents of the finally block are always executed,
regardless of the outcome of the try block. For example, you could use the finally block to close
a database connection.
Reserved Words
The reserved words in Java are listed in Table 37-2. You cannot use these words as the names of
classes, methods, or variables.
678
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:678
abstract else interface super
boolean extends long switch
break false native synchronized

byte final new this
case finally null throw
catch float package throws
char for private transient
class goto protected true
const if public try
TABLE 37-2.
Reserved Words in Java
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:39 PM
Color profile: Generic CMYK printer profile
Composite Default screen
Classes
In the prior sections of this chapter, you saw the basic syntax structures for Java. In this section,
you will see how to use that syntax to create and use objects. A simple program for printing the
word “Oracle” is shown in the following listing:
public class HelloOracle {
public static void main (String[] args) {
System.out.println("Oracle");
}
}
This example creates a
class
called HelloOracle. Within the HelloOracle class, a public
method called
main
is created. The main method prints the word “Oracle.” This is significantly
more complex than
select 'Oracle' from dual;
but the Java version has features lacking in the SQL version. HelloOracle is a class, and as such

its methods can be called from within other classes. HelloOracle could have multiple methods;
in this example, it has only the main method.
The main method’s declaration (public static void main) has a number of keywords that you
should become familiar with:
public Defining the class as public allows all classes to call this method.
static Declares that this is a class method; you use static to declare class methods. An additional
option is the keyword final for methods and variables whose values cannot change (similar
to PL/SQL’s constant option).
void
Specifies the return value’s datatype from the procedure. Because this procedure does
not return values, its type is void.
In this example, the method is given the name
main
because that will simplify running the
class’s method. Now that the class has been created, you can compile and load it.
Chapter 37: An Introduction to Java
679
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:679
continue implements return void
default import short volatile
do instanceof static while
double int strictfp
TABLE 37-2.
Reserved Words in Java
(continued)
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:40 PM
Color profile: Generic CMYK printer profile
Composite Default screen

680
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:680
NOTE
To compile and execute a Java class, you must have the JDK on your
server. The following examples assume that the binaries that are part
of that kit are located in a directory that is automatically searched via
the PATH environment variable and that the directory containing your
class files is included in the CLASSPATH environment variable. The
programs referenced here (javac and java) are located in the /bin
subdirectory of the JDK software directory.
First, save the program as a plain text file called HelloOracle.java. Next, compile it:
javac HelloOracle.java
A new file, called HelloOracle.class, will be created on your server. You can then run the class:
java HelloOracle
Then the output will be displayed:
Oracle
As shown in the HelloOracle example, the class is first given a name, along with other optional
attributes related to its inheritance of other classes’ attributes. In the class body, all the class variables
and methods are defined. As with abstract datatypes in Oracle, Java classes have methods associated
with them for the manipulation of their related data.
Let’s consider a more complex example. The following listing is a Java program that computes
the area of a circle, given a radius value as input (see Chapter 29 for the PL/SQL version):
// AreaOfCircle.java
//
public class AreaOfCircle {
public static void main(String[] args) {
try {
int input = Integer.parseInt(args[0]);

double result=area(input);
System.out.println(result);
}
catch (ArrayIndexOutOfBoundsException oob) {
System.out.println("You did not provide the radius of the circle.");
System.out.println("Usage: java AreaOfCircle 10");
}
catch (NumberFormatException nfe) {
System.out.println("Enter a valid number for the radius.");
System.out.println("Usage: java AreaOfCircle 10");
}
} /// main
public static double area (int rad) {
double pi=3.1415927;
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:41 PM
Color profile: Generic CMYK printer profile
Composite Default screen
double areacircle=pi*rad*rad;
return areacircle;
} /// area
} ///AreaOfCircle
NOTE
Be sure to include a closing brace, }, for each block. In the examples
shown in this chapter, the closing braces are always on lines by
themselves to simplify debugging and processing flow-control errors
that may arise.
First, note that the class and the name of the file must be the same. In this case, the class is
named AreaOfCircle, so this text is stored in a file called AreaOfCircle.java. The class has two
methods, called main and area. When you execute the class, the main method is automatically

executed. The main method takes the string provided as input and parses it as an integer into the
input
variable:
int input=Integer.parseInt(args[0]);
There are at least two possible exceptions that could be thrown when running this code. The
first exception handled, ArrayIndexOutOfBoundsException, occurs when you try to reference a
position in an array that doesn’t exist. Because the code explicitly references the first position of
the array named args (args[0]), an exception will be thrown if no data was passed to the program.
The other possible error, NumberFormatException, would occur if a nonnumeric value was
passed in. For example, if you ran the program by entering “java AreaOfCircle XYZ” instead of
“java AreaOfCircle 123”, the NumberFormatException would be thrown because XYZ isn’t a
valid number. Both of these exceptions are handled by the two catch statements that provide the
user with useful feedback regarding the cause of the error:
catch (ArrayIndexOutOfBoundsException oob) {
System.out.println("You did not provide the radius of the circle.");
System.out.println("Usage: java AreaOfCircle 10");
}
catch (NumberFormatException nfe) {
System.out.println("Enter a valid number for the radius.");
System.out.println("Usage: java AreaOfCircle 10");
}
Next, a variable named
result
is declared and is set equal to the value returned by the call to
area(input):
double result=area(input);
To process that directive, the area method is executed using the
input
variable’s value as its
input. That method is as follows:

public static double area (int rad) {
double pi=3.1415927;
Chapter 37: An Introduction to Java
681
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:681
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:42 PM
Color profile: Generic CMYK printer profile
Composite Default screen
double areacircle=pi*rad*rad;
return areacircle;
}
In its definition, the area method specifies that it will accept one variable, an integer type named
rad. That variable’s value (passed from the input variable in the main method) is then processed, and
a variable named
areacircle
is calculated and returned to main. In main, that value is then printed:
double result=area(input);
System.out.println(result);
Testing the program is straightforward:
javac AreaOfCircle.java
java AreaOfCircle 10
The following is the output:
314.15927
Let’s extend this example to include WHILE loop processing. In this example, the area method
will be called repeatedly until the resulting input value exceeds a given value:
// AreaOfCircleWhile.java
//
public class AreaOfCircleWhile {

public static void main(String[] args) {
try {
int input=Integer.parseInt(args[0]);
while (input < 7) {
double result=area(input);
System.out.println(result);
input++;
}
}
catch (ArrayIndexOutOfBoundsException oob) {
System.out.println("You did not provide the radius of the circle.");
System.out.println("Usage: java AreaOfCircle 10");
}
catch (NumberFormatException nfe) {
System.out.println("Enter a valid number for the radius.");
System.out.println("Usage: java AreaOfCircle 10");
}
} /// main
public static double area (int rad) {
double pi=3.1415927;
double areacircle=pi*rad*rad;
return areacircle;
} /// area
} /// AreaOfCircleWhile
682
Part VI: Java in Oracle
ORACLE Series TIGHT / Oracle Database 10g: TCR / Loney / 225351-7 / Chapter 37
Blind Folio 37:682
P:\010Comp\Oracle8\351-7\CD\Ventura\book.vp
Friday, August 13, 2004 1:51:43 PM

Color profile: Generic CMYK printer profile
Composite Default screen