In this first example, you'll create a Java class named ch06_01 that will include a method named msg that will return the string "Hello from JSP!". We'll be able to call this method from JSP. To create a Java class, you use the Java class statement, which looks like this in general:

access class classname [extends ...] [implements ...] 
{
    [access] [static] type variable1;
        .
        .
        .
    [access] [static] type variableN;

    [access] [static] type method1 (parameter_list)
    {
        .
        .
        .
    }
    .
    .
    .
    [access] [static] type methodN (parameter_list)
    {
        .
        .
        .
    }
}

We'll get familiar with the parts of this statement in more detail in Day 11, “Creating More Powerful JavaBeans.” The access term specifies the accessibility of the class or class members to the rest of the program, and can be public, private, or protected. You use the extends and implements keywords with class inheritance, as we'll see in Day 11.

To create ch06_01.class, which is a compiled Java class file, you have to start with the actual Java code for this class, which you must store in a file named ch06_01.java. The class in this file will be named ch06_01, and you create it with the Java class statement:

public class ch06_01 
{
        .
        .
        .
}

Let's get started on the actual Java code here, starting by adding a constructor to our class.

You use a constructor to create an object from a class. In Java, a constructor is a method with the same name as the class itself, so that you can add a constructor to the ch06_01 class like this:

public class ch06_01 
{
    public ch06_01()
    {
    }
        .
        .
        .
}

Here, the code adds a method named ch06_01 to the ch06_01 class. This particular constructor doesn't do anything; it's a default constructor. Later today, you'll see how you can pass data to a constructor such as this to configure the object—in particular, you'll see how to use the constructor to set the text that the msg method will return. Now it's time to create the msg method.

The msg method is simply supposed to return the text "Hello from JSP!", and you don't pass any data to it. This is a method of the ch06_01 class, so you can make its definition part of that class, as you see in Listing 6.1.

public class ch06_01
{
    public ch06_01()
    {
    }

    public String msg()
    {
      return "Hello from JSP!";
    }
}

Note that this method is declared public. A public method such as this can be called from outside a class and any other classes based on this class. We have to make msg a public method so that it'll be accessible outside the ch06_01 class and we can call it from JSP.

That's all you need to start—you've created a public class, given it a default constructor, and added a method, msg, to it. The msg method will return our message when it's called, so let's take a look at calling that method from a JSP page now.

The first step in making the msg method accessible to our JSP code is to compile the file ch06_01.java, creating the file ch06_01.class. This is a step that the JSP server has been taking care of for us, but now that we want to compile a Java class, we'll handle this task ourselves.

In Day 1, “Getting Started!,” we set our computer's path to include the Java bin directory (such as C:jdk1.4in), which gives us access to the Java tools that we'll use here—in this case, we'll use the Java compiler, javac. Make sure that you're in the same directory as ch06_01.java, and enter javac ch06_01.java at the command prompt to compile ch06_01.java. For example, in Windows, that might look like

C:ch06>javac ch06_01.java 

This will compile ch06_01.java and create ch06_01.class in the same directory. This new file, ch06_01.class, is the file we're going to need so that our JSP code can call the msg method.

So where can we put ch06_01.class, so that we'll have access to it in a Web page? The examples for today go into the webappsch06 directory in the Tomcat directories. As we saw in Day 1, directories like the ch06 directory need a subdirectory named WEB-INF, which itself has two subdirectories, classes and lib:

webapps 
|____ch06
     |____WEB-INF
          |____classes
          |____lib

To give the JSP pages in the ch06 directory access to Java .class files, those .class files must go into the ch06WEB-INFclasses directory. That's all it takes to give your JSP code access to ch06_01.class—just put that file into the ch06WEB-INFclasses directory. Now we're ready to put this new Java class to work for us, and that's coming up next.

Our new Java class, ch06_01, is now installed—how do you use it in a Web page? You can start off by importing that class into our JSP page with the page directive (that you first saw in Day 1). The page directive's import attribute enables you to import a Java class to make it available to your JSP code. Here's how you can import the ch06_01 class:

<%@ page import="ch06_01" %> 
<HTML>
  <HEAD>
    <TITLE>Using a JavaBean</TITLE>
  </HEAD>
  <BODY>
        .
        .
        .
  </BODY>
</HTML>

Now you can create a new object of this class. This time the code will call this new object messager. This object will enable us to call the msg method to get the "Hello from JSP!" message:

<%@ page import="ch06_01" %> 
<HTML>
  <HEAD>
    <TITLE>Using a JavaBean</TITLE>
  </HEAD>
  <BODY>
    <H1>Using a JavaBean</H1>

    <% ch06_01 messager = new ch06_01(); %>
        .
        .
        .
  </BODY>
</HTML>

Now you have an object of the ch06_01 class, so you can call the msg method to get the message and display it, as you see in Listing 6.2.

<%@ page import="ch06_01" %>
<HTML>
  <HEAD>
    <TITLE>Using a JavaBean</TITLE>
  </HEAD>
  <BODY>
    <H1>Using a JavaBean</H1>

    <% ch06_01 messager = new ch06_01(); %>

    The message is: <%= messager.msg() %>

  </BODY>
</HTML>

You can see the results in Figure 6.1, where our call to the msg method was successful.

Figure 6.1. Calling a compiled Java method.

At this point, we've been able to create and compile a Java class, install it where the JSP server can find it, and call a method in that class.

Java provides an easy way of organizing your classes using Java packages. And if you use a Java package, you won't have to use the page directive to import your classes in JSP.

For example, you can put the Java code just developed into a new class that's part of a Java package. In this case, the package will be named beans. You can create this package in a .java file with the package statement, as you see in Listing 6.3.

package beans;

public class ch06_03
{
  public String msg() {
    return "Hello from JSP!";
  }

  public ch06_03()
  {
  }
}

Now when you compile this new file, ch06_03.java, you'll get ch06_03.class—but the public class in this .class file is no longer ch06_03. Instead, it's beans.ch06_03, because it's in the beans package. That's how you must refer to it now—as beans.ch06_03. And you can't put it into the classes directory anymore; you must put it into a directory named classeseans:

webapps 
|____ch06
     |____WEB-INF
          |____classes
          |    |____beans
          |____lib

In this way, the disk organization of your Java classes reflects the package you've put your classes in. You separate package names with a dot (.). For example, if we created a package named these.are.my.beans like this

package these.are.my.beans; 

public class ch06_03
{
  public String msg() {
        .
        .
        .

then we'd store our ch06_03.class file in the directory classes hesearemyeans:

webapps 
|____ch06
     |____WEB-INF
          |____classes
          |    |____these
          |         |____are
          |              |____my
          |                   |____beans
          |____lib

Now that we've placed our new class in a package named beans, how do we access that class? That's coming up next.

As far as our JSP page goes, all that's changed is the name of our class; instead of ch06_03, it's now beans.ch06_03. That means all you have to do is use that as the class name, as you see in Listing 6.4.

<HTML>
    <HEAD>
        <TITLE>Using a Java Package</TITLE>
    </HEAD>

    <BODY>
        <H1>Using a Java Package</H1>

    <% beans.ch06_03 messager = new beans.ch06_03(); %>
    The message is: <%= messager.msg() %>

    </BODY>
</HTML>

Notice that the page directive we used in our earlier non-package example ch06_02.jsp is gone. Now that we've put our Java class into a package, the new directory structure (specifically, the beans subdirectory of the classes directory) tells Tomcat where to find ch06_03.class. We don't need to import any class at all; Tomcat will do that for us automatically. You can see the results in Figure 6.2—now we're organizing our Java classes into packages.

Figure 6.2. Using a class from a Java package.

So far, our constructor hasn't done anything, but it's time to change that. Usually you use a Java class's constructor to configure an object when you create it, and we'll do that here. For example, we can pass the string we want the msg method to return to the constructor, storing that string internally.

Here's how it might look—in this case, the constructor for this class takes a String argument and stores it in an internal variable named msg. The msg method reads the text and returns it when you call this method; you can see how it all looks in Listing 6.5.

package beans;

public class ch06_05
{
    String msg;

    public ch06_05(String message)
    {
        msg = message;
    }

    public String msg() {
      return msg;
    }
}

Now you can pass data to this new constructor when you create a new object of this Java class, as you can see in Listing 6.6.

<HTML>
    <HEAD>
        <TITLE>Using a Constructor</TITLE>
    </HEAD>

    <BODY>
    <H1>Using a Constructor</H1>

    <% beans.ch06_05 messager = new beans.ch06_05("Hello from JSP!"); %>

    The message is: <%= messager.msg() %>
  </BODY>
</HTML>

And that's all there is to it—now you're able to configure the objects you create from Java classes with a constructor. You can see the results in Figure 6.3.

Figure 6.3. Using a constructor.

Actually, the Java classes we've been developing so far are not technically JavaBeans, they're just classes. A JavaBean must also expose properties.

JSP makes it easy to interact with Java classes and JavaBeans using the <jsp:useBean> element. You can use this element to create objects from JavaBeans (and then set and get property values using that object), and an in-depth look at this element is coming up next.

You've seen that you can create objects from Java classes without any special effort. But you can also use the <jsp:useBean> element to do the same thing. The <jsp:useBean> element is a convenience element in JSP that enables you to create an object of a Java class and give it an ID. You can then use that ID with two other elements, <jsp:getProperty> and <jsp:setProperty>, to get and set property values.

Let's take a look at the syntax of the <jsp:useBean> element. As discussed in the Introduction, this book uses the conventions of Java documentation for syntax such as this—here, | means “or,” items in bold are default settings, items in square brackets ([ and ]) are optional, and you must select one item of those that appear in curly braces ({ and } ):

<jsp:useBean id="ID" 
    scope="page|request|session|application"
{
    class="package.class" [ type="package.class" ]|
    beanName="{package.class | <%= expression %>}"
        type="package.class" |
    type="package.class"
}
{ /> | > other elements </jsp:useBean> }

Let's take a look at the attributes of this element:

Here's an example that puts <jsp:useBean> to work. We've already seen this code, which creates an object from ch06_03.class and calls that object's msg method:

<% beans.ch06_03 messager = new beans.ch06_03(); %> 
The message is: <%= messager.msg() %>

Here's how to do the same thing with <jsp:useBean>. In this case, you can create a new bean with the ID bean1 from the same class, ch06_03.class (internally, Java actually uses the new operator to create this new object). Then you can refer to that bean with that ID—for example, you can call the bean's msg method as bean1.msg, as you see in Listing 6.7.

<HTML>
    <HEAD>
        <TITLE>Using &lt;jsp:useBean&gt;</TITLE>
    </HEAD>

    <BODY>
    <H1>Using &lt;jsp:useBean&gt;</H1>

    <jsp:useBean id="bean1" class="beans.ch06_03" />

    The message is: <%= bean1.msg() %>
  </BODY>
</HTML>

You can see this Web page in Figure 6.4, where we've used <jsp:useBean> to create a new Java object.

Figure 6.4. Using the <jsp:useBean> element.

The <jsp:useBean> element is designed to be used with two other elements—the <jsp:getProperty> and <jspSetProperty> elements, which enable you to work with bean properties. We'll look at how to create a property in a JavaBean next.

A property is a data item that you store in a JavaBean. For example, suppose you have a property named color. You can store various strings, such as red, blue, and so on in the color property, and the bean can use that property's value to configure the HTML it returns from other methods.

To support a JavaBean property, you use get and set methods. For example, for the color property, you'd add getColor and setColor methods to the bean. Note that you capitalize “color” in getColor and setColor, even though the actual property name is color—Java will expect these methods to exist, so it can work with the color property. If your property was named myFavoriteProperty, you would use the get and set methods getMyFavoriteProperty and setMyFavoriteProperty.

In this case, you can add a property named message that returns our message from the bean. You can start by only adding a get method, which means this property will be read-only (there's no set method to set its value). In particular, this code will enable Java to read the value of this property with a method named getMessage, as you see in Listing 6.8.

package beans;

public class ch06_08
{

    private String message = "Hello from JSP!";

    public String getMessage()
    {
        return message;
    }

    public ch06_08()
    {
    }
}

Note that in addition to the getMessage method, the code has also declared a variable with the same name as the property, message. Java will expect to find a variable with the same name as the property this way, because that tells Java what the data type of the property is.

You might also note that the code has declared the string variable message to be private here. That means it's not accessible outside objects of this class—instead, you must access its value with the getMessage method. If you made this variable public instead (such as this: public String message = "Hello from JSP!";), you can access it in JSP code directly as object.message, as in this code:

<% beans.ch06_05 messager = new beans.ch06_08; %> 
The message is: <%= messager.message %>

However, this gives the JSP code direct access to the message variable, which means it can change that variable's value. To avoid such tampering, it has become standard in JavaBeans to use get and set methods to create a well-defined way of accessing property values—for example, if some JSP code tried to set a property named height to a negative value, the property's set method can detect that and not store that value in the property.

That's all we need to let Java read the value of this property. How do you read that value in JSP? You use the <jsp:getProperty> element.

You use the <jsp:getProperty> element to return the value of a property. Here's the syntax for this element:

<jsp:getProperty name="ID" property="propertyName" /> 

Here are the attributes of this element:

Here's how you can use <jsp:getProperty> to get the value of the message property—all you have to do is use <jsp:useBean> to create an object named, say, bean1, and then get the value of the message property, as you see in Listing 6.9.

<HTML>
    <HEAD>
        <TITLE>Getting a Property Value</TITLE>
    </HEAD>

    <BODY> element> element> element>
    <H1>Getting a Property Value</H1>

    <jsp:useBean id="bean1" class="beans.ch06_08" />

    The message is: <jsp:getProperty name="bean1" property="message" />
    </BODY>
</HTML>

You can see the results in Figure 6.5.

Figure 6.5. Getting a property's value.

Now we can get the value of a property in a JavaBean. It's worth noting that you can also use <jsp:getProperty> inside a <jsp:useBean> element:

The message is: 
<jsp:useBean id="bean1" class="beans.ch06_08">
    <jsp:getProperty name="bean1" property="message" />
</jsp:useBean>

Note, however, that this will only work if the enclosing <jsp:useBean> element creates the object you're accessing with <jsp:getProperty>; if the object already exists (that is, was created by another <jsp:useBean> element), the elements in the <jsp:useBean> element are not executed.

That's how to get the value of a property—now what about setting a property's value?

To let Java set the value of a property, you can use a set method. For example, to let our JSP code set the message our bean will return, we can add a method named setMessage to set the value of the message property. You can see what that might look like in Listing 6.10.

package beans;

public class ch06_10
{

    private String message = "Hello from JSP!";

    public void setMessage(String msg)
    {
        this.message = msg;
    }

    public String getMessage()
    {
        return this.message;
    }

    public ch06_10()
    {
    }
}

Note the keyword this here. In Java, this keyword always refers to the current object. In other words, this.message refers to the private variable message created and stored in this object:

private String message = "Hello from JSP!"; 

public void setMessage(String msg)
{
    this.message = msg;
}

The this keyword is a handy one to know now that you're creating Java objects—you can always use it in code to refer to the current object. As you've seen, it's not technically necessary to use the this keyword when you're referring to an object's data from code in that object (in fact, Java will use it automatically if you omit it), but you'll sometimes see it done for clarity. It can also prevent ambiguity when a function argument has the same name as a variable.

To actually set the value of the message property in JSP code, you can use the <jsp:setProperty> element.

You use <jsp:setProperty> to set property values in JSP. You can pass your own values, or automatically pass values from the request object. Here's the syntax of this element:

<jsp:setProperty name="ID" 
{
   property="*" |
   property="propertyName" [ param="parameterName" ] |
   property="propertyName" value="{stringLiteral| <%= expression %>}"
}
/>

Here are the attributes of this element:

Here's an example that puts <jsp:setProperty> to work using the set method setMessage that we've added to our example. In this case, we'll first display the default message that this property holds, and then use <jsp:setProperty> to set it to a new message, as you see in Listing 6.11.

<HTML>
    <HEAD>
        <TITLE>Setting a Property Value</TITLE>
    </HEAD>

    <BODY>
        <H1>Setting a Property Value</H1>

        <jsp:useBean id="bean1" class="beans.ch06_10" />

        The message is: <jsp:getProperty name="bean1" property="message" />
        <BR>
       <jsp:setProperty name="bean1" property="message" value="Hello again!" />

       Now the message is: <jsp:getProperty name="bean1" property="message" />
    </BODY>
</HTML>

And that's all it takes—you can see the results in Figure 6.6, where we see that we were indeed able to set a bean's property.

Figure 6.6. Setting a property value.

Here's one more thing we should note in passing. We've stored our property using a private variable in our Java code—doing so helps hide that data from external tampering. You can also create private methods that are purely internal to the current object, and cannot be called from outside the object. This is a good idea if you're using methods that you only want to call from inside the object. Such methods might help in performing internal calculations, for example. Using private methods can help organize your objects, wrapping up all their functionality into a self-contained entity.

Here's an example that shows how this works—in this case, you can just add a private method named privateMessage that will return the object's message, and call the method in the message property's get method, as you see in Listing 6.12.

package beans;

public class ch06_12
{

    private String message = "Hello from JSP!";

    public void setMessage(String msg)
    {
        this.message = msg;
    }

    public String getMessage()
    {
        return privateMessage();
    }

    private String privateMessage()
    {
        return this.message;
    }

    public ch06_12()
    {
    }
}

You can see a JSP page that uses this new class in Listing 6.13.

<HTML>
    <HEAD>
        <TITLE>Calling a Private Method</TITLE>
    </HEAD>

    <BODY>
        <H1>Calling a Private Method</H1>

        <jsp:useBean id="bean1" class="beans.ch06_12" />

        The message is: <jsp:getProperty name="bean1" property="message" />
        <BR>
        <jsp:setProperty name="bean1" property="message" value="Hello again!" />

        Now the message is: <jsp:getProperty name="bean1" property="message" />
    </BODY>
</HTML>

You can see the results in Figure 6.7—now we've created private methods purely internal to a Java object.

Figure 6.7. Using private methods.

Now that you're digging into the depths of Java, it's a good idea to take a look at the first of several Java utility classes that you'll see throughout the book. These utility classes are an important part of Java programming. Here you'll see the Date class, which is in the package named java.util.

The Date class enables you to create objects that represent a specific instant in time. This class is a popular one in Java programming among JSP programmers, because it enables you to keep track of dates and times. For example, you can see a JSP page that displays the date and time in Listing 6.14.

<HTML>
    <HEAD>
        <TITLE>Using the Date Class</TITLE>
    </HEAD>

    <BODY>
        <H1>Using the Date Class</H1>

        The date is: <%= new java.util.Date() %>.
    </BODY>
</HTML>

You can see the results in Figure 6.8.

Figure 6.8. Getting the date.

Before Java version 1.1, you could also use the Date class to get the day of the month, year, hour, and so on separately, but that's gotten more complex. Now, the Calendar class should be used to get that kind of information. The original methods in the Date class are deprecated, as you'll see.

You should know that there are certain conventions used to represent months, days of the month, and so on, in the Date class:

You can see the Date class's methods in Table 6.1.

As you can see in Table 6.1, many of the Date class's methods that let you get the hour, day, minute, and so on are now deprecated in favor of the Calendar class. The reason is that the Date class wasn't prepared for internationalization. Using the Date class together with various Calendar classes, on the other hand, enables you to work with times in any international locale.

GregorianCalendar calendar = new GregorianCalendar(); 
Date date1 = new Date();
calendar.setTime(date1);
out.println("Calendar.YEAR is " + calendar.get(Calendar.YEAR) + "<BR>");

The fields of a class are its data members—that is, variables available publicly or to classes based on the current class. When a field name is in capital letters (like YEAR), that's a Java convention—it means the field is a constant, and its value can't be changed (these are static data members, and you declare them in Java with the static keyword). You can see the fields of the Calendar class in Table 6.2. You can also set the time in a GregorianCalendar object using the set method such as in the following, where the code is setting the time to 23:59 (one minute before midnight) on 11/31/2005:

calendar.set(2005, 11, 31, 23, 59); 

Here's an example putting these fields to work—you can find the current year, month, and so on and then reset the Calendar object to 23:59 on 11/31/2005 and display the various Calendar fields again, as you see in Listing 6.15.

<%@ page import="java.util.*" %>
<HTML>
    <HEAD>
        <TITLE>Fields of the Calendar Class</TITLE>
    </HEAD>

    <BODY>
        <H1>Fields of the Calendar Class</H1>
        <%
            String dateString = new String();

            GregorianCalendar calendar = new GregorianCalendar();
            Date date1 = new Date();
            calendar.setTime(date1);

            dateString += "Calendar.YEAR is " + calendar.get (Calendar.YEAR) + "<BR>";
            dateString += "Calendar.MONTH is " + calendar.get (Calendar.MONTH) + "<BR>";
            dateString += "Calendar.WEEK_OF_YEAR is " + calendar.get (Calendar
.WEEK_OF_YEAR) + 
                "<BR>";
            dateString += "Calendar.WEEK_OF_MONTH is " + calendar.get (Calendar.WEEK_OF_MONTH)
                + "<BR>";
            dateString += "Calendar.DATE is " + calendar.get (Calendar.DATE) + "<BR>";
            dateString += "Calendar.DAY_OF_MONTH is " + calendar.get (Calendar.DAY_OF_MONTH) +
                "<BR>";
            dateString += "Calendar.DAY_OF_YEAR is " + calendar.get(Calendar.DAY_OF_YEAR) +
                "<BR>";
            dateString += "Calendar.DAY_OF_WEEK is " + calendar.get (Calendar.DAY_OF_WEEK) +
                "<BR>";
            dateString += "Calendar.DAY_OF_WEEK_IN_MONTH is "
                + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH) + "<BR>";
            dateString += "Calendar.AM_PM is " + calendar.get(Calendar.AM_PM)  + "<BR>";
            dateString += "Calendar.HOUR is " + calendar.get(Calendar.HOUR)  + "<BR>";
            dateString += "Calendar.HOUR_OF_DAY is " + calendar.get (Calendar.HOUR_OF_DAY) +
                "<BR>";
            dateString += "Calendar.MINUTE is " + calendar.get(Calendar.MINUTE)  + "<BR>";
            dateString += "Calendar.SECOND is " + calendar.get(Calendar.SECOND)  + "<BR>";
            dateString += "Calendar.MILLISECOND is " + calendar.get (Calendar.MILLISECOND) +
                "<BR>";

            dateString += "Resetting the date!<BR>";

            calendar.set(2005, 11, 31, 23, 59);

            dateString += "Calendar.YEAR is " + calendar.get(Calendar.YEAR)  + "<BR>";
            dateString += "Calendar.MONTH is " + calendar.get(Calendar.MONTH) + "<BR>";
            dateString += "Calendar.WEEK_OF_YEAR is " + calendar.get (Calendar
.WEEK_OF_YEAR) +
                "<BR>";
            dateString += "Calendar.WEEK_OF_MONTH is " + calendar.get (Calendar.WEEK_OF_MONTH)
                + "<BR>";
            dateString += "Calendar.DATE is " + calendar.get(Calendar.DATE)  + "<BR>";
            dateString += "Calendar.DAY_OF_MONTH is " + calendar.get (Calendar.DAY_OF_MONTH) +
                "<BR>";
            dateString += "Calendar.DAY_OF_YEAR is " + calendar.get (Calendar.DAY_OF_YEAR) +
                "<BR>";
            dateString += "Calendar.DAY_OF_WEEK is " + calendar.get (Calendar.DAY_OF_WEEK) +
                "<BR>";
            dateString += "Calendar.DAY_OF_WEEK_IN_MONTH is "
                + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH) + "<BR>";
            dateString += "Calendar.AM_PM is " + calendar.get(Calendar.AM_PM)  + "<BR>";
            dateString += "Calendar.HOUR is " + calendar.get(Calendar.HOUR) + "<BR>";
            dateString += "Calendar.HOUR_OF_DAY is " + calendar.get (Calendar.HOUR_OF_DAY) +
                "<BR>";
            dateString += "Calendar.MINUTE is " + calendar.get(Calendar.MINUTE)  + "<BR>";
            dateString += "Calendar.SECOND is " + calendar.get(Calendar.SECOND)  + "<BR>";
            dateString += "Calendar.MILLISECOND is " + calendar.get (Calendar.MILLISECOND) +
                "<BR>";
            out.println(dateString);
        %>
    </BODY>
</HTML>

You can see the results in Figure 6.9, where you see the year, month, day, and so on.

Figure 6.9. Fields of the Calendar class.

Today you learned how to create Java classes, and JavaBeans that support properties.

In particular, you learned how to use the Java class statement to create Java classes. You also saw that you can place a constructor into a class, and that you can pass data to that constructor.

The <jsp:useBean> element enables you to create an object from a Java class or JavaBean. We've seen that you can use this element to name an object when it's created, so that it's accessible elsewhere in your code.

The <jsp:getProperty> element enables you to get the value of the property of a bean.

The <jsp:setProperty> element enables you to set the value of a bean's properties, including letting you set properties of the same name as request parameters automatically.

Finally, the Date class enables you to store dates and times. To access the individual day, month, year, and other fields in a Date object, you use a class based on the Calendar class, such as the GregorianCalendar class.

This workshop tests whether you understand all the concepts you learned today. It's a good idea to master today's concepts by honing your knowledge here before starting tomorrow's material. You can find the answers to the quiz questions in Appendix A.